/* packet-selfm.c

 * Routines for Schweitzer Engineering Laboratories (SEL) Protocols Dissection

 * By Chris Bontje (cbontje[AT]gmail.com

 * Copyright 2012-2021,

 *

 ************************************************************************************************

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 *

 ************************************************************************************************

 * Schweitzer Engineering Labs ("SEL") manufactures and sells digital protective relay equipment

 * for use in industrial high-voltage installations.  SEL Protocol evolved over time as a

 * (semi)proprietary method for auto-configuration of connected SEL devices for retrieval of

 * analog and digital status data.  The protocol itself supports embedded binary messages

 * (which are what this dissector looks for) slip-streamed in the data stream with normal

 * ASCII text data.  A combination of both are used for full auto-configuration of devices,

 * but a wealth of information can be extracted from the binary messages alone.

 *

 * 'SEL Protocol' encompasses several message types, including

 * - Fast Meter

 * - Fast Operate

 * - Fast SER

 * - Fast Message

 *

 * Documentation on Fast Meter and Fast Message standards available from www.selinc.com in

 * SEL Application Guides AG95-10_20091109.pdf and AG_200214.pdf

 ************************************************************************************************

 * Dissector Notes:

 *

 * 1) All SEL Protocol messages over TCP are normally tunneled via a Telnet connection.  As Telnet

 * has special handling for the 0xFF character ("IAC"), normally a pair of 0xFF's are inserted

 * to represent an actual payload byte of 0xFF.  A function from the packet-telnet.c dissector has

 * been borrowed to automatically pre-process any Ethernet-based packet and remove these 'extra'

 * 0xFF bytes.  Wireshark Notes on Telnet 0xFF doubling are discussed here:

 * https://lists.wireshark.org/archives/wireshark-bugs/201204/msg00198.html

 *

 * 2) The auto-configuration process for Fast Meter will exchange several "configuration" messages

 * that describe various data regions (METER, DEMAND, PEAK, etc) that will later have corresponding

 * "data" messages.  This dissector code will currently save and accurately retrieve the 3 sets

 * of these exchanges:

 *             0xA5C1, 0xA5D1, "METER" region

 *             0xA5C2, 0xA5D2, "DEMAND" region

 *             0xA5C3, 0xA5D3, "PEAK" region

 * The configuration messages are stored in structs that are managed using the wmem library and

 * the Wireshark conversation functionality.

 */

#include "config.h"

#define WS_LOG_DOMAIN "packet-selfm"

#include <wireshark.h>

#include <epan/packet.h>

#include "packet-tcp.h"

#include <epan/prefs.h>

#include <epan/to_str.h>

#include <epan/strutil.h>

#include <epan/reassemble.h>

#include <epan/expert.h>

#include <epan/crc16-tvb.h>

#include <epan/proto_data.h>

void proto_register_selfm(void);

/* Initialize the protocol and registered fields */

static int proto_selfm;

static int hf_selfm_msgtype;

static int hf_selfm_padbyte;

static int hf_selfm_checksum;

static int hf_selfm_relaydef_len;

static int hf_selfm_relaydef_numproto;

static int hf_selfm_relaydef_numfm;

static int hf_selfm_relaydef_numflags;

static int hf_selfm_relaydef_fmcfg_cmd;

static int hf_selfm_relaydef_fmdata_cmd;

static int hf_selfm_relaydef_statbit;

static int hf_selfm_relaydef_statbit_cmd;

static int hf_selfm_relaydef_proto;

static int hf_selfm_fmconfig_len;

static int hf_selfm_fmconfig_numflags;

static int hf_selfm_fmconfig_loc_sf;

static int hf_selfm_fmconfig_num_sf;

static int hf_selfm_fmconfig_num_ai;

static int hf_selfm_fmconfig_num_samp;

static int hf_selfm_fmconfig_num_dig;

static int hf_selfm_fmconfig_num_calc;

static int hf_selfm_fmconfig_ofs_ai;

static int hf_selfm_fmconfig_ofs_ts;

static int hf_selfm_fmconfig_ofs_dig;

static int hf_selfm_fmconfig_ai_type;

static int hf_selfm_fmconfig_ai_sf_type;

static int hf_selfm_fmconfig_ai_sf_ofs;

static int hf_selfm_fmconfig_cblk_rot;

static int hf_selfm_fmconfig_cblk_vconn;

static int hf_selfm_fmconfig_cblk_iconn;

static int hf_selfm_fmconfig_cblk_ctype;

static int hf_selfm_fmconfig_cblk_deskew_ofs;

static int hf_selfm_fmconfig_cblk_rs_ofs;

static int hf_selfm_fmconfig_cblk_xs_ofs;

static int hf_selfm_fmconfig_cblk_ia_idx;

static int hf_selfm_fmconfig_cblk_ib_idx;

static int hf_selfm_fmconfig_cblk_ic_idx;

static int hf_selfm_fmconfig_cblk_va_idx;

static int hf_selfm_fmconfig_cblk_vb_idx;

static int hf_selfm_fmconfig_cblk_vc_idx;

static int hf_selfm_fmconfig_ai_sf_float;

static int hf_selfm_fmdata_len;

static int hf_selfm_fmdata_flagbyte;

static int hf_selfm_fmdata_dig_b0;

static int hf_selfm_fmdata_dig_b1;

static int hf_selfm_fmdata_dig_b2;

static int hf_selfm_fmdata_dig_b3;

static int hf_selfm_fmdata_dig_b4;

static int hf_selfm_fmdata_dig_b5;

static int hf_selfm_fmdata_dig_b6;

static int hf_selfm_fmdata_dig_b7;

static int hf_selfm_fmdata_ai_sf_fp;

static int hf_selfm_foconfig_len;

static int hf_selfm_foconfig_num_brkr;

static int hf_selfm_foconfig_num_rb;

static int hf_selfm_foconfig_prb_supp;

static int hf_selfm_foconfig_reserved;

static int hf_selfm_foconfig_brkr_open;

static int hf_selfm_foconfig_brkr_close;

static int hf_selfm_foconfig_rb_cmd;

static int hf_selfm_fastop_len;

static int hf_selfm_fastop_rb_code;

static int hf_selfm_fastop_br_code;

static int hf_selfm_fastop_valid;

static int hf_selfm_alt_foconfig_len;

static int hf_selfm_alt_foconfig_num_ports;

static int hf_selfm_alt_foconfig_num_brkr;

static int hf_selfm_alt_foconfig_num_rb;

static int hf_selfm_alt_foconfig_funccode;

static int hf_selfm_alt_fastop_len;

static int hf_selfm_alt_fastop_code;

static int hf_selfm_alt_fastop_valid;

static int hf_selfm_fastmsg_len;

static int hf_selfm_fastmsg_routing_addr;

static int hf_selfm_fastmsg_status;

static int hf_selfm_fastmsg_funccode;

static int hf_selfm_fastmsg_response_code;

static int hf_selfm_fastmsg_seq;

static int hf_selfm_fastmsg_seq_fir;

static int hf_selfm_fastmsg_seq_fin;

static int hf_selfm_fastmsg_seq_cnt;

static int hf_selfm_fastmsg_resp_num;

static int hf_selfm_fastmsg_crc16;

static int hf_selfm_fastmsg_def_route_sup;

static int hf_selfm_fastmsg_def_rx_stat;

static int hf_selfm_fastmsg_def_tx_stat;

static int hf_selfm_fastmsg_def_rx_maxfr;

static int hf_selfm_fastmsg_def_tx_maxfr;

static int hf_selfm_fastmsg_def_rx_num_fc;

static int hf_selfm_fastmsg_def_rx_fc;

static int hf_selfm_fastmsg_def_tx_num_fc;

static int hf_selfm_fastmsg_def_tx_fc;

static int hf_selfm_fastmsg_uns_en_fc;

static int hf_selfm_fastmsg_uns_en_fc_data;

static int hf_selfm_fastmsg_uns_dis_fc;

static int hf_selfm_fastmsg_uns_dis_fc_data;

static int hf_selfm_fastmsg_baseaddr;

static int hf_selfm_fastmsg_numwords;

static int hf_selfm_fastmsg_flags;

static int hf_selfm_fastmsg_datafmt_resp_numitem;

static int hf_selfm_fastmsg_dataitem_qty;

static int hf_selfm_fastmsg_dataitem_type;

static int hf_selfm_fastmsg_dataitem_uint16;

static int hf_selfm_fastmsg_dataitem_int16;

static int hf_selfm_fastmsg_dataitem_uint32;

static int hf_selfm_fastmsg_dataitem_int32;

static int hf_selfm_fastmsg_dataitem_float;

static int hf_selfm_fastmsg_devdesc_num_region;

static int hf_selfm_fastmsg_devdesc_num_ctrl;

static int hf_selfm_fastmsg_unsresp_orig;

static int hf_selfm_fastmsg_unsresp_doy;

static int hf_selfm_fastmsg_unsresp_year;

static int hf_selfm_fastmsg_unsresp_todms;

static int hf_selfm_fastmsg_unsresp_num_elmt;

static int hf_selfm_fastmsg_unsresp_elmt_idx;

static int hf_selfm_fastmsg_unsresp_elmt_ts_ofs;

static int hf_selfm_fastmsg_unsresp_elmt_status;

static int hf_selfm_fastmsg_unsresp_eor;

static int hf_selfm_fastmsg_unsresp_elmt_statword;

static int hf_selfm_fastmsg_unswrite_addr1;

static int hf_selfm_fastmsg_unswrite_addr2;

static int hf_selfm_fastmsg_unswrite_num_reg;

static int hf_selfm_fastmsg_unswrite_reg_val;

static int hf_selfm_fastmsg_soe_req_orig;

static int hf_selfm_fastmsg_soe_resp_numblks;

static int hf_selfm_fastmsg_soe_resp_orig;

static int hf_selfm_fastmsg_soe_resp_numbits;

static int hf_selfm_fastmsg_soe_resp_pad;

static int hf_selfm_fastmsg_soe_resp_doy;

static int hf_selfm_fastmsg_soe_resp_year;

static int hf_selfm_fastmsg_soe_resp_tod;

static int hf_selfm_fastmsg_soe_resp_data;

/* Generated from convert_proto_tree_add_text.pl */

static int hf_selfm_fmconfig_ai_channel;

static int hf_selfm_fmdata_ai_value16;

static int hf_selfm_fmdata_ai_scale_factor;

static int hf_selfm_fmdata_ai_value_float;

static int hf_selfm_fmdata_ai_value_double;

static int hf_selfm_fmdata_data_type;

static int hf_selfm_fmdata_quantity;

static int hf_selfm_fmdata_ai_value_string;

static int hf_selfm_fastmsg_unsresp_elmt_ts_ofs_decoded;

static int hf_selfm_fid;

static int hf_selfm_rid;

static int hf_selfm_fastmsg_data_region_name;

static int hf_selfm_fmdata_timestamp;

static int hf_selfm_fmdata_frame_data_format_reference;

static int hf_selfm_fastmsg_bit_label_name;

/* Initialize the subtree pointers */

static int ett_selfm;

static int ett_selfm_relaydef;

static int ett_selfm_relaydef_fm;

static int ett_selfm_relaydef_proto;

static int ett_selfm_relaydef_flags;

static int ett_selfm_fmconfig;

static int ett_selfm_fmconfig_ai;

static int ett_selfm_fmconfig_calc;

static int ett_selfm_foconfig;

static int ett_selfm_foconfig_brkr;

static int ett_selfm_foconfig_rb;

static int ett_selfm_fastop;

static int ett_selfm_fmdata;

static int ett_selfm_fmdata_ai;

static int ett_selfm_fmdata_dig;

static int ett_selfm_fmdata_ai_ch;

static int ett_selfm_fmdata_dig_ch;

static int ett_selfm_fastmsg;

static int ett_selfm_fastmsg_seq;

static int ett_selfm_fastmsg_def_fc;

static int ett_selfm_fastmsg_datareg;

static int ett_selfm_fastmsg_soeblk;

static int ett_selfm_fastmsg_tag;

static int ett_selfm_fastmsg_element_list;

static int ett_selfm_fastmsg_element;

/* Expert fields */

static expert_field ei_selfm_crc16_incorrect;

static dissector_handle_t selfm_handle;

#define CMD_FAST_MSG            0xA546

#define CMD_CLEAR_STATBIT       0xA5B9

#define CMD_RELAY_DEF           0xA5C0

#define CMD_FM_CONFIG           0xA5C1

#define CMD_DFM_CONFIG          0xA5C2

#define CMD_PDFM_CONFIG         0xA5C3

#define CMD_FASTOP_RESETDEF     0xA5CD

#define CMD_FASTOP_CONFIG       0xA5CE

#define CMD_ALT_FASTOP_CONFIG   0xA5CF

#define CMD_FM_DATA             0xA5D1

#define CMD_DFM_DATA            0xA5D2

#define CMD_PDFM_DATA           0xA5D3

#define CMD_FASTOP_RB_CTRL      0xA5E0

#define CMD_FASTOP_BR_CTRL      0xA5E3

#define CMD_ALT_FASTOP_OPEN     0xA5E5

#define CMD_ALT_FASTOP_CLOSE    0xA5E6

#define CMD_ALT_FASTOP_SET      0xA5E7

#define CMD_ALT_FASTOP_CLEAR    0xA5E8

#define CMD_ALT_FASTOP_PULSE    0xA5E9

#define CMD_FASTOP_RESET        0xA5ED

#define FM_CONFIG_SF_LOC_FM             0

#define FM_CONFIG_SF_LOC_CFG            1

#define FM_CONFIG_ANA_CHNAME_LEN        6

#define FM_CONFIG_ANA_CHTYPE_INT16      0x00

#define FM_CONFIG_ANA_CHTYPE_FP         0x01

#define FM_CONFIG_ANA_CHTYPE_FPD        0x02

#define FM_CONFIG_ANA_CHTYPE_TS         0x03

#define FM_CONFIG_ANA_CHTYPE_TS_LEN     8

#define FM_CONFIG_ANA_SFTYPE_INT16      0x00

#define FM_CONFIG_ANA_SFTYPE_FP         0x01

#define FM_CONFIG_ANA_SFTYPE_FPD        0x02

#define FM_CONFIG_ANA_SFTYPE_TS         0x03

#define FM_CONFIG_ANA_SFTYPE_NONE       0xFF

/* Fast Message Function Codes, "response" or "ACK" messages are the same as the request, but have the MSB set */

#define FAST_MSG_CFG_BLOCK              0x00

#define FAST_MSG_EN_UNS_DATA            0x01

#define FAST_MSG_DIS_UNS_DATA           0x02

#define FAST_MSG_PING                   0x05

#define FAST_MSG_READ_REQ               0x10

#define FAST_MSG_GEN_UNS_DATA           0x12

#define FAST_MSG_SOE_STATE_REQ          0x16

#define FAST_MSG_UNS_RESP               0x18

#define FAST_MSG_UNS_WRITE              0x20

#define FAST_MSG_UNS_WRITE_REQ          0x21

#define FAST_MSG_DEVDESC_REQ            0x30

#define FAST_MSG_DATAFMT_REQ            0x31

#define FAST_MSG_UNS_DATAFMT_RESP       0x32

#define FAST_MSG_BITLABEL_REQ           0x33

#define FAST_MSG_MGMT_REQ               0x40

#define FAST_MSG_CFG_BLOCK_RESP         0x80

#define FAST_MSG_EN_UNS_DATA_ACK        0x81

#define FAST_MSG_DIS_UNS_DATA_ACK       0x82

#define FAST_MSG_PING_ACK               0x85

#define FAST_MSG_READ_RESP              0x90

#define FAST_MSG_SOE_STATE_RESP         0x96

#define FAST_MSG_UNS_RESP_ACK           0x98

#define FAST_MSG_DEVDESC_RESP           0xB0

#define FAST_MSG_DATAFMT_RESP           0xB1

#define FAST_MSG_BITLABEL_RESP          0xB3

/* Fast Message Sequence Byte Masks */

#define FAST_MSG_SEQ_FIR     0x80

#define FAST_MSG_SEQ_FIN     0x40

#define FAST_MSG_SEQ_CNT     0x3f

/* Fast Message Tag Data Types */

#define FAST_MSG_TAGTYPE_CHAR8        0x0011   /* 1 x 8-bit character per item */

#define FAST_MSG_TAGTYPE_CHAR16       0x0012   /* 2 x 8-bit characters per item */

#define FAST_MSG_TAGTYPE_DIGWORD8_BL  0x0021   /* 8-bit binary item, with labels */

#define FAST_MSG_TAGTYPE_DIGWORD8     0x0022   /* 8-bit binary item, without labels */

#define FAST_MSG_TAGTYPE_DIGWORD16_BL 0x0023   /* 16-bit binary item, with labels */

#define FAST_MSG_TAGTYPE_DIGWORD16    0x0024   /* 16-bit binary item, without labels */

#define FAST_MSG_TAGTYPE_INT16        0x0031   /* 16-bit signed integer */

#define FAST_MSG_TAGTYPE_UINT16       0x0032   /* 16-bit unsigned integer */

#define FAST_MSG_TAGTYPE_INT32        0x0033   /* 32-bit signed integer */

#define FAST_MSG_TAGTYPE_UINT32       0x0034   /* 32-bit unsigned integer */

#define FAST_MSG_TAGTYPE_FLOAT        0x0041   /* 32-bit floating point */

/* Globals for SEL Protocol Preferences */

static bool selfm_desegment = true;

static bool selfm_telnet_clean = true;

static bool selfm_crc16;             /* Default CRC16 validation to false */

static const char *selfm_ser_list;

/***************************************************************************************/

/* Fast Meter Message structs */

/***************************************************************************************/

/* Holds Configuration Information required to decode a Fast Meter analog value        */

typedef struct {

    char    name[FM_CONFIG_ANA_CHNAME_LEN+1];     /* Name of Analog Channel, 6 char + a null */

    uint8_t type;                                 /* Analog Channel Type, Int, FP, etc */

    uint8_t sf_type;                              /* Analog Scale Factor Type, none, etc */

    uint16_t sf_offset;                            /* Analog Scale Factor Offset */

    float   sf_fp;                                /* Scale factor, if present in Cfg message */

} fm_analog_info;

/* Holds Information from a single "Fast Meter Configuration" frame.  Required to dissect subsequent "Data" frames. */

typedef struct {

    uint32_t fnum;                   /* frame number */

    uint16_t cfg_cmd;                /* holds ID of config command, ie: 0xa5c1 */

    uint8_t  num_flags;              /* Number of Flag Bytes           */

    uint8_t  sf_loc;                 /* Scale Factor Location          */

    uint8_t  sf_num;                 /* Number of Scale Factors        */

    uint8_t  num_ai;                 /* Number of Analog Inputs        */

    uint8_t  num_ai_samples;         /* Number samples per Analog Input */

    uint16_t offset_ai;              /* Start Offset of Analog Inputs  */

    uint8_t  num_dig;                /* Number of Digital Input Blocks */

    uint16_t offset_dig;             /* Start Offset of Digital Inputs */

    uint16_t offset_ts;              /* Start Offset of Time Stamp     */

    uint8_t  num_calc;               /* Number of Calculations         */

    fm_analog_info *analogs;         /* Array of fm_analog_infos       */

} fm_config_frame;

/**************************************************************************************/

/* Fast Message Data Item struct */

/**************************************************************************************/

/* Holds Configuration Information required to decode a Fast Message Data Item        */

/* Each data region format is returned as a sequential list of tags, w/o reference to */

/* an absolute address.  The format information will consist of a name, a data type   */

/* and a quantity of values contained within the data item.  We will retrieve this    */

/* format information later while attempting to dissect Read Response frames          */

typedef struct {

    uint32_t fnum;                              /* frame number */

    uint32_t base_address;                      /* Base address of Data Item Region                         */

    uint8_t  index_pos;                         /* Index Offset Position within data format message (1-16)  */

    char     name[10+1];                        /* Name of Data Item, 10 chars, null-terminated             */

    uint16_t quantity;                          /* Quantity of values within Data Item                      */

    uint16_t data_type;                         /* Data Item Type, Char, Int, FP, etc                       */

} fastmsg_dataitem;

/**************************************************************************************/

/* Fast Message Data Region struct */

/**************************************************************************************/

/* Holds Configuration Information required to decode a Fast Message Data Region      */

/* Each data region format is returned as a sequential list of tags, w/o reference to */

typedef struct {

    char     name[10+1];                        /* Name of Data Region, 10 chars, null-terminated              */

} fastmsg_dataregion;

/**************************************************************************************/

/* Fast Unsolicited SER Index Lookup */

/**************************************************************************************/

/* Holds user-configurable naming information for Unsolicited Fast SER word bits      */

/* that will later be present in an 0xA546 msg with only an index position reference  */

typedef struct {

    char     *name;                     /* Name of Word Bit, 8 chars, null-terminated */

} fastser_uns_wordbit;

/**************************************************************************************/

/* Fast Message Conversation struct */

/**************************************************************************************/

typedef struct {

    wmem_list_t *fm_config_frames;      /* List contains a fm_config_data struct for each Fast Meter configuration frame */

    wmem_list_t *fastmsg_dataitems;     /* List contains a fastmsg_dataitem struct for each Fast Message Data Item */

    wmem_tree_t *fastmsg_dataregions;   /* Tree contains a fastmsg_dataregion struct for each Fast Message Data Region */

    wmem_tree_t *fastser_uns_wordbits;  /* Tree contains a fastser_uns_wordbit struct for each comma-separated entry in the 'SER List' User Preference */

} fm_conversation;

static const value_string selfm_msgtype_vals[] = {

    { CMD_FAST_MSG,              "Fast Message Block"                              },  /* 0xA546 */

    { CMD_CLEAR_STATBIT,         "Clear Status Bits Command"                       },  /* 0xA5B9 */

    { CMD_RELAY_DEF,             "Relay Definition Block"                          },  /* 0xA5C0 */

    { CMD_FM_CONFIG,             "Fast Meter Configuration Block"                  },  /* 0xA5C1 */

    { CMD_DFM_CONFIG,            "Demand Fast Meter Configuration Block"           },  /* 0xA5C2 */

    { CMD_PDFM_CONFIG,           "Peak Demand Fast Meter Configuration Block"      },  /* 0xA5C3 */

    { CMD_FASTOP_RESETDEF,       "Fast Operate Reset Definition"                   },  /* 0xA5CD */

    { CMD_FASTOP_CONFIG,         "Fast Operate Configuration"                      },  /* 0xA5CE */

    { CMD_ALT_FASTOP_CONFIG,     "Alternate Fast Operate Configuration"            },  /* 0xA5CF */

    { CMD_FM_DATA,               "Fast Meter Data Block"                           },  /* 0xA5D1 */

    { CMD_DFM_DATA,              "Demand Fast Meter Data Block"                    },  /* 0xA5D2 */

    { CMD_PDFM_DATA,             "Peak Demand Fast Meter Data Block"               },  /* 0xA5D3 */

    { CMD_FASTOP_RB_CTRL,        "Fast Operate Remote Bit Control"                 },  /* 0xA5E0 */

    { CMD_FASTOP_BR_CTRL,        "Fast Operate Breaker Bit Control"                },  /* 0xA5E3 */

    { CMD_ALT_FASTOP_OPEN,       "Alternate Fast Operate Open Breaker Control"     },  /* 0xA5E5 */

    { CMD_ALT_FASTOP_CLOSE,      "Alternate Fast Operate Close Breaker Control"    },  /* 0xA5E6 */

    { CMD_ALT_FASTOP_SET,        "Alternate Fast Operate Set Remote Bit Control"   },  /* 0xA5E7 */

    { CMD_ALT_FASTOP_CLEAR,      "Alternate Fast Operate Clear Remote Bit Control" },  /* 0xA5E8 */

    { CMD_ALT_FASTOP_PULSE,      "Alternate Fast Operate Pulse Remote Bit Control" },  /* 0xA5E9 */

    { CMD_FASTOP_RESET,          "Fast Operate Reset"                              },  /* 0xA5ED */

    { 0,                         NULL }

};

static value_string_ext selfm_msgtype_vals_ext = VALUE_STRING_EXT_INIT(selfm_msgtype_vals);

static const value_string selfm_relaydef_proto_vals[] = {

    { 0x0000,  "SEL Fast Meter" },

    { 0x0001,  "SEL Limited Multidrop (LMD)" },

    { 0x0002,  "Modbus" },

    { 0x0003,  "SY/MAX" },

    { 0x0004,  "SEL Relay-to-Relay" },

    { 0x0005,  "DNP 3.0" },

    { 0x0006,  "SEL Mirrored Bits" },

    { 0x0007,  "IEEE 37.118 Synchrophasors" },

    { 0x0008,  "IEC 61850" },

    { 0x0100,  "SEL Fast Meter w/ Fast Operate" },

    { 0x0101,  "SEL Limited Multidrop (LMD) w/ Fast Operate" },

    { 0x0200,  "SEL Fast Meter w/ Fast Message" },

    { 0x0300,  "SEL Fast Meter w/ Fast Operate and Fast Message" },

    { 0x0301,  "SEL Limited Multidrop (LMD) w/ Fast Operate and Fast Message" },

    { 0,                         NULL }

};

static value_string_ext selfm_relaydef_proto_vals_ext = VALUE_STRING_EXT_INIT(selfm_relaydef_proto_vals);

static const value_string selfm_fmconfig_ai_chtype_vals[] = {

    { FM_CONFIG_ANA_CHTYPE_INT16,  "16-Bit Integer" },

    { FM_CONFIG_ANA_CHTYPE_FP,     "IEEE Floating Point" },

    { FM_CONFIG_ANA_CHTYPE_FPD,    "IEEE Floating Point (Double)" },

    { FM_CONFIG_ANA_CHTYPE_TS,     "8-byte Time Stamp" },

    { 0,                           NULL }

};

static const value_string selfm_fmconfig_ai_sftype_vals[] = {

    { FM_CONFIG_ANA_SFTYPE_INT16,  "16-Bit Integer" },

    { FM_CONFIG_ANA_SFTYPE_FP,     "IEEE Floating Point" },

    { FM_CONFIG_ANA_SFTYPE_FPD,    "IEEE Floating Point (Double)" },

    { FM_CONFIG_ANA_SFTYPE_TS,     "8-byte Time Stamp" },

    { FM_CONFIG_ANA_SFTYPE_NONE,   "None" },

    { 0,                           NULL }

};

static const value_string selfm_fmconfig_sfloc_vals[] = {

    { FM_CONFIG_SF_LOC_FM,  "In Fast Meter Message" },

    { FM_CONFIG_SF_LOC_CFG, "In Configuration Message" },

    { 0,                           NULL }

};

/* Depending on number of analog samples present in Fast Meter Messages, identification of data will change */

static const value_string selfm_fmconfig_numsamples1_vals[] = {

    { 1,              "Magnitudes Only" },

    { 0,                           NULL }

};

static const value_string selfm_fmconfig_numsamples2_vals[] = {

    { 1,              "Imaginary Components" },

    { 2,              "Real Components" },

    { 0,                           NULL }

};

static const value_string selfm_fmconfig_numsamples4_vals[] = {

    { 1,              "1st Quarter Cycle Data" },

    { 2,              "2nd Quarter Cycle Data" },

    { 3,              "5th Quarter-Cycle Data" },

    { 4,              "6th Quarter-Cycle Data" },

    { 0,                           NULL }

};

/* Calculation Block lookup values */

static const value_string selfm_fmconfig_cblk_rot_vals[] = {

    { 0x00,      "ABC Rotation" },

    { 0x01,      "ACB Rotation" },

    { 0,         NULL           }

};

static const value_string selfm_fmconfig_cblk_vconn_vals[] = {

    { 0x00,      "Y-Connected" },

    { 0x01,      "Delta-Connected (in seq. Vab, Vbc, Vca)" },

    { 0x02,      "Delta-Connected (in seq. Vac, Vba, Vcb)" },

    { 0,         NULL           }

};

static const value_string selfm_fmconfig_cblk_iconn_vals[] = {

    { 0x00,      "Y-Connected" },

    { 0x01,      "Delta-Connected (in seq. Iab, Ibc, Ica)" },

    { 0x02,      "Delta-Connected (in seq. Iac, Iba, Icb)" },

    { 0,         NULL           }

};

static const value_string selfm_fmconfig_cblk_ctype_vals[] = {

    { 0,      "Standard Power Calculations" },

    { 1,      "2-1/2 Element Delta Power Calculation" },

    { 2,      "Voltages-Only" },

    { 3,      "Currents-Only" },

    { 4,      "Single-Phase Ia and Va Only" },

    { 5,      "Standard Power Calcs with 2 sets of Currents" },

    { 6,      "2-1/2 Element Delta Power Calcs with 2 sets of Currents" },

    { 0,         NULL           }

};

/* Fast Operate Remote Bit 'Pulse Supported' Lookup */

static const value_string selfm_foconfig_prb_supp_vals[] = {

    { 0x00,  "No" },

    { 0x01,  "Yes" },

    { 0,                      NULL }

};

/* SER Status Value Lookup */

static const value_string selfm_ser_status_vals[] = {

    { 0x00,  "Deasserted" },

    { 0x01,  "Asserted" },

    { 0,  NULL }

};

/* Fast Operate Remote Bit Lookup */

static const value_string selfm_fo_rb_vals[] = {

    { 0x00,  "RB01 Clear" },

    { 0x01,  "RB02 Clear" },

    { 0x02,  "RB03 Clear" },

    { 0x03,  "RB04 Clear" },

    { 0x04,  "RB05 Clear" },

    { 0x05,  "RB06 Clear" },

    { 0x06,  "RB07 Clear" },

    { 0x07,  "RB08 Clear" },

    { 0x08,  "RB09 Clear" },

    { 0x09,  "RB10 Clear" },

    { 0x0A,  "RB11 Clear" },

    { 0x0B,  "RB12 Clear" },

    { 0x0C,  "RB13 Clear" },

    { 0x0D,  "RB14 Clear" },

    { 0x0E,  "RB15 Clear" },

    { 0x0F,  "RB16 Clear" },

    { 0x10,  "RB17 Clear" },

    { 0x11,  "RB18 Clear" },

    { 0x12,  "RB19 Clear" },

    { 0x13,  "RB20 Clear" },

    { 0x14,  "RB21 Clear" },

    { 0x15,  "RB22 Clear" },

    { 0x16,  "RB23 Clear" },

    { 0x17,  "RB24 Clear" },

    { 0x18,  "RB25 Clear" },

    { 0x19,  "RB26 Clear" },

    { 0x1A,  "RB27 Clear" },

    { 0x1B,  "RB28 Clear" },

    { 0x1C,  "RB29 Clear" },

    { 0x1D,  "RB30 Clear" },

    { 0x1E,  "RB31 Clear" },

    { 0x1F,  "RB32 Clear" },

    { 0x20,  "RB01 Set" },

    { 0x21,  "RB02 Set" },

    { 0x22,  "RB03 Set" },

    { 0x23,  "RB04 Set" },

    { 0x24,  "RB05 Set" },

    { 0x25,  "RB06 Set" },

    { 0x26,  "RB07 Set" },

    { 0x27,  "RB08 Set" },

    { 0x28,  "RB09 Set" },

    { 0x29,  "RB10 Set" },

    { 0x2A,  "RB11 Set" },

    { 0x2B,  "RB12 Set" },

    { 0x2C,  "RB13 Set" },

    { 0x2D,  "RB14 Set" },

    { 0x2E,  "RB15 Set" },

    { 0x2F,  "RB16 Set" },

    { 0x30,  "RB17 Set" },

    { 0x31,  "RB18 Set" },

    { 0x32,  "RB19 Set" },

    { 0x33,  "RB20 Set" },

    { 0x34,  "RB21 Set" },

    { 0x35,  "RB22 Set" },

    { 0x36,  "RB23 Set" },

    { 0x37,  "RB24 Set" },

    { 0x38,  "RB25 Set" },

    { 0x39,  "RB26 Set" },

    { 0x3A,  "RB27 Set" },

    { 0x3B,  "RB28 Set" },

    { 0x3C,  "RB29 Set" },

    { 0x3D,  "RB30 Set" },

    { 0x3E,  "RB31 Set" },

    { 0x3F,  "RB32 Set" },

    { 0x40,  "RB01 Pulse" },

    { 0x41,  "RB02 Pulse" },

    { 0x42,  "RB03 Pulse" },

    { 0x43,  "RB04 Pulse" },

    { 0x44,  "RB05 Pulse" },

    { 0x45,  "RB06 Pulse" },

    { 0x46,  "RB07 Pulse" },

    { 0x47,  "RB08 Pulse" },

    { 0x48,  "RB09 Pulse" },

    { 0x49,  "RB10 Pulse" },

    { 0x4A,  "RB11 Pulse" },

    { 0x4B,  "RB12 Pulse" },

    { 0x4C,  "RB13 Pulse" },

    { 0x4D,  "RB14 Pulse" },

    { 0x4E,  "RB15 Pulse" },

    { 0x4F,  "RB16 Pulse" },

    { 0x50,  "RB17 Pulse" },

    { 0x51,  "RB18 Pulse" },

    { 0x52,  "RB19 Pulse" },

    { 0x53,  "RB20 Pulse" },

    { 0x54,  "RB21 Pulse" },

    { 0x55,  "RB22 Pulse" },

    { 0x56,  "RB23 Pulse" },

    { 0x57,  "RB24 Pulse" },

    { 0x58,  "RB25 Pulse" },

    { 0x59,  "RB26 Pulse" },

    { 0x5A,  "RB27 Pulse" },

    { 0x5B,  "RB28 Pulse" },

    { 0x5C,  "RB29 Pulse" },

    { 0x5D,  "RB30 Pulse" },

    { 0x5E,  "RB31 Pulse" },

    { 0x5F,  "RB32 Pulse" },

    { 0,             NULL }

};

static value_string_ext selfm_fo_rb_vals_ext = VALUE_STRING_EXT_INIT(selfm_fo_rb_vals);

/* Fast Operate Breaker Bit Lookup */

static const value_string selfm_fo_br_vals[] = {

    { 0x11, "Breaker Bit 1 Close (CC/CC1)" },

    { 0x12, "Breaker Bit 2 Close (CC2)" },

    { 0x13, "Breaker Bit 3 Close (CC3)" },

    { 0x14, "Breaker Bit 4 Close (CC4)" },

    { 0x15, "Breaker Bit 5 Close (CC5)" },

    { 0x16, "Breaker Bit 6 Close (CC6)" },

    { 0x17, "Breaker Bit 7 Close (CC7)" },

    { 0x18, "Breaker Bit 8 Close (CC8)" },

    { 0x19, "Breaker Bit 9 Close (CC9)" },

    { 0x1A, "Breaker Bit 10 Close (CC10)" },

    { 0x1B, "Breaker Bit 11 Close (CC11)" },

    { 0x1C, "Breaker Bit 12 Close (CC12)" },

    { 0x1D, "Breaker Bit 13 Close (CC13)" },

    { 0x1E, "Breaker Bit 14 Close (CC14)" },

    { 0x1F, "Breaker Bit 15 Close (CC15)" },

    { 0x20, "Breaker Bit 16 Close (CC16)" },

    { 0x21, "Breaker Bit 17 Close (CC17)" },

    { 0x22, "Breaker Bit 18 Close (CC18)" },

    { 0x31, "Breaker Bit 1 Open (OC/OC1)" },

    { 0x32, "Breaker Bit 2 Open (OC2)" },

    { 0x33, "Breaker Bit 3 Open (OC3)" },

    { 0x34, "Breaker Bit 4 Open (OC4)" },

    { 0x35, "Breaker Bit 5 Open (OC5)" },

    { 0x36, "Breaker Bit 6 Open (OC6)" },

    { 0x37, "Breaker Bit 7 Open (OC7)" },

    { 0x38, "Breaker Bit 8 Open (OC8)" },

    { 0x39, "Breaker Bit 9 Open (OC9)" },

    { 0x3A, "Breaker Bit 10 Open (OC10)" },

    { 0x3B, "Breaker Bit 11 Open (OC11)" },

    { 0x3C, "Breaker Bit 12 Open (OC12)" },

    { 0x3D, "Breaker Bit 13 Open (OC13)" },

    { 0x3E, "Breaker Bit 14 Open (OC14)" },

    { 0x3F, "Breaker Bit 15 Open (OC15)" },

    { 0x40, "Breaker Bit 16 Open (OC16)" },

    { 0x41, "Breaker Bit 17 Open (OC17)" },

    { 0x42, "Breaker Bit 18 Open (OC18)" },

    { 0,                           NULL }

};

static value_string_ext selfm_fo_br_vals_ext = VALUE_STRING_EXT_INIT(selfm_fo_br_vals);

/* Alternate Fast Operate Function Code Lookup */

static const value_string selfm_foconfig_alt_funccode_vals[] = {

    { 0xE5, "Open Breaker Bit"  },

    { 0xE6, "Close Breaker Bit" },

    { 0xE7, "Set Remote Bit"    },

    { 0xE8, "Clear Remote Bit"  },

    { 0xE9, "Pulse Remote Bit"  },

    { 0x00, "Unsupported"       },

    { 0,                   NULL }

};

/* Fast Message Function Codes */

static const value_string selfm_fastmsg_func_code_vals[] = {

    { FAST_MSG_CFG_BLOCK,         "Fast Message Configuration Block Request" },

    { FAST_MSG_EN_UNS_DATA,       "Enable Unsolicited Data" },

    { FAST_MSG_DIS_UNS_DATA,      "Disable Unsolicited Data" },

    { FAST_MSG_PING,              "Ping Message" },

    { FAST_MSG_READ_REQ,          "Read Request" },

    { FAST_MSG_GEN_UNS_DATA,      "Generic Unsolicited Data" },

    { FAST_MSG_SOE_STATE_REQ,     "SOE Present State Request" },

    { FAST_MSG_UNS_RESP,          "Unsolicited Fast SER Data Response" },

    { FAST_MSG_UNS_WRITE,         "Unsolicited Write" },

    { FAST_MSG_UNS_WRITE_REQ,     "Unsolicited Write Request" },

    { FAST_MSG_DEVDESC_REQ,       "Device Description Request" },

    { FAST_MSG_DATAFMT_REQ,       "Data Format Request" },

    { FAST_MSG_UNS_DATAFMT_RESP,  "Unsolicited Data Format Response" },

    { FAST_MSG_BITLABEL_REQ,      "Bit Label Request" },

    { FAST_MSG_MGMT_REQ,          "Management Request" },

    { FAST_MSG_CFG_BLOCK_RESP,    "Fast Message Configuration Block Response" },

    { FAST_MSG_EN_UNS_DATA_ACK,   "Enable Unsolicited Data ACK" },

    { FAST_MSG_DIS_UNS_DATA_ACK,  "Disable Unsolicited Data ACK" },

    { FAST_MSG_PING_ACK,          "Ping Message ACK" },

    { FAST_MSG_READ_RESP,         "Read Response" },

    { FAST_MSG_SOE_STATE_RESP,    "SOE Present State Response" },

    { FAST_MSG_UNS_RESP_ACK,      "Unsolicited Fast SER Data Response ACK" },

    { FAST_MSG_DEVDESC_RESP,      "Device Description Response" },

    { FAST_MSG_DATAFMT_RESP,      "Data Format Response" },

    { FAST_MSG_BITLABEL_RESP,     "Bit Label Response" },

    { 0,                           NULL }

};

static value_string_ext selfm_fastmsg_func_code_vals_ext =

    VALUE_STRING_EXT_INIT(selfm_fastmsg_func_code_vals);

static const value_string selfm_fastmsg_tagtype_vals[] = {

    { FAST_MSG_TAGTYPE_CHAR8,        "1 x 8-bit character per item" },

    { FAST_MSG_TAGTYPE_CHAR16,       "2 x 8-bit characters per item" },

    { FAST_MSG_TAGTYPE_DIGWORD8_BL,  "8-bit binary item, with labels" },

    { FAST_MSG_TAGTYPE_DIGWORD8,     "8-bit binary item, without labels" },

    { FAST_MSG_TAGTYPE_DIGWORD16_BL, "16-bit binary item, with labels" },

    { FAST_MSG_TAGTYPE_DIGWORD16,    "16-bit binary item, without labels" },

    { FAST_MSG_TAGTYPE_INT16,        "16-bit Signed Integer" },

    { FAST_MSG_TAGTYPE_UINT16,       "16-bit Unsigned Integer" },

    { FAST_MSG_TAGTYPE_INT32,        "32-bit Signed Integer" },

    { FAST_MSG_TAGTYPE_UINT32,       "32-bit Unsigned Integer" },

    { FAST_MSG_TAGTYPE_FLOAT,        "IEEE Floating Point" },

    { 0,  NULL }

};

/* Fast Message ACK Response Codes */

static const value_string selfm_fastmsg_ack_responsecode_vals[] = {

    { 0x0,  "Success" },

    { 0x1,  "Function code not recognized" },

    { 0x2,  "Function code supported but disabled" },

    { 0x3,  "Invalid Data Address" },

    { 0x4,  "Bad Data" },

    { 0x5,  "Insufficient Memory" },

    { 0x6,  "Busy" },

    { 0,  NULL }

};

static value_string_ext selfm_fastmsg_ack_responsecode_vals_ext =

    VALUE_STRING_EXT_INIT(selfm_fastmsg_ack_responsecode_vals);

/* Fast Message Unsolicited Write COM Port Codes */

static const value_string selfm_fastmsg_unswrite_com_vals[] = {

    { 0x0100,   "COM01" },

    { 0x0200,   "COM02" },

    { 0x0300,   "COM03" },

    { 0x0400,   "COM04" },

    { 0x0500,   "COM05" },

    { 0x0600,   "COM06" },

    { 0x0700,   "COM07" },

    { 0x0800,   "COM08" },

    { 0x0900,   "COM09" },

    { 0x0A00,   "COM10" },

    { 0x0B00,   "COM11" },

    { 0x0C00,   "COM12" },

    { 0x0D00,   "COM13" },

    { 0x0E00,   "COM14" },

    { 0x0F00,   "COM15" },

    { 0,  NULL }

};

static value_string_ext selfm_fastmsg_unswrite_com_vals_ext =

    VALUE_STRING_EXT_INIT(selfm_fastmsg_unswrite_com_vals);

/* Tables for reassembly of fragments. */

static reassembly_table selfm_reassembly_table;

/* ************************************************************************* */

/*                   Header values for reassembly                            */

/* ************************************************************************* */

static int   hf_selfm_fragment;

static int   hf_selfm_fragments;

static int   hf_selfm_fragment_overlap;

static int   hf_selfm_fragment_overlap_conflict;

static int   hf_selfm_fragment_multiple_tails;

static int   hf_selfm_fragment_too_long_fragment;

static int   hf_selfm_fragment_error;

static int   hf_selfm_fragment_count;

static int   hf_selfm_fragment_reassembled_in;

static int   hf_selfm_fragment_reassembled_length;

static int ett_selfm_fragment;

static int ett_selfm_fragments;

static const fragment_items selfm_frag_items = {

    &ett_selfm_fragment,

    &ett_selfm_fragments,

    &hf_selfm_fragments,

    &hf_selfm_fragment,

    &hf_selfm_fragment_overlap,

    &hf_selfm_fragment_overlap_conflict,

    &hf_selfm_fragment_multiple_tails,

    &hf_selfm_fragment_too_long_fragment,

    &hf_selfm_fragment_error,

    &hf_selfm_fragment_count,

    &hf_selfm_fragment_reassembled_in,

    &hf_selfm_fragment_reassembled_length,

    /* Reassembled data field */

    NULL,

    "SEL Fast Message fragments"

};

/**********************************************************************************************************/

/* Clean all instances of 0xFFFF from Telnet payload to compensate for IAC control code (replace w/ 0xFF) */

/* Function Duplicated from packet-telnet.c (unescape_and_tvbuffify_telnet_option)                        */

/**********************************************************************************************************/

static tvbuff_t *

clean_telnet_iac(packet_info *pinfo, tvbuff_t *tvb, int offset, int len, int *num_skip_byte)

{

    tvbuff_t     *telnet_tvb;

    uint8_t      *buf;

    const uint8_t *spos;

    uint8_t      *dpos;

    int           len_remaining, skip_byte = 0;

    spos=tvb_get_ptr(tvb, offset, len);

    buf=(uint8_t *)wmem_alloc(pinfo->pool, len);

    dpos=buf;

    len_remaining = len;

    while(len_remaining > 0){

        /* Only analyze two sequential bytes of source tvb if we have at least two bytes left */

        if (len_remaining > 1) {

            /* If two sequential 0xFF's exist, increment skip_byte counter, decrement  */

            /* len_remaining by 2 and copy a single 0xFF to dest tvb. */

            if((spos[0]==0xff) && (spos[1]==0xff)){

                skip_byte++;

                len_remaining -= 2;

                *(dpos++)=0xff;

                spos+=2;

                continue;

            }

        }

        /* If we only have a single byte left, or there were no sequential 0xFF's, copy byte from src tvb to dest tvb */

        *(dpos++)=*(spos++);

        len_remaining--;

    }

    telnet_tvb = tvb_new_child_real_data(tvb, buf, len-skip_byte, len-skip_byte);

    add_new_data_source(pinfo, telnet_tvb, "Processed Telnet Data");

    *num_skip_byte = skip_byte;

    return telnet_tvb;

}

/* Names are copied from the packet into fixed buffers and shown in item

 * labels, which must be valid UTF-8: replace any octet that is not ASCII. */

static void

selfm_ascii_name(char *name)

{

    for (; *name != '\0'; name++) {

        if ((unsigned char)*name >= 0x80) {

            *name = '?';

        }

    }

}

/******************************************************************************************************/

/* Execute dissection of Fast Meter configuration frames independent of any GUI access of said frames */

/* Load configuration information into fm_config_frame struct */

/******************************************************************************************************/

static fm_config_frame* fmconfig_frame_fast(tvbuff_t *tvb)

{

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

    unsigned        count, offset = 0;

    fm_config_frame *frame;

    /* get a new frame and initialize it */

    frame = wmem_new(wmem_file_scope(), fm_config_frame);

    /* Get data packet setup information from config message and copy into ai_info (if required) */

    frame->cfg_cmd        = tvb_get_ntohs(tvb, offset);

    /* skip length byte, position offset+2 */

    frame->num_flags      = tvb_get_uint8(tvb, offset+3);

    frame->sf_loc         = tvb_get_uint8(tvb, offset+4);

    frame->sf_num         = tvb_get_uint8(tvb, offset+5);

    frame->num_ai         = tvb_get_uint8(tvb, offset+6);

    frame->num_ai_samples = tvb_get_uint8(tvb, offset+7);

    frame->num_dig        = tvb_get_uint8(tvb, offset+8);

    frame->num_calc       = tvb_get_uint8(tvb, offset+9);

    /* Update offset pointer */

    offset += 10;

    /* Get data packet analog/timestamp/digital offsets and copy into ai_info */

    frame->offset_ai  = tvb_get_ntohs(tvb, offset);

    frame->offset_ts  = tvb_get_ntohs(tvb, offset+2);

    frame->offset_dig = tvb_get_ntohs(tvb, offset+4);

    /* Update offset pointer */

    offset += 6;

    frame->analogs = (fm_analog_info *)wmem_alloc(wmem_file_scope(), frame->num_ai * sizeof(fm_analog_info));

    /* Get AI Channel Details and copy into ai_info */

    for (count = 0; count < frame->num_ai; count++) {

        fm_analog_info *analog = &(frame->analogs[count]);

        tvb_memcpy(tvb, analog->name, offset, FM_CONFIG_ANA_CHNAME_LEN);

        analog->name[FM_CONFIG_ANA_CHNAME_LEN] = '\0'; /* Put a terminating null onto the end of the AI Channel name */

        selfm_ascii_name(analog->name);

        analog->type = tvb_get_uint8(tvb, offset+6);

        analog->sf_type = tvb_get_uint8(tvb, offset+7);

        analog->sf_offset = tvb_get_ntohs(tvb, offset+8);

        /* If Scale Factors are present in the cfg message, retrieve and store them per analog */

        /* Otherwise, default to Scale Factor of 1 for now */

        if (frame->sf_loc == FM_CONFIG_SF_LOC_CFG) {

            analog->sf_fp = tvb_get_ntohieee_float(tvb, analog->sf_offset);

        }

        else {

            analog->sf_fp = 1;

        }

        offset += 10;

    }

    return frame;

}

/******************************************************************************************************/

/* Execute dissection of Data Item definition info before loading GUI tree                            */

/* Load configuration information into fastmsg_dataitem struct                                        */

/******************************************************************************************************/

static fastmsg_dataitem* fastmsg_dataitem_save(tvbuff_t *tvb, int offset)

{

    fastmsg_dataitem *dataitem;

    /* get a new dataitem and initialize it */

    dataitem = wmem_new(wmem_file_scope(), fastmsg_dataitem);

    /* retrieve data item name and terminate with a null */

    tvb_memcpy(tvb, dataitem->name, offset, 10);

    dataitem->name[10] = '\0'; /* Put a terminating null onto the end of the string */

    selfm_ascii_name(dataitem->name);

    /* retrieve data item quantity and type */

    dataitem->quantity = tvb_get_ntohs(tvb, offset+10);

    dataitem->data_type = tvb_get_ntohs(tvb, offset+12);

    return dataitem;

}

/******************************************************************************************************/

/* Execute dissection of Data Region definition info before loading GUI tree                          */

/* Load configuration information into fastmsg_dataregion struct                                      */

/******************************************************************************************************/

static fastmsg_dataregion* fastmsg_dataregion_save(tvbuff_t *tvb, int offset)

{

    fastmsg_dataregion *dataregion;

    /* get a new dataregion and initialize it */

    dataregion = wmem_new(wmem_file_scope(), fastmsg_dataregion);

    /* retrieve data region name and terminate with a null */

    tvb_memcpy(tvb, dataregion->name, offset, 10);

    dataregion->name[10] = '\0'; /* Put a terminating null onto the end of the string */

    selfm_ascii_name(dataregion->name);

    return dataregion;

}

/********************************************************************************************************/

/* Lookup region name using current base address & saved conversation data.  Return ptr to char string */

/********************************************************************************************************/

static const char*

region_lookup(packet_info *pinfo, uint32_t base_addr)

{

    fm_conversation    *conv;

    fastmsg_dataregion *dataregion = NULL;

    conv = (fm_conversation *)p_get_proto_data(wmem_file_scope(), pinfo, proto_selfm, 0);

    if (conv) {

        dataregion = (fastmsg_dataregion*)wmem_tree_lookup32(conv->fastmsg_dataregions, base_addr);

    }

    if (dataregion) {

        return dataregion->name;

    }

    /* If we couldn't identify the region using the current base address, return a default string */

    return "Unknown Region";

}

/***********************************************************************************************************/

/* Create Fast SER Unsolicited Word Bit item.  Return item to calling function.  'index' parameter         */

/* will be used to store 'name' parameter in lookup tree.  Index 254 and 255 are special (hardcoded) cases */

/***********************************************************************************************************/

static fastser_uns_wordbit* fastser_uns_wordbit_save(uint8_t idx, const char *name)

{

    fastser_uns_wordbit *wordbit_item;

    /* get a new wordbit_item and initialize it */

    wordbit_item = wmem_new(wmem_file_scope(), fastser_uns_wordbit);

    if (idx <= 253) {

        wordbit_item->name = wmem_strdup(wmem_file_scope(), name);

    }

    if (idx == 254) {

        wordbit_item->name = wmem_strdup(wmem_file_scope(), "POWER_UP");

    }

    if (idx == 255) {

        wordbit_item->name = wmem_strdup(wmem_file_scope(), "SET_CHNG");

    }

    return wordbit_item;

}

/***************************************************************************************************************/

/* Lookup uns wordbit name using current index position & saved conversation data.  Return ptr to char string */

/***************************************************************************************************************/

static const char*

fastser_uns_wordbit_lookup(packet_info *pinfo, uint8_t idx)

{

    fm_conversation    *conv;

    fastser_uns_wordbit *wordbit = NULL;

    conv = (fm_conversation *)p_get_proto_data(wmem_file_scope(), pinfo, proto_selfm, 0);

    if (conv) {

        wordbit = (fastser_uns_wordbit*)wmem_tree_lookup32(conv->fastser_uns_wordbits, idx);

    }

    if (wordbit) {

        return wordbit->name;

    }

    /* If we couldn't identify the bit using the index, return a default string */

    return "Unknown";

}

/******************************************************************************************************/

/* Code to Dissect Relay Definition Frames */

/******************************************************************************************************/

static int

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

{

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

    proto_item    *relaydef_fm_item, *relaydef_flags_item, *relaydef_proto_item;

    proto_tree    *relaydef_tree, *relaydef_fm_tree, *relaydef_flags_tree, *relaydef_proto_tree;