/* packet-fcels.c

 * Routines for FC Extended 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

 */

/*

 * TODO Still (Complete compliance with FC-MI):

 * - Decode RNID, RLIR

 */

/* AI generated:

 * Fibre Channel (FC) Extended Link Services (ELS) is a protocol used for managing communication between ports (Nx_Ports)

 * within a Fibre Channel fabric. While Basic Link Services are single-frame commands, ELS requests and replies are

 * transmitted within their own independent Exchanges.

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/tfs.h>

#include <epan/expert.h>

#include "packet-fc.h"

#include "packet-fcels.h"

void proto_register_fcels(void);

void proto_reg_handoff_fcels(void);

static dissector_handle_t els_handle;

#define FC_ELS_RPLY 0

#define FC_ELS_REQ  1

/* Initialize the protocol and registered fields */

static int proto_fcels;

static int hf_fcels_opcode;

static int hf_fcels_rjtcode;

static int hf_fcels_rjtdetcode;

static int hf_fcels_vnduniq;

static int hf_fcels_b2b;

static int hf_fcels_cmnfeatures;

static int hf_fcels_bbscnum;

static int hf_fcels_rcvsize;

static int hf_fcels_maxconseq;

static int hf_fcels_reloffset;

static int hf_fcels_edtov;

static int hf_fcels_npname;

static int hf_fcels_fnname;

#if 0

static int hf_fcels_cls1param;

static int hf_fcels_cls2param;

static int hf_fcels_cls3param;

static int hf_fcels_cls4param;

#endif

static int hf_fcels_vendorvers;

static int hf_fcels_svcavail;

static int hf_fcels_clsflags;

static int hf_fcels_clsrcvsize;

static int hf_fcels_conseq;

static int hf_fcels_e2e;

static int hf_fcels_openseq;

static int hf_fcels_nportid;

static int hf_fcels_oxid;

static int hf_fcels_rxid;

static int hf_fcels_recovqual;

static int hf_fcels_fabricaddr;

static int hf_fcels_fabricpname;

static int hf_fcels_failedrcvr;

static int hf_fcels_flacompliance;

static int hf_fcels_loopstate;

static int hf_fcels_publicloop_bmap;

static int hf_fcels_pvtloop_bmap;

static int hf_fcels_alpa_map;

static int hf_fcels_scrregn;

static int hf_fcels_farp_matchcodept;

static int hf_fcels_farp_respaction;

static int hf_fcels_resportid;

static int hf_fcels_respname;

static int hf_fcels_respnname;

static int hf_fcels_reqipaddr;

static int hf_fcels_respipaddr;

static int hf_fcels_hardaddr;

static int hf_fcels_rps_flag;

static int hf_fcels_rps_portnum;

static int hf_fcels_rps_portstatus;

static int hf_fcels_rnft_fc4type;

static int hf_fcels_rscn_evqual;

static int hf_fcels_rscn_addrfmt;

static int hf_fcels_rscn_domain;

static int hf_fcels_rscn_area;

static int hf_fcels_rscn_port;

static int hf_fcels_rec_fc4;

static int hf_fcels_estat;

static int hf_fcels_estat_resp;

static int hf_fcels_estat_seq_init;

static int hf_fcels_estat_compl;

static int hf_fcels_nodeidfmt;

static int hf_fcels_spidlen;

static int hf_fcels_vendoruniq;

static int hf_fcels_vendorsp;

static int hf_fcels_asstype;

static int hf_fcels_physport;

static int hf_fcels_attnodes;

static int hf_fcels_nodemgmt;

static int hf_fcels_ipvers;

static int hf_fcels_tcpport;

static int hf_fcels_ip;

static int hf_fcels_cbind_liveness;

static int hf_fcels_cbind_addr_mode;

static int hf_fcels_cbind_ifcp_version;

static int hf_fcels_cbind_userinfo;

static int hf_fcels_cbind_snpname;

static int hf_fcels_cbind_dnpname;

static int hf_fcels_cbind_status;

static int hf_fcels_chandle;

static int hf_fcels_unbind_status;

static int hf_fcels_cmn_cios;

static int hf_fcels_cmn_rro;

static int hf_fcels_cmn_vvv;

static int hf_fcels_cmn_b2b;

static int hf_fcels_cmn_e_d_tov;

static int hf_fcels_cmn_simplex;

static int hf_fcels_cmn_multicast;

static int hf_fcels_cmn_broadcast;

static int hf_fcels_cmn_security;

static int hf_fcels_cmn_clk;

static int hf_fcels_cmn_dhd;

static int hf_fcels_cmn_seqcnt;

static int hf_fcels_cmn_payload;

static int hf_fcels_cls_cns;

static int hf_fcels_cls_sdr;

static int hf_fcels_cls_prio;

static int hf_fcels_cls_nzctl;

static int hf_fcels_initctl;

static int hf_fcels_initctl_initial_pa;

static int hf_fcels_initctl_ack0;

static int hf_fcels_initctl_ackgaa;

static int hf_fcels_initctl_sync;

static int hf_fcels_rcptctl;

static int hf_fcels_rcptctl_ack0;

static int hf_fcels_rcptctl_interlock;

static int hf_fcels_rcptctl_policy;

static int hf_fcels_rcptctl_category;

static int hf_fcels_rcptctl_sync;

static int hf_fcels_fcpflags;

static int hf_fcels_fcpflags_trireq;

static int hf_fcels_fcpflags_trirep;

static int hf_fcels_fcpflags_retry;

static int hf_fcels_fcpflags_ccomp;

static int hf_fcels_fcpflags_datao;

static int hf_fcels_fcpflags_initiator;

static int hf_fcels_fcpflags_target;

static int hf_fcels_fcpflags_rdxr;

static int hf_fcels_fcpflags_wrxr;

static int hf_fcels_prliloflags;

static int hf_fcels_tprloflags_opav;

static int hf_fcels_tprloflags_rpav;

static int hf_fcels_tprloflags_npv;

static int hf_fcels_tprloflags_gprlo;

static int hf_fcels_speedflags;

static int hf_fcels_speedflags_1gb;

static int hf_fcels_speedflags_2gb;

static int hf_fcels_speedflags_4gb;

static int hf_fcels_speedflags_10gb;

static int hf_fcels_prliloflags_opav;

static int hf_fcels_prliloflags_ipe;

static int hf_fcels_prliloflags_eip;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_fcels_rnft_index_of_first_rec_in_list;

static int hf_fcels_lip_f7_received_count;

static int hf_fcels_recovery_qualifier_status;

static int hf_fcels_rpl_port_identifier;

static int hf_fcels_rpl_index_of_i_port_block;

static int hf_fcels_lip_f7_initiated_count;

static int hf_fcels_srl_fl_port_addr;

static int hf_fcels_loss_of_signal_count;

static int hf_fcels_lirr_regn_function;

static int hf_fcels_rscn_page_len;

static int hf_fcels_prlilo_service_parameter_response;

static int hf_fcels_prlilo_type_code_extension;

static int hf_fcels_rnft_list_length;

static int hf_fcels_rpl_index;

static int hf_fcels_rpl_physical_port;

static int hf_fcels_prlilo_originator_pa;

static int hf_fcels_rpl_list_length;

static int hf_fcels_common_identification_data_length;

static int hf_fcels_loss_of_sync_count;

static int hf_fcels_lip_reset_received_count;

static int hf_fcels_rpl_max_size;

static int hf_fcels_prlilo_response_code;

static int hf_fcels_invalid_crc_count;

static int hf_fcels_rscn_payload_len;

static int hf_fcels_link_failure_count;

static int hf_fcels_prlilo_3rd_party_n_port_id;

static int hf_fcels_lip_al_ps;

static int hf_fcels_prlilo_type;

static int hf_fcels_lirr_regn_format;

static int hf_fcels_srl_flag;

static int hf_fcels_prlilo_page_length;

static int hf_fcels_rpl_payload_length;

static int hf_fcels_rpsc_port_oper_speed;

static int hf_fcels_lip_reset_initiated_count;

static int hf_fcels_l_port_status;

static int hf_fcels_primitive_seq_protocol_err;

static int hf_fcels_rnft_max_size;

static int hf_fcels_lip_f8_received_count;

static int hf_fcels_rnft_index;

static int hf_fcels_rnft_payload_len;

static int hf_fcels_prlilo_payload_length;

static int hf_fcels_prlilo_responder_pa;

static int hf_fcels_rpsc_number_of_entries;

static int hf_fcels_prlilo_3rd_party_originator_pa;

static int hf_fcels_invalid_xmission_word;

static int hf_fcels_rnft_fc4_qualifier;

static int hf_fcels_lip_f8_initiated_count;

static int hf_fcels_rpl_port_name;

static int ett_fcels;

static int ett_fcels_lsrjt;

static int ett_fcels_acc;

static int ett_fcels_logi;

static int ett_fcels_logi_cmnsvc;

static int ett_fcels_logi_clssvc;

static int ett_fcels_logo;

static int ett_fcels_abtx;

static int ett_fcels_rsi;

static int ett_fcels_rrq;

static int ett_fcels_rec;

static int ett_fcels_prli;

static int ett_fcels_prli_svcpg;

static int ett_fcels_adisc;

static int ett_fcels_farp;

static int ett_fcels_rps;

static int ett_fcels_rpl;

static int ett_fcels_rplpb;

static int ett_fcels_fan;

static int ett_fcels_rscn;

static int ett_fcels_rscn_rec;

static int ett_fcels_estat;

static int ett_fcels_scr;

static int ett_fcels_rnft;

static int ett_fcels_rnft_fc4;

static int ett_fcels_lsts;

static int ett_fcels_rnid;

static int ett_fcels_rlir;

static int ett_fcels_lirr;

static int ett_fcels_srl;

static int ett_fcels_rpsc;

static int ett_fcels_cbind;

static int ett_fcels_cmnfeatures;

static int ett_fcels_clsflags;

static int ett_fcels_initctl;

static int ett_fcels_rcptctl;

static int ett_fcels_fcpflags;

static int ett_fcels_prliloflags;

static int ett_fcels_speedflags;

static expert_field ei_fcels_src_unknown;

static expert_field ei_fcels_dst_unknown;

static expert_field ei_fcels_no_record_of_els_req;

static expert_field ei_fcels_no_record_of_exchange;

static expert_field ei_fcels_short_payload;

static int * const hf_fcels_estat_fields[] = {

    &hf_fcels_estat_resp,

    &hf_fcels_estat_seq_init,

    &hf_fcels_estat_compl,

    NULL

};

static const true_false_string tfs_fcels_estat_resp = {

        "Responding to Exchange",

        "Originator of Exchange"

};

static const true_false_string tfs_fcels_estat_seq_init = {

        "Seq Initiative held by REC responder",

        "Seq Initiative not held by REC responder"

};

#define FC_ESB_ST_RESP      (1U << 31)   /* responder to exchange */

#define FC_ESB_ST_SEQ_INIT  (1U << 30)   /* holds sequence initiative */

#define FC_ESB_ST_COMPLETE  (1U << 29)   /* exchange is complete */

static const value_string fc_els_proto_val[] = {

    {FC_ELS_LSRJT        , "LS_RJT"},

    {FC_ELS_ACC          , "ACC"},

    {FC_ELS_PLOGI        , "PLOGI"},

    {FC_ELS_FLOGI        , "FLOGI"},

    {FC_ELS_LOGOUT       , "LOGO"},

    {FC_ELS_ABTX         , "ABTX"},

    {FC_ELS_RSI          , "RSI"},

    {FC_ELS_RTV          , "RTV"},

    {FC_ELS_RLS          , "RLS"},

    {FC_ELS_ECHO         , "ECHO"},

    {FC_ELS_TEST         , "TEST"},

    {FC_ELS_RRQ          , "RRQ"},

    {FC_ELS_REC          , "REC"},

    {FC_ELS_SRR          , "SRR"},

    {FC_ELS_PRLI         , "PRLI"},

    {FC_ELS_PRLO         , "PRLO"},

    {FC_ELS_TPRLO        , "TPRLO"},

    {FC_ELS_PDISC        , "PDISC"},

    {FC_ELS_FDISC        , "FDISC"},

    {FC_ELS_ADISC        , "ADISC"},

    {FC_ELS_FARP_REQ     , "FARP-REQ"},

    {FC_ELS_FARP_RPLY    , "FARP-REPLY"},

    {FC_ELS_RPS          , "RPS"},

    {FC_ELS_RPL          , "RPL"},

    {FC_ELS_FAN          , "FAN"},

    {FC_ELS_RSCN         , "RSCN"},

    {FC_ELS_SCR          , "SCR"},

    {FC_ELS_RNFT         , "RNFT"},

    {FC_ELS_LINIT        , "LINIT"},

    {FC_ELS_LSTS         , "LSTS"},

    {FC_ELS_RNID         , "RNID"},

    {FC_ELS_RLIR         , "RLIR"},

    {FC_ELS_LIRR         , "LIRR"},

    {FC_ELS_SRL          , "SRL"},

    {FC_ELS_RPSC         , "RPSC"},

    {FC_ELS_LKA          , "LKA"},

    {FC_ELS_AUTH         , "AUTH"},

    {FC_ELS_CBIND        , "CBIND"},

    {FC_ELS_UNBIND       , "UNBIND"},

    {0, NULL}

};

value_string_ext fc_els_proto_val_ext = VALUE_STRING_EXT_INIT(fc_els_proto_val);

/* Reject Reason Codes */

#define FC_ELS_RJT_INVCMDCODE   0x01

#define FC_ELS_RJT_LOGERR       0x03

#define FC_ELS_RJT_LOGBSY       0x05

#define FC_ELS_RJT_PROTERR      0x07

#define FC_ELS_RJT_GENFAIL      0x09

#define FC_ELS_RJT_CMDNOTSUPP   0x0B

#define FC_ELS_RJT_GENFAIL2     0x0D

#define FC_ELS_RJT_CMDINPROG    0x0E

#define FC_ELS_RJT_FIP          0x20

#define FC_ELS_RJT_VENDOR       0xFF

static const value_string fc_els_rjt_val[] = {

    {FC_ELS_RJT_INVCMDCODE, "Invalid Cmd Code"},

    {FC_ELS_RJT_LOGERR    , "Logical Error"},

    {FC_ELS_RJT_LOGBSY    , "Logical Busy"},

    {FC_ELS_RJT_PROTERR   , "Protocol Error"},

    {FC_ELS_RJT_GENFAIL   , "Unable to Perform Cmd"},

    {FC_ELS_RJT_CMDNOTSUPP, "Command Not Supported"},

    {FC_ELS_RJT_GENFAIL2  , "Unable to Perform Cmd"},

    {FC_ELS_RJT_CMDINPROG , "Command in Progress Already"},

    {FC_ELS_RJT_FIP       , "FIP Error"},

    {FC_ELS_RJT_VENDOR    , "Vendor Unique Error"},

    {0, NULL}

};

static value_string_ext fc_els_rjt_val_ext = VALUE_STRING_EXT_INIT(fc_els_rjt_val);

#define FC_ELS_RJT_DET_NODET             0x00

#define FC_ELS_RJT_DET_SVCPARM_OPT       0x01

#define FC_ELS_RJT_DET_SVCPARM_INITCTL   0x03

#define FC_ELS_RJT_DET_SVCPARM_RCPTCTL   0x05

#define FC_ELS_RJT_DET_SVCPARM_RCVSZE    0x07

#define FC_ELS_RJT_DET_SVCPARM_CSEQ      0x09

#define FC_ELS_RJT_DET_SVCPARM_CREDIT    0x0B

#define FC_ELS_RJT_DET_INV_PFNAME        0x0D

#define FC_ELS_RJT_DET_INV_NFNAME        0x0E

#define FC_ELS_RJT_DET_INV_CMNSVCPARM    0x0F

#define FC_ELS_RJT_DET_INV_ASSOCHDR      0x11

#define FC_ELS_RJT_DET_ASSOCHDR_REQD     0x13

#define FC_ELS_RJT_DET_INV_OSID          0x15

#define FC_ELS_RJT_DET_EXCHG_COMBO       0x17

#define FC_ELS_RJT_DET_CMDINPROG         0x19

#define FC_ELS_RJT_DET_PLOGI_REQ         0x1E

#define FC_ELS_RJT_DET_INV_NPID          0x1F

#define FC_ELS_RJT_DET_INV_SEQID         0x21

#define FC_ELS_RJT_DET_INV_EXCHG         0x23

#define FC_ELS_RJT_DET_INACTIVE_EXCHG    0x25

#define FC_ELS_RJT_DET_RQUAL_REQD        0x27

#define FC_ELS_RJT_DET_OORSRC            0x29

#define FC_ELS_RJT_DET_SUPPLYFAIL        0x2A

#define FC_ELS_RJT_DET_REQNOTSUPP        0x2C

#define FC_ELS_RJT_DET_INV_PLEN          0x2D

#define FC_ELS_RJT_DET_INV_ALIASID       0x30

#define FC_ELS_RJT_DET_OORSRC_ALIASID    0x31

#define FC_ELS_RJT_DET_INACTIVE_ALIASID  0x32

#define FC_ELS_RJT_DET_DEACT_ALIAS_FAIL1 0x33

#define FC_ELS_RJT_DET_DEACT_ALIAS_FAIL2 0x34

#define FC_ELS_RJT_DET_SVCPARM_CONFLICT  0x35

#define FC_ELS_RJT_DET_INV_ALIASTOK      0x36

#define FC_ELS_RJT_DET_UNSUPP_ALIASTOK   0x37

#define FC_ELS_RJT_DET_GRPFORM_FAIL      0x38

#define FC_ELS_RJT_DET_QOSPARM_ERR       0x40

#define FC_ELS_RJT_DET_INV_VCID          0x41

#define FC_ELS_RJT_DET_OORSRC_C4         0x42

#define FC_ELS_RJT_DET_INV_PNNAME        0x44

#define FC_ELS_RJT_DET_AUTH_REQD         0x48

#define FC_ELS_RJT_DET_NOT_NEIGHBOR      0x62

static const value_string fc_els_rjt_det_val[] = {

    {FC_ELS_RJT_DET_NODET            , "No further details"},

    {FC_ELS_RJT_DET_SVCPARM_OPT      , "Svc Param - Options Error"},

    {FC_ELS_RJT_DET_SVCPARM_INITCTL  , "Svc Param - Initiator Ctl Error"},

    {FC_ELS_RJT_DET_SVCPARM_RCPTCTL  , "Svc Param - Recipient Ctl Error"},

    {FC_ELS_RJT_DET_SVCPARM_RCVSZE   , "Svc Param - Recv Size Error"},

    {FC_ELS_RJT_DET_SVCPARM_CSEQ     , "Svc Param - Concurrent Seq Error"},

    {FC_ELS_RJT_DET_SVCPARM_CREDIT   , "Svc Param - Credit Error"},

    {FC_ELS_RJT_DET_INV_PFNAME       , "Invalid N_/F_Port Name"},

    {FC_ELS_RJT_DET_INV_NFNAME       , "Invalid Node/Fabric Name"},

    {FC_ELS_RJT_DET_INV_CMNSVCPARM   , "Invalid Common Svc Param"},

    {FC_ELS_RJT_DET_INV_ASSOCHDR     , "Invalid Association Header"},

    {FC_ELS_RJT_DET_ASSOCHDR_REQD    , "Association Header Reqd"},

    {FC_ELS_RJT_DET_INV_OSID         , "Invalid Orig S_ID"},

    {FC_ELS_RJT_DET_EXCHG_COMBO      , "Invalid OXID-RXID Combo"},

    {FC_ELS_RJT_DET_CMDINPROG        , "Cmd Already in Progress"},

    {FC_ELS_RJT_DET_PLOGI_REQ        , "N_Port Login Required"},

    {FC_ELS_RJT_DET_INV_NPID         , "Invalid N_Port Id"},

    {FC_ELS_RJT_DET_INV_SEQID        , "Invalid SeqID"},

    {FC_ELS_RJT_DET_INV_EXCHG        , "Attempt to Abort Invalid Exchg"},

    {FC_ELS_RJT_DET_INACTIVE_EXCHG   , "Attempt to Abort Inactive Exchg"},

    {FC_ELS_RJT_DET_RQUAL_REQD       , "Resource Qualifier Required"},

    {FC_ELS_RJT_DET_OORSRC           , "Insufficient Resources for Login"},

    {FC_ELS_RJT_DET_SUPPLYFAIL       , "Unable to Supply Req Data"},

    {FC_ELS_RJT_DET_REQNOTSUPP       , "Command Not Supported"},

    {FC_ELS_RJT_DET_INV_PLEN         , "Invalid Payload Length"},

    {FC_ELS_RJT_DET_INV_ALIASID      , "No Alias IDs available"},

    {FC_ELS_RJT_DET_OORSRC_ALIASID   , "Alias_ID Cannot be Activated (Out of Rsrc)"},

    {FC_ELS_RJT_DET_INACTIVE_ALIASID , "Alias_ID Cannot be Activated (Inv AID)"},

    {FC_ELS_RJT_DET_DEACT_ALIAS_FAIL1, "Alias_ID Cannot be Deactivated"},

    {FC_ELS_RJT_DET_DEACT_ALIAS_FAIL2, "Alias_ID Cannot be Deactivated"},

    {FC_ELS_RJT_DET_SVCPARM_CONFLICT , "Svc Parameter Conflict"},

    {FC_ELS_RJT_DET_INV_ALIASTOK     , "Invalid Alias Token"},

    {FC_ELS_RJT_DET_UNSUPP_ALIASTOK  , "Unsupported Alias Token"},

    {FC_ELS_RJT_DET_GRPFORM_FAIL     , "Alias Grp Cannot be Formed"},

    {FC_ELS_RJT_DET_QOSPARM_ERR      , "QoS Param Error"},

    {FC_ELS_RJT_DET_INV_VCID         , "VC_ID Not Found"},

    {FC_ELS_RJT_DET_OORSRC_C4        , "No Resources to Support Class 4 Conn"},

    {FC_ELS_RJT_DET_INV_PNNAME       , "Invalid Port/Node Name"},

    {FC_ELS_RJT_DET_AUTH_REQD        , "Authentication Required"},

    {FC_ELS_RJT_DET_NOT_NEIGHBOR     , "VN2VN_Port not in Neighbor Set"},

    {0, NULL}

};

static value_string_ext fc_els_rjt_det_val_ext = VALUE_STRING_EXT_INIT(fc_els_rjt_det_val);

static const value_string fc_els_flacompliance_val[] = {

    {1, "FC-FLA Level 1"},

    {2, "FC-FLA Level 2"},

    {0, NULL}

};

static const value_string fc_els_loopstate_val[] = {

    {1, "Online"},

    {2, "Loop Failure"},

    {3, "Initialization Failure"},

    {4, "Initializing"},

    {0, NULL}

};

static const value_string fc_els_scr_reg_val[] = {

    {1, "Fabric Detected Regn"},

    {2, "N_Port Detected Regn"},

    {3, "Full Regn"},

    {255, "Clear All Regn"},

    {0, NULL}

};

static const value_string fc_els_farp_respaction_val[] = {

    {0, "No Action"},

    {1, "Login Using Requesting Port ID"},

    {2, "Respond with FARP-REPLY"},

    {3, "Login & send FARP-REPLY"},

    {0, NULL}

};

static const value_string fc_els_portstatus_val[] = {

    {0x01, "Link Reset Protocol in Progress"},

    {0x02, "Loss of Synchronization"},

    {0x04, "Loss of Signal"},

    {0x10, "AL Connection | No Fabric"},

    {0x14, "AL Connection | Loss of Signal"},

    {0x18, "AL Connection | Fabric Detected"},

    {0x1C, "AL Connection | Fabric Detected | Loss of Signal"},

    {0x20, "Point-to-Point Connection | No Fabric"},

    {0x24, "Point-to-Point Connection | Loss of Signal"},

    {0x28, "Point-to-Point Connection | Fabric Detected"},

    {0x2C, "Point-to-Point Connection | Fabric Detected | Loss of Signal"},

    {0, NULL}

};

static value_string_ext fc_els_portstatus_val_ext = VALUE_STRING_EXT_INIT(fc_els_portstatus_val);

static const value_string fc_els_portspeed_val[] = {

    {0x8000, "1 Gb"},

    {0x4000, "2 Gb"},

    {0x2000, "4 Gb"},

    {0x1000, "10 Gb"},

    {0x0002, "Unknown"},

    {0x0001, "Speed Not Estd."},

    {0, NULL}

};

static const value_string fc_els_lirr_regfunc_val[] = {

    {0x1, "Set Reg: Conditionally Receive"},

    {0x2, "Set Reg: Always Receive"},

    {0xFF, "Clear Reg"},

    {0, NULL}

};

static const value_string fc_els_rscn_evqual_val[] = {

    {0x00, "Event is not specified"},

    {0x01, "Changed Name Server Object"},

    {0x02, "Changed Port Attribute"},

    {0x03, "Changed Service Object"},

    {0x04, "Changed Switch Config"},

    {0, NULL}

};

static const value_string fc_els_rscn_addrfmt_val[] = {

    {0, "Port Addr (single N/L Port or service)"},

    {1, "Area Addr Group (area of E/L/N Port addresses)"},

    {2, "Domain Addr Group"},

    {3, "Fabric Addr Group"},

    {0, NULL}

};

static const value_string fc_els_nodeid_val[] = {

    {0x00, "Common Identification Data Only"},

    {0x05, "IP Specific Data"},

    {0x08, "FCP-Specific Data"},

    {0x20, "FC_CT Specific Data"},

    {0x22, "SW_ILS Specific Data"},

    {0x23, "AL Specific Data"},

    {0x24, "SNMP Specific Data"},

    {0xDF, "Common ID Data + General Topology Discovery Format"},

    {0, NULL}

};

static const value_string fc_els_rnid_asstype_val[] = {

    {0x0, "Reserved"},

    {0x1, "Unknown"},

    {0x2, "Other"},

    {0x3, "Hub"},

    {0x4, "Switch"},

    {0x5, "Gateway"},

    {0x6, "Converter"},

    {0x7, "HBA"},

    {0x9, "Storage Device"},

    {0xA, "Host"},

    {0xB, "Storage Subsystem"},

    {0xE, "Storage Access Device"},

    {0x11, "NAS Device"},

    {0, NULL}

};

static value_string_ext fc_els_rnid_asstype_val_ext = VALUE_STRING_EXT_INIT(fc_els_rnid_asstype_val);

static const value_string fc_els_rnid_mgmt_val[] = {

    {0, "IP/UDP/SNMP"},

    {1, "IP/TCP/Telnet"},

    {2, "IP/TCP/HTTP"},

    {3, "IP/TCP/HTTPS"},

    {0, NULL}

};

static const value_string fc_els_rnid_ipvers_val[] = {

    {0, "None"},

    {1, "IPv4"},

    {2, "IPv6"},

    {0, NULL}

};

static const value_string fc_prli_fc4_val[] = {

    {FC_TYPE_SCSI    , "FCP"},

    {FC_TYPE_IP      , "IP/FC"},

    {FC_TYPE_LLCSNAP , "LLC_SNAP"},

    {FC_TYPE_ELS     , "Ext Link Svc"},

    {FC_TYPE_FCCT    , "FC_CT"},

    {FC_TYPE_SWILS   , "SW_ILS"},

    {FC_TYPE_AL      , "AL"},

    {FC_TYPE_SNMP    , "SNMP"},

    {FC_TYPE_CMNSVC  , "Common to all FC-4 Types"},

    {0, NULL},

};

static const value_string cbind_addr_mode_vals[] = {

    {0, "Address Translation mode"},

    {1, "Address Transparent Mode"},

    {0, NULL},

};

static const value_string cbind_status_vals[] = {

    {0, "Success"},

    {16, "Failed - Unspecified Reason"},

    {18, "Failed - Connection ID invalid"},

    {0, NULL},

};

static const value_string unbind_status_vals[] = {

    {0, "Success"},

    {16, "Failed - Unspecified Reason"},

    {17, "Failed - No such device"},

    {18, "Failed - iFCP session already exists"},

    {19, "Failed - Lack of resources"},

    {20, "Failed - Incompatible address translation mode"},

    {21, "Failed - Incorrect protocol version"},

    {22, "Failed - Gateway not synchronized"},

    {0, NULL},

};

typedef struct _fcels_conv_key {

    uint32_t conv_idx;

} fcels_conv_key_t;

typedef struct _fcels_conv_data {

    uint32_t opcode;

} fcels_conv_data_t;

static wmem_map_t *fcels_req_hash;

static dissector_handle_t fcsp_handle;

/*

 * Hash Functions

 */

static int

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

{

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

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

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

}

static unsigned

fcels_hash (const void *v)

{

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

    unsigned val;

    val = key->conv_idx;

    return val;

}

static const true_false_string tfs_fc_fcels_cmn_b2b = {

    "Alt B2B Credit Mgmt",

    "Normal B2B Credit Mgmt"

};

static const true_false_string tfs_fc_fcels_cmn_e_d_tov = {

    "E_D_TOV Resolution in ns",

    "E_D_TOV Resolution in ms"

};

static const true_false_string tfs_fc_fcels_cmn_seqcnt = {

    "Cont. Incr SEQCNT rules",

    "Normal SEQCNT rules"

};

static const true_false_string tfs_fc_fcels_cmn_payload = {

    "Payload Len=256 bytes",

    "Payload Len=116 bytes"

};

static void

dissect_cmnsvc (proto_tree *parent_tree, tvbuff_t *tvb, unsigned offset, uint16_t flags, uint8_t opcode)

{

    static int * const common_flags[] = {

        &hf_fcels_cmn_cios,

        &hf_fcels_cmn_rro,

        &hf_fcels_cmn_vvv,

        &hf_fcels_cmn_b2b,

        &hf_fcels_cmn_multicast,

        &hf_fcels_cmn_broadcast,

        &hf_fcels_cmn_security,

        &hf_fcels_cmn_clk,

        &hf_fcels_cmn_dhd,

        &hf_fcels_cmn_payload,

        NULL

    };

    static int * const pflags[] = {

        &hf_fcels_cmn_cios,

        &hf_fcels_cmn_rro,

        &hf_fcels_cmn_vvv,

        &hf_fcels_cmn_b2b,

        &hf_fcels_cmn_e_d_tov,

        &hf_fcels_cmn_simplex,

        &hf_fcels_cmn_multicast,

        &hf_fcels_cmn_broadcast,

        &hf_fcels_cmn_security,

        &hf_fcels_cmn_clk,

        &hf_fcels_cmn_dhd,

        &hf_fcels_cmn_seqcnt,

        &hf_fcels_cmn_payload,

        NULL

    };

    if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_cmnfeatures,

                           ett_fcels_cmnfeatures, pflags, flags, BMT_NO_FLAGS);

    } else {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_cmnfeatures,

                           ett_fcels_cmnfeatures, common_flags, flags, BMT_NO_FLAGS);

    }

}

static const true_false_string tfs_fc_fcels_cls_sdr = {

    "Seq Delivery Requested",

    "Out of Order Delivery Requested"

};

static const true_false_string tfs_fc_fcels_cls_nzctl = {

    "Non-zero CS_CTL Tolerated",

    "Non-zero CS_CTL Maybe Tolerated"

};

/* The next 3 routines decode only Class 2 & Class 3 relevant bits */

static void

dissect_clssvc_flags (proto_tree *parent_tree, tvbuff_t *tvb, unsigned offset, uint16_t flags, uint8_t opcode)

{

    static int * const common_flags[] = {

        &hf_fcels_cls_cns,

        &hf_fcels_cls_prio,

        NULL

    };

    static int * const pflags[] = {

        &hf_fcels_cls_cns,

        &hf_fcels_cls_sdr,

        &hf_fcels_cls_prio,

        &hf_fcels_cls_nzctl,

        NULL

    };

    if ((opcode == FC_ELS_FLOGI) || (opcode == FC_ELS_FDISC)) {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_clsflags,

                           ett_fcels_clsflags, pflags, flags, BMT_NO_FLAGS);

    } else {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_clsflags,

                           ett_fcels_clsflags, common_flags, flags, BMT_NO_FLAGS);

    }

}

static const true_false_string tfs_fc_fcels_fcpflags_retry = {

    "Retry Possible",

    "Retry NOT possible"

};

static const true_false_string tfs_fc_fcels_fcpflags_ccomp = {

    "Confirmed Comp",

    "Comp NOT confirmed"

};

static const true_false_string tfs_fc_fcels_fcpflags_datao = {

    "Data Overlay",

    "NO data overlay"

};

static const true_false_string tfs_fc_fcels_fcpflags_initiator = {

    "Initiator",

    "NOT an initiator"

};

static const true_false_string tfs_fc_fcels_fcpflags_target = {

    "Target",

    "NOT a target"

};

static const true_false_string tfs_fc_fcels_fcpflags_rdxr = {

    "Rd Xfer_Rdy Dis",

    "NO rd xfer_rdy dis"

};

static const true_false_string tfs_fc_fcels_fcpflags_wrxr = {

    "Wr Xfer_Rdy Dis",

    "NO wr xfer_rdy dis"

};

static void

dissect_fcp_flags (proto_tree *parent_tree, tvbuff_t *tvb, unsigned offset, uint32_t flags, uint8_t isreq)

{

    static int * const req_flags[] = {

        &hf_fcels_fcpflags_trireq,

        &hf_fcels_fcpflags_retry,

        &hf_fcels_fcpflags_ccomp,

        &hf_fcels_fcpflags_datao,

        &hf_fcels_fcpflags_initiator,

        &hf_fcels_fcpflags_target,

        &hf_fcels_fcpflags_rdxr,

        &hf_fcels_fcpflags_wrxr,

        NULL

    };

    static int * const rep_flags[] = {

        &hf_fcels_fcpflags_trirep,

        &hf_fcels_fcpflags_retry,

        &hf_fcels_fcpflags_ccomp,

        &hf_fcels_fcpflags_datao,

        &hf_fcels_fcpflags_initiator,

        &hf_fcels_fcpflags_target,

        &hf_fcels_fcpflags_rdxr,

        &hf_fcels_fcpflags_wrxr,

        NULL

    };

    if (isreq) {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_fcpflags,

                           ett_fcels_fcpflags, req_flags, flags, BMT_NO_FALSE);

    } else {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_fcpflags,

                           ett_fcels_fcpflags, rep_flags, flags, BMT_NO_FALSE);

    }

}

static void

dissect_speed_flags (proto_tree *parent_tree, tvbuff_t *tvb, unsigned offset, uint32_t flags, int port)

{

    proto_item *item;

    static int * const speed_flags[] = {

        &hf_fcels_speedflags_1gb,

        &hf_fcels_speedflags_2gb,

        &hf_fcels_speedflags_4gb,

        &hf_fcels_speedflags_10gb,

        NULL

    };

    item = proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_speedflags,

                           ett_fcels_speedflags, speed_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);

    proto_item_set_text(item, "Port Speed Capabilities (Port %u): 0x%04x", port, flags);

}

static const true_false_string tfs_fc_fcels_tprloflags_gprlo = {

    "Global PRLO",

    "NO global prlo"

};

static const true_false_string tfs_fc_fcels_prliloflags_ipe = {

    "Image Pair Estd",

    "Image pair NOT estd"

};

static const true_false_string tfs_fc_fcels_prliloflags_eip = {

    "Est Image Pair & Exchg Svc Param",

    "Exchange Svc Param Only"

};

static void

dissect_prlilo_flags (proto_tree *parent_tree, tvbuff_t *tvb, unsigned offset, int flags, uint8_t opcode)

{

    static int * const tprlo_flags[] = {

        &hf_fcels_tprloflags_opav,

        &hf_fcels_tprloflags_rpav,

        &hf_fcels_tprloflags_npv,

        &hf_fcels_tprloflags_gprlo,

        NULL

    };

    static int * const prli_flags[] = {

        &hf_fcels_prliloflags_opav,

        &hf_fcels_tprloflags_rpav,

        &hf_fcels_prliloflags_ipe,

        NULL

    };

    static int * const not_prli_flags[] = {

        &hf_fcels_prliloflags_opav,

        &hf_fcels_tprloflags_rpav,

        &hf_fcels_prliloflags_eip,

        NULL

    };

    if (opcode == FC_ELS_TPRLO) {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_prliloflags,

                                   ett_fcels_prliloflags, tprlo_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);

    } else { /* opcode != TPRLO */

        if (opcode == FC_ELS_PRLI) {

            proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_prliloflags,

                                   ett_fcels_prliloflags, prli_flags, flags, BMT_NO_FALSE);

        } else {

            proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_prliloflags,

                                   ett_fcels_prliloflags, not_prli_flags, flags, BMT_NO_FALSE);

        }

    }

}

static const value_string initial_pa_vals[] = {

    { 0, "Initial P_A Not Supported" },

    { 1, "Initial P_A Supported" },

    { 3, "Initial P_A Required & Supported" },

    { 0, NULL }

};

static const true_false_string tfs_fc_fcels_initctl_ackgaa = {

    "ACK Generation Assistance Avail",

    "NO ack generation assistance"

};

static void

dissect_initctl_flags (proto_tree *parent_tree, tvbuff_t *tvb, unsigned offset, uint16_t flags, uint8_t opcode)

{

    static int * const plogi_flags[] = {

        &hf_fcels_initctl_initial_pa,

        &hf_fcels_initctl_ack0,

        &hf_fcels_initctl_ackgaa,

        &hf_fcels_initctl_sync,

        NULL

    };

    static int * const not_plogi_flags[] = {

        &hf_fcels_initctl_sync,

        NULL

    };

    if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_initctl,

                                   ett_fcels_initctl, plogi_flags, flags, BMT_NO_FALSE);

    } else {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_initctl,

                                   ett_fcels_initctl, not_plogi_flags, flags, BMT_NO_FALSE);

    }

}

static const value_string rcptctl_policy_vals[] = {

    { 0, "Error Policy: Discard Policy only" },

    { 1, "Error Policy: Reserved" },

    { 2, "Error Policy: Both discard and process policies supported" },

    { 3, "Error Policy: Reserved" },

    { 0, NULL }

};

static const value_string rcptctl_category_vals[] = {

    { 0, "1 Category/Seq" },

    { 1, "2 Categories/Seq" },

    { 3, "More than 2 Categories/Seq" },

    { 0, NULL }

};

static void

dissect_rcptctl_flags (proto_tree *parent_tree, tvbuff_t *tvb, unsigned offset, uint16_t flags, uint8_t opcode)

{

    static int * const plogi_flags[] = {

        &hf_fcels_rcptctl_ack0,

        &hf_fcels_rcptctl_interlock,

        &hf_fcels_rcptctl_policy,

        &hf_fcels_rcptctl_category,

        &hf_fcels_rcptctl_sync,

        NULL

    };

    static int * const not_plogi_flags[] = {

        &hf_fcels_rcptctl_sync,

        NULL

    };

    if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_rcptctl,

                                   ett_fcels_rcptctl, plogi_flags, flags, BMT_NO_FALSE);

    } else {

        proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_rcptctl,

                                   ett_fcels_rcptctl, not_plogi_flags, flags, BMT_NO_FALSE);

    }

}

/* Maximum length of possible string from, construct_*_string

 * 296 bytes, FIX possible buffer overflow */

#define FCELS_LOGI_MAXSTRINGLEN 512

static void

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

                    proto_item *ti, uint8_t opcode)

{

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

    unsigned offset = 0,

        svcvld = 0,

        svcclass;

    proto_tree *logi_tree, *cmnsvc_tree;

    uint16_t flag;

    if (tree) {

        logi_tree = proto_item_add_subtree (ti, ett_fcels_logi);

        proto_tree_add_item (logi_tree, hf_fcels_opcode, tvb, offset, 1, ENC_BIG_ENDIAN);

        cmnsvc_tree = proto_tree_add_subtree(logi_tree, tvb, offset+4, 16, ett_fcels_logi_cmnsvc, NULL, "Common Svc Parameters");

        proto_tree_add_item (cmnsvc_tree, hf_fcels_b2b, tvb, offset+6, 2, ENC_BIG_ENDIAN);

        flag = tvb_get_ntohs (tvb, offset+8);

        if (flag & 0x0001) {

            svcvld = 1;

        }

        dissect_cmnsvc (cmnsvc_tree, tvb, offset+8, flag, opcode);

        proto_tree_add_item (cmnsvc_tree, hf_fcels_bbscnum, tvb, offset+10, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item (cmnsvc_tree, hf_fcels_rcvsize, tvb, offset+10, 2, ENC_BIG_ENDIAN);

        proto_tree_add_item (cmnsvc_tree, hf_fcels_maxconseq, tvb, offset+12, 2, ENC_BIG_ENDIAN);

        proto_tree_add_item (cmnsvc_tree, hf_fcels_reloffset, tvb, offset+14, 2, ENC_BIG_ENDIAN);

        proto_tree_add_item (cmnsvc_tree, hf_fcels_edtov, tvb, offset+16, 4, ENC_BIG_ENDIAN);

        proto_tree_add_item (cmnsvc_tree, hf_fcels_npname, tvb, offset+20, 8, ENC_NA);

        proto_tree_add_item (cmnsvc_tree, hf_fcels_fnname, tvb, offset+28, 8, ENC_NA);

        /* Add subtree for class parameters */

        offset = 36;

        for (svcclass = 1; svcclass < 5; svcclass++) {

            cmnsvc_tree = proto_tree_add_subtree_format(logi_tree, tvb, offset, 16,

                                         ett_fcels_logi_cmnsvc, NULL, "Class %d Svc Parameters", svcclass);

            flag = tvb_get_ntohs (tvb, offset);

            dissect_clssvc_flags (cmnsvc_tree, tvb, offset, flag, opcode);

            if (flag & 0x8000) {

                flag = tvb_get_ntohs (tvb, offset+2);

                dissect_initctl_flags (cmnsvc_tree, tvb, offset+2, flag, opcode);

                flag = tvb_get_ntohs (tvb, offset+4);

                dissect_rcptctl_flags (cmnsvc_tree, tvb, offset+4, flag, opcode);

                proto_tree_add_item (cmnsvc_tree, hf_fcels_clsrcvsize, tvb,

                                     offset+6, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item (cmnsvc_tree, hf_fcels_conseq, tvb,

                                     offset+8, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item (cmnsvc_tree, hf_fcels_e2e, tvb,

                                     offset+10, 2, ENC_BIG_ENDIAN);

                proto_tree_add_item (cmnsvc_tree, hf_fcels_openseq, tvb,

                                     offset+12, 2, ENC_BIG_ENDIAN);

            }

            offset += 16;

        }

        proto_tree_add_item (logi_tree, hf_fcels_vendorvers, tvb, offset, 16, ENC_NA);

        /* The standard 116 octet payload ends before the service availability */

        if (svcvld && tvb_bytes_exist (tvb, offset+32, 8)) {

            proto_tree_add_item (logi_tree, hf_fcels_svcavail, tvb, offset+32, 8, ENC_NA);

        }

    }

}

static void

dissect_fcels_plogi (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                     uint8_t isreq _U_, proto_item *ti)

{

    dissect_fcels_logi (tvb, pinfo, tree, ti, FC_ELS_PLOGI);

}

static void

dissect_fcels_flogi (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                     uint8_t isreq _U_, proto_item *ti)

{

    dissect_fcels_logi (tvb, pinfo, tree, ti, FC_ELS_FLOGI);

}

static void

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

                      uint8_t isreq, proto_item *ti)

{

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

    unsigned offset = 5;             /* bypass opcode+rsvd field */

    proto_tree *logo_tree;

    if (tree) {

        logo_tree = proto_item_add_subtree (ti, ett_fcels_logo);

        proto_tree_add_item (logo_tree, hf_fcels_opcode, tvb, offset-5, 1, ENC_BIG_ENDIAN);

        if (!isreq) {

            /* Accept has no payload */

            return;

        }

        proto_tree_add_item (logo_tree, hf_fcels_nportid, tvb, offset, 3, ENC_NA);

        proto_tree_add_item (logo_tree, hf_fcels_npname, tvb, offset+3, 8, ENC_NA);

    }

}

static void

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

                    uint8_t isreq, proto_item *ti)

{

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

    unsigned offset = 0;

    proto_tree *abtx_tree;

    if (tree) {

        abtx_tree = proto_item_add_subtree (ti, ett_fcels_abtx);

        proto_tree_add_item (abtx_tree, hf_fcels_opcode, tvb, offset, 1, ENC_BIG_ENDIAN);

        if (!isreq) {

            return;

        }

        proto_tree_add_item(abtx_tree, hf_fcels_recovery_qualifier_status, tvb, offset+4, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item (abtx_tree, hf_fcels_nportid, tvb, offset+5, 3, ENC_NA);

        proto_tree_add_item (abtx_tree, hf_fcels_oxid, tvb, offset+8, 2, ENC_BIG_ENDIAN);

        proto_tree_add_item (abtx_tree, hf_fcels_rxid, tvb, offset+10, 2, ENC_BIG_ENDIAN);

    }

}

static void

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

                   uint8_t isreq, proto_item *ti)

{

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