diff options
Diffstat (limited to 'epan/dissectors/packet-synphasor.c')
| -rw-r--r-- | epan/dissectors/packet-synphasor.c | 2376 |
1 files changed, 2376 insertions, 0 deletions
diff --git a/epan/dissectors/packet-synphasor.c b/epan/dissectors/packet-synphasor.c new file mode 100644 index 00000000..3d8d4e09 --- /dev/null +++ b/epan/dissectors/packet-synphasor.c @@ -0,0 +1,2376 @@ +/* packet-synphasor.c + * Dissector for IEEE C37.118 synchrophasor frames. + * + * Copyright 2008, Jens Steinhauser <jens.steinhauser@omicron.at> + * Copyright 2019, Dwayne Rich <dwayne_rich@selinc.com> + * Copyright 2020, Dmitriy Eliseev <eliseev_d@ntcees.ru> + * + * 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 <math.h> + +#include <epan/packet.h> +#include <epan/crc16-tvb.h> +#include <epan/expert.h> +#include <epan/proto_data.h> +#include "packet-tcp.h" + +#include <wsutil/utf8_entities.h> + +#define PNAME "IEEE C37.118 Synchrophasor Protocol" +#define PSNAME "SYNCHROPHASOR" +#define PFNAME "synphasor" + +/* forward references */ +void proto_register_synphasor(void); +void proto_reg_handoff_synphasor(void); + +/* global variables */ + +static int proto_synphasor = -1; + +/* user preferences */ +#define SYNPHASOR_TCP_PORT 4712 /* Not IANA registered */ +#define SYNPHASOR_UDP_PORT 4713 /* Not IANA registered */ + +/* Config 1 & 2 frames have channel names that are all 16 bytes long */ +/* Config 3 frame channel names have a variable length with a max of 255 characters */ +#define CHNAM_LEN 16 +#define MAX_NAME_LEN 255 +#define G_PMU_ID_LEN 16 + +/* the ett... variables hold the state (open/close) of the treeview in the GUI */ +static gint ett_synphasor = -1; /* root element for this protocol */ + /* used in the common header */ + static gint ett_frtype = -1; + static gint ett_timequal = -1; + /* used for config frames */ + static gint ett_conf = -1; + static gint ett_conf_station = -1; + static gint ett_conf_format = -1; + static gint ett_conf_phnam = -1; + static gint ett_conf_annam = -1; + static gint ett_conf_dgnam = -1; + static gint ett_conf_phconv = -1; + static gint ett_conf_phlist = -1; + static gint ett_conf_phflags = -1; + static gint ett_conf_phmod_flags = -1; + static gint ett_conf_ph_user_flags = -1; + static gint ett_conf_anconv = -1; + static gint ett_conf_anlist = -1; + static gint ett_conf_dgmask = -1; + static gint ett_conf_chnam = -1; + static gint ett_conf_wgs84 = -1; + /* used for data frames */ + static gint ett_data = -1; + static gint ett_data_block = -1; + static gint ett_data_stat = -1; + static gint ett_data_phasors = -1; + static gint ett_data_analog = -1; + static gint ett_data_digital = -1; + /* used for command frames */ + static gint ett_command = -1; + static gint ett_status_word_mask = -1; + +/* handles to the header fields hf[] in proto_register_synphasor() */ +static int hf_sync = -1; +static int hf_sync_frtype = -1; +static int hf_sync_version = -1; +static int hf_station_name_len = -1; +static int hf_station_name = -1; +static int hf_idcode_stream_source = -1; +static int hf_idcode_data_source = -1; +static int hf_g_pmu_id = -1; +static int hf_frsize = -1; +static int hf_soc = -1; +static int hf_timeqal_lsdir = -1; +static int hf_timeqal_lsocc = -1; +static int hf_timeqal_lspend = -1; +static int hf_timeqal_timequalindic = -1; +static int hf_fracsec_raw = -1; +static int hf_fracsec_ms = -1; +static int hf_cont_idx = -1; +static int hf_conf_timebase = -1; +static int hf_conf_numpmu = -1; +static int hf_conf_formatb3 = -1; +static int hf_conf_formatb2 = -1; +static int hf_conf_formatb1 = -1; +static int hf_conf_formatb0 = -1; +static int hf_conf_chnam_len = -1; +static int hf_conf_chnam = -1; +static int hf_conf_phasor_mod_b15 = -1; +static int hf_conf_phasor_mod_b10 = -1; +static int hf_conf_phasor_mod_b09 = -1; +static int hf_conf_phasor_mod_b08 = -1; +static int hf_conf_phasor_mod_b07 = -1; +static int hf_conf_phasor_mod_b06 = -1; +static int hf_conf_phasor_mod_b05 = -1; +static int hf_conf_phasor_mod_b04 = -1; +static int hf_conf_phasor_mod_b03 = -1; +static int hf_conf_phasor_mod_b02 = -1; +static int hf_conf_phasor_mod_b01 = -1; +static int hf_conf_phasor_type_b03 = -1; +static int hf_conf_phasor_type_b02to00 = -1; +static int hf_conf_phasor_user_data = -1; +static int hf_conf_phasor_scale_factor = -1; +static int hf_conf_phasor_angle_offset = -1; +static int hf_conf_analog_scale_factor = -1; +static int hf_conf_analog_offset = -1; +static int hf_conf_pmu_lat = -1; +static int hf_conf_pmu_lon = -1; +static int hf_conf_pmu_elev = -1; +static int hf_conf_pmu_lat_unknown = -1; +static int hf_conf_pmu_lon_unknown = -1; +static int hf_conf_pmu_elev_unknown = -1; +static int hf_conf_svc_class = -1; +static int hf_conf_window = -1; +static int hf_conf_grp_dly = -1; +static int hf_conf_fnom = -1; +static int hf_conf_cfgcnt = -1; +static int hf_data_statb15to14 = -1; +static int hf_data_statb13 = -1; +static int hf_data_statb12 = -1; +static int hf_data_statb11 = -1; +static int hf_data_statb10 = -1; +static int hf_data_statb09 = -1; +static int hf_data_statb08to06 = -1; +static int hf_data_statb05to04 = -1; +static int hf_data_statb03to00 = -1; +static int hf_command = -1; +static int hf_cfg_frame_num = -1; + +/* Generated from convert_proto_tree_add_text.pl */ +static int hf_synphasor_data = -1; +static int hf_synphasor_checksum = -1; +static int hf_synphasor_checksum_status = -1; +static int hf_synphasor_num_phasors = -1; +static int hf_synphasor_num_analog_values = -1; +static int hf_synphasor_num_digital_status_words = -1; +static int hf_synphasor_rate_of_transmission = -1; +static int hf_synphasor_phasor = -1; +static int hf_synphasor_actual_frequency_value = -1; +static int hf_synphasor_rate_change_frequency = -1; +static int hf_synphasor_frequency_deviation_from_nominal = -1; +static int hf_synphasor_analog_value = -1; +static int hf_synphasor_digital_status_word = -1; +static int hf_synphasor_conversion_factor = -1; +static int hf_synphasor_factor_for_analog_value = -1; +static int hf_synphasor_channel_name = -1; +static int hf_synphasor_extended_frame_data = -1; +static int hf_synphasor_unknown_data = -1; +static int hf_synphasor_status_word_mask_normal_state = -1; +static int hf_synphasor_status_word_mask_valid_bits = -1; + +static expert_field ei_synphasor_extended_frame_data = EI_INIT; +static expert_field ei_synphasor_checksum = EI_INIT; +static expert_field ei_synphasor_data_error = EI_INIT; +static expert_field ei_synphasor_pmu_not_sync = EI_INIT; + +static dissector_handle_t synphasor_udp_handle; +static dissector_handle_t synphasor_tcp_handle; + +/* the different frame types for this protocol */ +enum FrameType { + DATA = 0, + HEADER, + CFG1, + CFG2, + CMD, + CFG3 +}; + +/* Structures to save CFG frame content. */ + +/* type to indicate the format for (D)FREQ/PHASORS/ANALOG in data frame */ +typedef enum { integer, /* 16 bit signed integer */ + floating_point /* single precision floating point */ +} data_format; + +typedef enum { rect, polar } phasor_notation_e; + +typedef enum { V, A } unit_e; + +/* holds the information required to dissect a single phasor */ +typedef struct { + char name[MAX_NAME_LEN + 1]; + unit_e unit; + guint32 conv; /* cfg-2 conversion factor in 10^-5 scale */ + float conv_cfg3; /* cfg-3 conversion scale factor */ + float angle_offset_cfg3; /* cfg-3 angle offset */ +} phasor_info; + +/* holds the information for an analog value */ +typedef struct { + char name[MAX_NAME_LEN + 1]; + guint32 conv; /* cfg-2 conversion scale factor, user defined scaling (so it's pretty useless) */ + float conv_cfg3; /* cfg-3 conversion scale factor */ + float offset_cfg3; /* cfg-3 conversion offset */ +} analog_info; + +/* holds information required to dissect a single PMU block in a data frame */ +typedef struct { + guint16 id; /* (Data Source ID) identifies source of block */ + char name[MAX_NAME_LEN + 1]; /* holds STN */ + guint8 cfg_frame_type; /* Config Frame Type (1,2,3,...) */ + data_format format_fr; /* data format of FREQ and DFREQ */ + data_format format_ph; /* data format of PHASORS */ + data_format format_an; /* data format of ANALOG */ + phasor_notation_e phasor_notation; /* format of the phasors */ + guint fnom; /* nominal line frequency */ + guint num_dg; /* number of digital status words */ + wmem_array_t *phasors; /* array of phasor_infos */ + wmem_array_t *analogs; /* array of analog_infos */ +} config_block; + +/* holds the id the configuration comes from an and + * an array of config_block members */ +typedef struct { + guint32 fnum; /* frame number */ + guint16 id; /* (Stream Source ID) identifies source of stream */ + guint32 time_base; /* Time base - resolution of FRACSEC time stamp. */ + wmem_array_t *config_blocks; /* Contains a config_block struct for + * every PMU included in the config frame */ +} config_frame; + +/* strings for type bits in SYNC */ +static const value_string typenames[] = { + { 0, "Data Frame" }, + { 1, "Header Frame" }, + { 2, "Configuration Frame 1" }, + { 3, "Configuration Frame 2" }, + { 4, "Command Frame" }, + { 5, "Configuration Frame 3" }, + { 0, NULL } +}; + +/* strings for version bits in SYNC */ +static const value_string versionnames[] = { + { 1, "Defined in IEEE Std C37.118-2005" }, + { 2, "Added in IEEE Std C37.118.2-2011" }, + { 0, NULL } +}; + +/* strings for the time quality flags in FRACSEC */ +static const true_false_string leapseconddir = { + "Add", + "Delete" +}; +static const value_string timequalcodes[] = { + { 0xF, "Clock failure, time not reliable" }, + { 0xB, "Clock unlocked, time within 10 s" }, + { 0xA, "Clock unlocked, time within 1 s" }, + { 0x9, "Clock unlocked, time within 10^-1 s" }, + { 0x8, "Clock unlocked, time within 10^-2 s" }, + { 0x7, "Clock unlocked, time within 10^-3 s" }, + { 0x6, "Clock unlocked, time within 10^-4 s" }, + { 0x5, "Clock unlocked, time within 10^-5 s" }, + { 0x4, "Clock unlocked, time within 10^-6 s" }, + { 0x3, "Clock unlocked, time within 10^-7 s" }, + { 0x2, "Clock unlocked, time within 10^-8 s" }, + { 0x1, "Clock unlocked, time within 10^-9 s" }, + { 0x0, "Normal operation, clock locked" }, + { 0 , NULL } +}; + +/* strings for flags in the FORMAT word of a configuration frame */ +static const true_false_string conf_formatb123names = { + "32-bit IEEE floating point", + "16-bit integer" +}; +static const true_false_string conf_formatb0names = { + "polar", + "rectangular" +}; + +/* strings to decode ANUNIT in configuration frame */ +static const range_string conf_anconvnames[] = { + { 0, 0, "single point-on-wave" }, + { 1, 1, "rms of analog input" }, + { 2, 2, "peak of input" }, + { 3, 4, "undefined" }, + { 5, 64, "reserved" }, + { 65, 255, "user defined" }, + { 0, 0, NULL } +}; + +/* strings for the FNOM field */ +static const true_false_string conf_fnomnames = { + "50Hz", + "60Hz" +}; + +static const true_false_string conf_phasor_mod_b15 = { + "Modification applied, type not here defined", + "None" +}; + +static const true_false_string conf_phasor_mod_b10 = { + "Pseudo-phasor value (combined from other phasors)", + "None" +}; + +static const true_false_string conf_phasor_mod_b09 = { + "Phasor phase adjusted for rotation", + "None" +}; + +static const true_false_string conf_phasor_mod_b08 = { + "Phasor phase adjusted for calibration", + "None" +}; + +static const true_false_string conf_phasor_mod_b07 = { + "Phasor magnitude adjusted for calibration", + "None" +}; + +static const true_false_string conf_phasor_mod_b06 = { + "Filtered without changing sampling", + "None" +}; + +static const true_false_string conf_phasor_mod_b05 = { + "Down sampled with non-FIR filter", + "None" +}; + +static const true_false_string conf_phasor_mod_b04 = { + "Down sampled with FIR filter", + "None" +}; + +static const true_false_string conf_phasor_mod_b03 = { + "Down sampled by reselection", + "None" +}; + +static const true_false_string conf_phasor_mod_b02 = { + "Up sampled with extrapolation", + "None" +}; + +static const true_false_string conf_phasor_mod_b01 = { + "Up sampled with interpolation", + "None" +}; + +static const value_string conf_phasor_type[] = { + { 0, "Voltage, Zero sequence" }, + { 1, "Voltage, Positive sequence" }, + { 2, "Voltage, Negative sequence" }, + { 3, "Voltage, Reserved" }, + { 4, "Voltage, Phase A" }, + { 5, "Voltage, Phase B" }, + { 6, "Voltage, Phase C" }, + { 7, "Voltage, Reserved" }, + { 8, "Current, Zero sequence" }, + { 9, "Current, Positive sequence" }, + { 10, "Current, Negative sequence" }, + { 11, "Current, Reserved" }, + { 12, "Current, Phase A" }, + { 13, "Current, Phase B" }, + { 14, "Current, Phase C" }, + { 15, "Current, Reserved" }, + { 0, NULL } +}; + +static const true_false_string conf_phasor_type_b03 = { + "Current", + "Voltage" +}; + +static const value_string conf_phasor_type_b02to00[] = { + { 0, "Zero sequence" }, + { 1, "Positive sequence"}, + { 2, "Negative sequence"}, + { 3, "Reserved" }, + { 4, "Phase A" }, + { 5, "Phase B" }, + { 6, "Phase C" }, + { 7, "Reserved" }, + { 0, NULL } +}; + +static const true_false_string conf_phasor_user_defined = { + "Flags set", + "No flags set" +}; + +/* strings for flags in the STAT word of a data frame */ +static const value_string data_statb15to14names[] = { + { 0, "Good measurement data, no errors" }, + { 1, "PMU error, no information about data" }, + { 2, "PMU in test mode or absent data tags have been inserted (do not use values)" }, + { 3, "PMU error (do not use values)" }, + { 0, NULL } +}; +static const true_false_string data_statb13names = { + "Synchronization lost", + "Clock is synchronized" +}; +static const true_false_string data_statb12names = { + "By arrival", + "By timestamp" +}; +static const true_false_string data_statb11names = { + "Trigger detected", + "No trigger" +}; +static const true_false_string data_statb10names = { + "Within 1 minute", + "No" +}; +static const true_false_string data_statb09names = { + "Data modified by a post-processing device", + "Data not modified" +}; +static const value_string data_statb08to06names[] = { + { 0, "Not used (indicates code from previous version of profile)" }, + { 1, "Estimated maximum time error < 100 ns" }, + { 2, "Estimated maximum time error < 1 " UTF8_MICRO_SIGN "s" }, + { 3, "Estimated maximum time error < 10 " UTF8_MICRO_SIGN "s" }, + { 4, "Estimated maximum time error < 100 " UTF8_MICRO_SIGN "s" }, + { 5, "Estimated maximum time error < 1 ms" }, + { 6, "Estimated maximum time error < 10 ms" }, + { 7, "Estimated maximum time error > 10 ms or time error unknown" }, + { 0, NULL } +}; +static const value_string data_statb05to04names[] = { + { 0, "Locked or unlocked less than 10 s"}, + { 1, "Unlocked for 10-100 s" }, + { 2, "Unlocked for 100-1000 s" }, + { 3, "Unlocked for over 1000 s" }, + { 0, NULL } +}; +static const value_string data_statb03to00names[] = { + { 0x0, "Manual" }, + { 0x1, "Magnitude low" }, + { 0x2, "Magnitude high" }, + { 0x3, "Phase-angel diff" }, + { 0x4, "Frequency high or low" }, + { 0x5, "df/dt high" }, + { 0x6, "Reserved" }, + { 0x7, "Digital" }, + { 0x8, "User defined" }, + { 0x9, "User defined" }, + { 0xA, "User defined" }, + { 0xB, "User defined" }, + { 0xC, "User defined" }, + { 0xD, "User defined" }, + { 0xE, "User defined" }, + { 0xF, "User defined" }, + { 0, NULL } +}; + +/* strings to decode the commands (CMD Field) acording Table 15, p.26 +* 0000 0000 0000 0001 - Turn off transmission of data frames +* 0000 0000 0000 0010 - Turn on transmission of data frames +* 0000 0000 0000 0011 - Send HDR frame +* 0000 0000 0000 0100 - Send CFG-1 frame. +* 0000 0000 0000 0101 - Send CFG-2 frame. +* 0000 0000 0000 0110 - Send CFG-3 frame (optional command). +* 0000 0000 0000 1000 - Extended frame. +* 0000 0000 xxxx xxxx - All undesignated codes reserved. +* 0000 yyyy xxxx xxxx - All codes where yyyy ≠ 0 available for user designation. +* zzzz xxxx xxxx xxxx - All codes where zzzz ≠ 0 reserved. +*/ +static const range_string command_names[] = { + { 0x0000, 0x0000, "reserved codes" }, + { 0x0001, 0x0001, "data transmission off" }, + { 0x0002, 0x0002, "data transmission on" }, + { 0x0003, 0x0003, "send HDR frame" }, + { 0x0004, 0x0004, "send CFG-1 frame" }, + { 0x0005, 0x0005, "send CFG-2 frame" }, + { 0x0006, 0x0006, "send CFG-3 frame" }, + { 0x0007, 0x0007, "reserved codes" }, + { 0x0008, 0x0008, "extended frame" }, + { 0x0009, 0x00FF, "reserved codes" }, + { 0x0100, 0x0FFF, "user designation" }, + { 0x1000, 0xFFFF, "reserved codes" }, + { 0x0000, 0x0000, NULL } +}; + + +/****************************************************************************** +* functions +******************************************************************************/ + +/* read in the size length for names found in config 3 frames + 0 - no name + 1-255 - length of name +*/ +static guint8 get_name_length(tvbuff_t *tvb, gint offset) +{ + guint8 name_length; + + /* read the size of the name */ + name_length = tvb_get_guint8(tvb, offset); + + return name_length; +} + +/* Checks the CRC of a synchrophasor frame, 'tvb' has to include the whole + * frame, including CRC, the calculated CRC is returned in '*computedcrc'. + */ +static gboolean check_crc(tvbuff_t *tvb, guint16 *computedcrc) +{ + guint16 crc; + guint len = tvb_get_ntohs(tvb, 2); + + crc = tvb_get_ntohs(tvb, len - 2); + *computedcrc = crc16_x25_ccitt_tvb(tvb, len - 2); + + if (crc == *computedcrc) + return TRUE; + + return FALSE; +} + +/* Dissects a configuration frame (only the most important stuff, tries + * to be fast, does no GUI stuff) and returns a pointer to a config_frame + * struct that contains all the information from the frame needed to + * dissect a DATA frame. + * + * use 'config_frame_free()' to free the config_frame again + */ +static config_frame *config_frame_fast(tvbuff_t *tvb) +{ + guint16 num_pmu; + gint offset; + config_frame *frame; + + /* get a new frame and initialize it */ + frame = wmem_new(wmem_file_scope(), config_frame); + + frame->config_blocks = wmem_array_new(wmem_file_scope(), sizeof(config_block)); + + // Start with Stream Source ID - identifies source of stream + offset = 4; + frame->id = tvb_get_ntohs(tvb, offset); + + /* Skip to time base for FRACSEC */ + offset += 11; // high 8 bits reserved for flags, so +1 byte + frame->time_base = tvb_get_guint24(tvb, offset,ENC_BIG_ENDIAN); + + /* Next number of PMU blocks */ + offset += 3; + num_pmu = tvb_get_ntohs(tvb, offset); + + // Start of repeating blocks + offset += 2; + + while (num_pmu) { + guint16 format_flags; + gint num_ph, + num_an, + num_dg; + gint i, + phunit, + anunit, + fnom; + config_block block; + + /* initialize the block */ + block.phasors = wmem_array_new(wmem_file_scope(), sizeof(phasor_info)); + block.analogs = wmem_array_new(wmem_file_scope(), sizeof(analog_info)); + /* copy the station name from the tvb to block, and add NULL byte */ + tvb_memcpy(tvb, block.name, offset, CHNAM_LEN); offset += CHNAM_LEN; + block.name[CHNAM_LEN] = '\0'; + block.cfg_frame_type = 2; + block.id = tvb_get_ntohs(tvb, offset); offset += 2; + + format_flags = tvb_get_ntohs(tvb, offset); offset += 2; + block.format_fr = (format_flags & 0x0008) ? floating_point : integer; + block.format_an = (format_flags & 0x0004) ? floating_point : integer; + block.format_ph = (format_flags & 0x0002) ? floating_point : integer; + block.phasor_notation = (format_flags & 0x0001) ? polar : rect; + + num_ph = tvb_get_ntohs(tvb, offset); offset += 2; + num_an = tvb_get_ntohs(tvb, offset); offset += 2; + num_dg = tvb_get_ntohs(tvb, offset); offset += 2; + block.num_dg = num_dg; + + /* the offset of the PHUNIT, ANUNIT, and FNOM blocks */ + phunit = offset + (num_ph + num_an + num_dg * CHNAM_LEN) * CHNAM_LEN; + anunit = phunit + num_ph * 4; + fnom = anunit + num_an * 4 + num_dg * 4; + + /* read num_ph phasor names and conversion factors */ + for (i = 0; i != num_ph; i++) { + phasor_info pi; + guint32 conv; + + /* copy the phasor name from the tvb, and add NULL byte */ + tvb_memcpy(tvb, pi.name, offset, CHNAM_LEN); offset += CHNAM_LEN; + pi.name[CHNAM_LEN] = '\0'; + + conv = tvb_get_ntohl(tvb, phunit + 4 * i); + pi.unit = conv & 0xFF000000 ? A : V; + pi.conv = conv & 0x00FFFFFF; + pi.conv_cfg3 = 1; + pi.angle_offset_cfg3 = 0; + + wmem_array_append_one(block.phasors, pi); + } + + /* read num_an analog value names and conversion factors */ + for (i = 0; i != num_an; i++) { + analog_info ai; + guint32 conv; + + /* copy the phasor name from the tvb, and add NULL byte */ + tvb_memcpy(tvb, ai.name, offset, CHNAM_LEN); offset += CHNAM_LEN; + ai.name[CHNAM_LEN] = '\0'; + + conv = tvb_get_ntohl(tvb, anunit + 4 * i); + ai.conv = conv; + ai.conv_cfg3 = 1; + ai.offset_cfg3 = 0; + + wmem_array_append_one(block.analogs, ai); + } + + /* the names for the bits in the digital status words aren't saved, + there is no space to display them in the GUI anyway */ + + /* save FNOM */ + block.fnom = tvb_get_ntohs(tvb, fnom) & 0x0001 ? 50 : 60; + offset = fnom + 2; + + /* skip CFGCNT */ + offset += 2; + + wmem_array_append_one(frame->config_blocks, block); + num_pmu--; + } + + return frame; +} /* config_frame_fast() */ + +/* Dissects a configuration 3 frame (only the most important stuff, tries + * to be fast, does no GUI stuff) and returns a pointer to a config_frame + * struct that contains all the information from the frame needed to + * dissect a DATA frame. + * + * use 'config_frame_free()' to free the config_frame again + */ +static config_frame * config_3_frame_fast(tvbuff_t *tvb) +{ + guint16 num_pmu; + gint offset; + config_frame *frame; + phasor_info *pi = NULL; + analog_info *ai = NULL; + gboolean frame_not_fragmented; + + /* get a new frame and initialize it */ + frame = wmem_new(wmem_file_scope(), config_frame); + + frame->config_blocks = wmem_array_new(wmem_file_scope(), sizeof(config_block)); + + // Start with Stream Source ID - identifies source of stream + offset = 4; + frame->id = tvb_get_ntohs(tvb, offset); + + /* Skip to CONT_IDX -- Fragmented Frames not supported at this time */ + offset += 10; + frame_not_fragmented = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN) == 0; + + /* Skip to time base for FRACSEC */ + offset += 3; // high 8 bits reserved for flags, so +1 byte + frame->time_base = tvb_get_guint24(tvb, offset,ENC_BIG_ENDIAN); + + /* Skip to number of PMU blocks */ + offset += 3; + num_pmu = tvb_get_ntohs(tvb, offset); + + /* start of repeating blocks */ + offset += 2; + while ((num_pmu) && (frame_not_fragmented)) { + guint16 format_flags; + gint num_ph, + num_an, + num_dg; + gint i; + guint8 name_length; + config_block block; + + /* initialize the block */ + block.phasors = wmem_array_new(wmem_file_scope(), sizeof(phasor_info)); + block.analogs = wmem_array_new(wmem_file_scope(), sizeof(analog_info)); + + /* copy the station name from the tvb to block, and add NULL byte */ + /* first byte is name size */ + name_length = get_name_length(tvb, offset); + offset += 1; + + tvb_memcpy(tvb, block.name, offset, name_length); + offset += name_length; + + block.name[name_length] = '\0'; + block.cfg_frame_type = 3; + + /* Block ID and Global PMU ID */ + block.id = tvb_get_ntohs(tvb, offset); + offset += 2; + + /* skip over Global PMU ID */ + offset += G_PMU_ID_LEN; + + format_flags = tvb_get_ntohs(tvb, offset); + offset += 2; + + block.format_fr = (format_flags & 0x0008) ? floating_point : integer; + block.format_an = (format_flags & 0x0004) ? floating_point : integer; + block.format_ph = (format_flags & 0x0002) ? floating_point : integer; + block.phasor_notation = (format_flags & 0x0001) ? polar : rect; + + num_ph = tvb_get_ntohs(tvb, offset); + offset += 2; + + num_an = tvb_get_ntohs(tvb, offset); + offset += 2; + + num_dg = tvb_get_ntohs(tvb, offset); + offset += 2; + block.num_dg = num_dg; + + /* grab phasor names */ + if (num_ph > 0) + { + pi = (phasor_info *)wmem_alloc(wmem_file_scope(), sizeof(phasor_info)*num_ph); + + for (i = 0; i != num_ph; i++) { + /* copy the phasor name from the tvb, and add NULL byte */ + name_length = get_name_length(tvb, offset); + offset += 1; + + tvb_memcpy(tvb, pi[i].name, offset, name_length); + offset += name_length; + + pi[i].name[name_length] = '\0'; + } + } + + /* grab analog names */ + if (num_an > 0) + { + ai = (analog_info *)wmem_alloc(wmem_file_scope(), sizeof(analog_info)*num_an); + + for (i = 0; i != num_an; i++) { + /* copy the phasor name from the tvb, and add NULL byte */ + name_length = get_name_length(tvb, offset); + offset += 1; + + tvb_memcpy(tvb, ai[i].name, offset, name_length); + offset += name_length; + + ai[i].name[name_length] = '\0'; + } + } + + /* skip digital names */ + if (num_dg > 0) + { + for (i = 0; i != num_dg * 16; i++) { + name_length = get_name_length(tvb, offset); + offset += name_length + 1; + } + } + + /* get phasor conversion factors */ + if (num_ph > 0) + { + for (i = 0; i != num_ph; i++) { + guint32 phasor_unit; + + /* get unit */ + phasor_unit = tvb_get_ntohl(tvb, offset); + pi[i].unit = phasor_unit & 0x00000800 ? A : V; + pi[i].conv = 1; + pi[i].conv_cfg3 = tvb_get_ntohieee_float(tvb, offset + 4); + pi[i].angle_offset_cfg3 = tvb_get_ntohieee_float(tvb, offset + 8); + + wmem_array_append_one(block.phasors, pi[i]); + + offset += 12; + } + } + + /* get analog conversion factors */ + if (num_an > 0) + { + for (i = 0; i != num_an; i++) { + ai[i].conv = 1; + ai[i].conv_cfg3 = tvb_get_ntohieee_float(tvb, offset); + ai[i].offset_cfg3 = tvb_get_ntohieee_float(tvb, offset + 4); + + wmem_array_append_one(block.analogs, ai[i]); + + offset += 8; + } + } + + /* skip digital masks */ + if (num_dg > 0) + { + for (i = 0; i != num_dg; i++) { + offset += 4; + } + } + + /* Skip to FNOM */ + offset += 21; + + /* save FNOM */ + block.fnom = tvb_get_ntohs(tvb, offset) & 0x0001 ? 50 : 60; + offset += 2; + + /* skip CFGCNT - offset ready for next PMU */ + offset += 2; + + wmem_array_append_one(frame->config_blocks, block); + num_pmu--; + } + + return frame; +} /* config_3_frame_fast() */ + +/* Dissects the common header of frames. + * + * Returns the framesize, in contrast to most + * other helper functions that return the offset. + */ +static gint dissect_header(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo) +{ + proto_tree *temp_tree; + proto_item *temp_item; + config_frame *conf; + + gint offset = 0; + guint16 framesize; + + conf = (config_frame *)p_get_proto_data(wmem_file_scope(), pinfo, proto_synphasor, 0); + + /* SYNC and flags */ + temp_item = proto_tree_add_item(tree, hf_sync, tvb, offset, 2, ENC_BIG_ENDIAN); + temp_tree = proto_item_add_subtree(temp_item, ett_frtype); + proto_tree_add_item(temp_tree, hf_sync_frtype, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_sync_version, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* FRAMESIZE */ + proto_tree_add_item(tree, hf_frsize, tvb, offset, 2, ENC_BIG_ENDIAN); + framesize = tvb_get_ntohs(tvb, offset); offset += 2; + + /* IDCODE */ + proto_tree_add_item(tree, hf_idcode_stream_source, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* SOC */ + proto_tree_add_item(tree, hf_soc, tvb, offset, 4, ENC_TIME_SECS | ENC_BIG_ENDIAN); + offset += 4; + + /* FRACSEC */ + /* time quality flags */ + temp_tree = proto_tree_add_subtree(tree, tvb, offset, 1, ett_timequal, NULL, "Time quality flags"); + proto_tree_add_item(temp_tree, hf_timeqal_lsdir, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_timeqal_lsocc, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_timeqal_lspend, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_timeqal_timequalindic, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + // Add RAW FRACSEC + proto_tree_add_item(tree, hf_fracsec_raw, tvb, offset, 3, ENC_BIG_ENDIAN); + + // If exist configuration frame, add fracsec in milliseconds + if (conf){ + guint32 fracsec_raw = tvb_get_guint24(tvb, offset, ENC_BIG_ENDIAN); + float fracsec_ms = 1000.0f*fracsec_raw/conf->time_base; + proto_tree_add_float(tree, hf_fracsec_ms, tvb, offset, 3, fracsec_ms); + } else + { + } + /*offset += 3;*/ + + return framesize; +} + +/* Dissects a single phasor for 'dissect_PHASORS()' */ +static int dissect_single_phasor(tvbuff_t *tvb, int offset, + gdouble *mag, gdouble *phase, /* returns the resulting values in polar format here */ + gdouble* real, gdouble* imag, /* returns the resulting values in rectangular format here*/ + gdouble* mag_real_unscaled, gdouble* phase_imag_unscaled, /* returns unscaled values*/ + config_block *block, /* information needed to... */ + phasor_info* pi) /* ...dissect the phasor */ +{ + if (floating_point == block->format_ph) { + if (polar == block->phasor_notation) { + /* float, polar */ + *mag = tvb_get_ntohieee_float(tvb, offset ); + *phase = tvb_get_ntohieee_float(tvb, offset + 4); + + *real = (*mag) * cos(*phase); + *imag = (*mag) * sin(*phase); + } + else { + /* float, rect */ + *real = tvb_get_ntohieee_float(tvb, offset ); + *imag = tvb_get_ntohieee_float(tvb, offset + 4); + + *mag = sqrt(pow(*real, 2) + pow(*imag, 2)); + *phase = atan2(*imag, *real); + } + } + else { + if (polar == block->phasor_notation) { + /* int, polar */ + *mag_real_unscaled = tvb_get_ntohs(tvb, offset ); + *phase_imag_unscaled = tvb_get_ntohis(tvb, offset + 2); + + /* For fixed-point data in polar format all values are permissible for the magnitude + field. However, the angle field is restricted to ±31416. A value of 0x8000 (–32768) used in the angle field + will be used to signify absent data. + bullet 6.3.1 page 16 IEEE Std C37.118.2-2011 + */ + if (*phase_imag_unscaled == -32768) { + *phase_imag_unscaled = NAN; + *mag_real_unscaled = NAN; + } + + *phase = *phase_imag_unscaled/10000.0; /* angle is in radians*10^4 */ + + /* for values in integer format, consider conversation factor */ + if (block->cfg_frame_type == 3){ + *mag = (*mag_real_unscaled * pi->conv_cfg3); + *phase = *phase - pi->angle_offset_cfg3; + } + else{ + *mag = (*mag_real_unscaled * pi->conv) * 0.00001; + } + + *real = (*mag) * cos(*phase); + *imag = (*mag) * sin(*phase); + } + else { + /* int, rect */ + *mag_real_unscaled = tvb_get_ntohis(tvb, offset ); + *phase_imag_unscaled = tvb_get_ntohis(tvb, offset + 2); + + /* For fixed-point data in rectangular format the PDC will use + 0x8000 (–32768) as the substitute for the absent data. + bullet 6.3.1 page 16 IEEE Std C37.118.2-2011 + */ + if (*mag_real_unscaled == -32768) { + *mag_real_unscaled = NAN; + } + if (*phase_imag_unscaled == -32768) { + *phase_imag_unscaled = NAN; + } + + *mag = sqrt(pow(*mag_real_unscaled, 2) + pow(*phase_imag_unscaled, 2)); + *phase = atan2(*phase_imag_unscaled, *mag_real_unscaled); + + /* for values in integer format, consider conversation factor */ + if (block->cfg_frame_type == 3) { + *mag = (*mag * pi->conv_cfg3); + *phase = *phase - pi->angle_offset_cfg3; + } + else { + *mag = (*mag * pi->conv) * 0.00001; + } + + *real = (*mag) * cos(*phase); + *imag = (*mag) * sin(*phase); + } + } + + return floating_point == block->format_ph ? 8 : 4; +} + +/* used by 'dissect_data_frame()' to dissect the PHASORS field */ +static gint dissect_PHASORS(tvbuff_t *tvb, proto_tree *tree, config_block *block, gint offset) +{ + proto_tree *phasor_tree; + guint length; + gint j; + gint cnt = wmem_array_get_count(block->phasors); /* number of phasors to dissect */ + + if (0 == cnt) + return offset; + + length = wmem_array_get_count(block->phasors) * (floating_point == block->format_ph ? 8 : 4); + phasor_tree = proto_tree_add_subtree_format(tree, tvb, offset, length, ett_data_phasors, NULL, + "Phasors (%u), notation: %s, format: %s", cnt, + block->phasor_notation ? "polar" : "rectangular", + block->format_ph ? "floating point" : "integer"); + + /* dissect a phasor for every phasor_info saved in the config_block */ + for (j = 0; j < cnt; j++) { + proto_item *temp_item; + gdouble mag, phase,real, imag; + gdouble mag_real_unscaled = NAN, phase_imag_unscaled = NAN; + phasor_info *pi; + + pi = (phasor_info *)wmem_array_index(block->phasors, j); + temp_item = proto_tree_add_string_format(phasor_tree, hf_synphasor_phasor, tvb, offset, + floating_point == block->format_ph ? 8 : 4, pi->name, + "Phasor #%u: \"%s\"", j + 1, pi->name); + + offset += dissect_single_phasor(tvb, offset, + &mag, &phase, &real, &imag, + &mag_real_unscaled, &phase_imag_unscaled, + block,pi); + + #define SYNP_ANGLE "\xe2\x88\xa0" /* 8736 / 0x2220 */ + + char phasor_unit = V == pi->unit ? 'V' : 'A'; + + proto_item_append_text(temp_item, ", %10.3F%c " SYNP_ANGLE "%7.3F" UTF8_DEGREE_SIGN " alt %7.3F+j%7.3F%c", + mag, phasor_unit, phase * 180.0 / G_PI, + real, imag, phasor_unit); + if (integer == block->format_ph) { + proto_item_append_text(temp_item, "; unscaled: %5.0F, %5.0F", + mag_real_unscaled, phase_imag_unscaled); + } + #undef SYNP_ANGLE + } + return offset; +} + +/* used by 'dissect_data_frame()' to dissect the FREQ and DFREQ fields */ +static gint dissect_DFREQ(tvbuff_t *tvb, proto_tree *tree, config_block *block, gint offset) +{ + if (floating_point == block->format_fr) { + proto_tree_add_item(tree, hf_synphasor_actual_frequency_value, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + /* In new version of the standard IEEE Std C37.118.2-2011: "Can be 16-bit integer or IEEE floating point, same as FREQ above." + * --> no scaling factor is applied to DFREQ + */ + proto_tree_add_item(tree, hf_synphasor_rate_change_frequency, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + } + else { + gint16 tmp; + + tmp = tvb_get_ntohs(tvb, offset); + proto_tree_add_int_format_value(tree, hf_synphasor_frequency_deviation_from_nominal, tvb, offset, 2, tmp, + "%dmHz (actual frequency: %.3fHz)", tmp, block->fnom + (tmp / 1000.0)); + offset += 2; + + tmp = tvb_get_ntohs(tvb, offset); + proto_tree_add_float_format_value(tree, hf_synphasor_rate_change_frequency, tvb, offset, 2, (gfloat)(tmp / 100.0), "%.3fHz/s", tmp / 100.0); offset += 2; + } + return offset; +} + +/* used by 'dissect_data_frame()' to dissect the ANALOG field */ +static gint dissect_ANALOG(tvbuff_t *tvb, proto_tree *tree, config_block *block, gint offset) +{ + proto_tree *analog_tree; + guint length; + gint j; + gint cnt = wmem_array_get_count(block->analogs); /* number of analog values to dissect */ + + if (0 == cnt) + return offset; + + length = wmem_array_get_count(block->analogs) * (floating_point == block->format_an ? 4 : 2); + analog_tree = proto_tree_add_subtree_format(tree, tvb, offset, length, ett_data_analog, NULL, + "Analog values (%u)", cnt); + + for (j = 0; j < cnt; j++) { + proto_item *temp_item; + analog_info *ai = (analog_info *)wmem_array_index(block->analogs, j); + + temp_item = proto_tree_add_string_format(analog_tree, hf_synphasor_analog_value, tvb, offset, + floating_point == block->format_an ? 4 : 2, ai->name, + "Analog value #%u: \"%s\"", j + 1, ai->name); + + if (block->cfg_frame_type == 3) + { + if (floating_point == block->format_an) { + gfloat tmp; + + tmp = tvb_get_ntohieee_float(tvb, offset); + offset += 4; + + proto_item_append_text(temp_item, ", %.3f", tmp); + } + else { + /* the "standard" doesn't say if this is signed or unsigned, + * so I just use gint16 */ + gint16 tmp_i; + gfloat tmp_f; + + tmp_i = tvb_get_ntohs(tvb, offset); + offset += 2; + + tmp_f = (tmp_i * ai->conv_cfg3) + ai->offset_cfg3; + + proto_item_append_text(temp_item, ", %.3f", tmp_f); + } + } + else + { + if (floating_point == block->format_an) { + gfloat tmp = tvb_get_ntohieee_float(tvb, offset); offset += 4; + proto_item_append_text(temp_item, ", %.3f", tmp); + } + else { + /* the "standard" doesn't say if this is signed or unsigned, + * so I just use gint16; the scaling of the conversion factor + * is also "user defined", so I just write it after the analog value */ + gint16 tmp = tvb_get_ntohs(tvb, offset); offset += 2; + proto_item_append_text(temp_item, ", %" PRId16 " (conversion factor: %#06x)", + tmp, ai->conv); + } + } + } + return offset; +} + +/* used by 'dissect_data_frame()' to dissect the DIGITAL field */ +static gint dissect_DIGITAL(tvbuff_t *tvb, proto_tree *tree, config_block *block, gint offset) +{ + gint j; + gint cnt = block->num_dg; /* number of digital status words to dissect */ + + if (0 == cnt) + return offset; + + tree = proto_tree_add_subtree_format(tree, tvb, offset, cnt * 2, ett_data_digital, NULL, + "Digital status words (%u)", cnt); + + for (j = 0; j < cnt; j++) { + guint16 tmp = tvb_get_ntohs(tvb, offset); + proto_tree_add_uint_format(tree, hf_synphasor_digital_status_word, tvb, offset, 2, tmp, "Digital status word #%u: 0x%04x", j + 1, tmp); + offset += 2; + } + return offset; +} + +/* used by 'dissect_config_frame()' to dissect the PHUNIT field */ +static gint dissect_PHUNIT(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt) +{ + proto_tree *temp_tree; + gint i; + + if (0 == cnt) + return offset; + + temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 * cnt, ett_conf_phconv, NULL, + "Phasor conversion factors (%u)", cnt); + + /* Conversion factor for phasor channels. Four bytes for each phasor. + * MSB: 0 = voltage, 1 = current + * Lower 3 Bytes: unsigned 24-bit word in 10^-5 V or A per bit to scale the phasor value + */ + for (i = 0; i < cnt; i++) { + guint32 tmp = tvb_get_ntohl(tvb, offset); + proto_tree_add_uint_format(temp_tree, hf_synphasor_conversion_factor, tvb, offset, 4, + tmp, "#%u factor: %u * 10^-5, unit: %s", + i + 1, + tmp & 0x00FFFFFF, + tmp & 0xFF000000 ? "Ampere" : "Volt"); + offset += 4; + } + + return offset; +} + +/* used by 'dissect_config_3_frame()' to dissect the PHSCALE field */ +static gint dissect_PHSCALE(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt) +{ + proto_tree *temp_tree; + gint i; + + if (0 == cnt) { + return offset; + } + + temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, 12 * cnt, ett_conf_phconv, NULL, + "Phasor scaling and data flags (%u)", cnt); + + for (i = 0; i < cnt; i++) { + proto_tree *single_phasor_scaling_and_flags_tree; + proto_tree *phasor_flag1_tree; + proto_tree *phasor_flag2_tree; + proto_tree *data_flag_tree; + + single_phasor_scaling_and_flags_tree = proto_tree_add_subtree_format(temp_tree, tvb, offset, 12, + ett_conf_phlist, NULL, + "Phasor #%u", i + 1); + + data_flag_tree = proto_tree_add_subtree_format(single_phasor_scaling_and_flags_tree, tvb, offset, 4, + ett_conf_phflags, NULL, "Phasor Data flags: %s", + val_to_str_const(tvb_get_guint8(tvb, offset + 2), conf_phasor_type, "Unknown")); + + /* first and second bytes - phasor modification flags*/ + phasor_flag1_tree = proto_tree_add_subtree_format(data_flag_tree, tvb, offset, 2, ett_conf_phmod_flags, + NULL, "Modification Flags: 0x%04x", + tvb_get_ntohs(tvb, offset)); + + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b15, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b10, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b09, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b08, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b07, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b06, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b05, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b04, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b03, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b02, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(phasor_flag1_tree, hf_conf_phasor_mod_b01, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* third byte - phasor type*/ + proto_tree_add_item(data_flag_tree, hf_conf_phasor_type_b03, tvb, offset, 1, ENC_BIG_ENDIAN); + proto_tree_add_item(data_flag_tree, hf_conf_phasor_type_b02to00, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* fourth byte - user designation*/ + phasor_flag2_tree = proto_tree_add_subtree_format(data_flag_tree, tvb, offset, 1, ett_conf_ph_user_flags, + NULL, "User designated flags: 0x%02x", + tvb_get_guint8(tvb, offset)); + + proto_tree_add_item(phasor_flag2_tree, hf_conf_phasor_user_data, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* phasor scalefactor */ + proto_tree_add_item(single_phasor_scaling_and_flags_tree, hf_conf_phasor_scale_factor, + tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + /* angle adjustment */ + proto_tree_add_item(single_phasor_scaling_and_flags_tree, hf_conf_phasor_angle_offset, + tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + } + + return offset; +} + +/* used by 'dissect_config_frame()' to dissect the ANUNIT field */ +static gint dissect_ANUNIT(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt) +{ + proto_item *temp_item; + proto_tree *temp_tree; + gint i; + + if (0 == cnt) + return offset; + + temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 * cnt, ett_conf_anconv, NULL, + "Analog values conversion factors (%u)", cnt); + + /* Conversion factor for analog channels. Four bytes for each analog value. + * MSB: see 'synphasor_conf_anconvnames' in 'synphasor_strings.c' + * Lower 3 Bytes: signed 24-bit word, user-defined scaling + */ + for (i = 0; i < cnt; i++) { + gint32 tmp = tvb_get_ntohl(tvb, offset); + temp_item = proto_tree_add_uint_format(temp_tree, hf_synphasor_factor_for_analog_value, tvb, offset, 4, + tmp, "Factor for analog value #%i: %s", + i + 1, + try_rval_to_str((tmp >> 24) & 0x000000FF, conf_anconvnames)); + + tmp &= 0x00FFFFFF; + if ( tmp & 0x00800000) /* sign bit set */ + tmp |= 0xFF000000; + + proto_item_append_text(temp_item, ", value: %" PRId32, tmp); + + offset += 4; + } + + return offset; +} + +/* used by 'dissect_config_3_frame()' to dissect the ANSCALE field */ +static gint dissect_ANSCALE(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt) +{ + proto_tree *temp_tree; + gint i; + + if (0 == cnt) { + return offset; + } + + temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, 8 * cnt, ett_conf_anconv, NULL, + "Analog values conversion factors (%u)", cnt); + + /* Conversion factor for analog channels. Four bytes for each analog value. + * MSB: see 'synphasor_conf_anconvnames' in 'synphasor_strings.c' + * Lower 3 Bytes: signed 24-bit word, user-defined scaling + */ + for (i = 0; i < cnt; i++) { + proto_tree *single_analog_scalefactor_tree; + + single_analog_scalefactor_tree = proto_tree_add_subtree_format(temp_tree, tvb, offset, 8, + ett_conf_phlist, NULL, + "Analog #%u", i + 1); + + /* analog scalefactor */ + proto_tree_add_item(single_analog_scalefactor_tree, hf_conf_analog_scale_factor, + tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + /* angle adjustment */ + proto_tree_add_item(single_analog_scalefactor_tree, hf_conf_analog_offset, + tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + } + + return offset; +} + +/* used by 'dissect_config_frame()' to dissect the DIGUNIT field */ +static gint dissect_DIGUNIT(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt) +{ + proto_tree *temp_tree, *mask_tree; + gint i; + + if (0 == cnt) + return offset; + + temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, 4 * cnt, ett_conf_dgmask, NULL, + "Masks for digital status words (%u)", cnt); + + /* Mask words for digital status words. Two 16-bit words for each digital word. The first + * indicates the normal status of the inputs, the second indicated the valid bits in + * the status word + */ + for (i = 0; i < cnt; i++) { + + mask_tree = proto_tree_add_subtree_format(temp_tree, tvb, offset, 4, ett_status_word_mask, NULL, "Mask for status word #%u: ", i + 1); + proto_tree_add_item(mask_tree, hf_synphasor_status_word_mask_normal_state, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; + proto_tree_add_item(mask_tree, hf_synphasor_status_word_mask_valid_bits, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; + } + + return offset; +} + +/* used by 'dissect_config_frame()' to dissect the "channel name"-fields */ +static gint dissect_CHNAM(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt, const char *prefix) +{ + proto_tree *temp_tree; + gint i; + + if (0 == cnt) + return offset; + + temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, CHNAM_LEN * cnt, ett_conf_phnam, NULL, + "%ss (%u)", prefix, cnt); + + /* dissect the 'cnt' channel names */ + for (i = 0; i < cnt; i++) { + char *str; + str = (char *)tvb_get_string_enc(wmem_packet_scope(), tvb, offset, CHNAM_LEN, ENC_ASCII); + proto_tree_add_string_format(temp_tree, hf_synphasor_channel_name, tvb, offset, CHNAM_LEN, + str, "%s #%i: \"%s\"", prefix, i+1, str); + offset += CHNAM_LEN; + } + + return offset; +} + +/* used by 'dissect_config_3_frame()' to dissect the "channel name"-fields */ +static gint dissect_config_3_CHNAM(tvbuff_t *tvb, proto_tree *tree, gint offset, gint cnt, const char *prefix) +{ + proto_tree *temp_tree, *chnam_tree; + gint i; + guint8 name_length; + gint temp_offset; + gint subsection_length = 0; + + if (0 == cnt) { + return offset; + } + + /* get the subsection length */ + temp_offset = offset; + for (i = 0; i < cnt; i++) { + name_length = get_name_length(tvb, temp_offset); + /* count the length byte and the actual name */ + subsection_length += name_length + 1; + temp_offset += name_length + 1; + } + + temp_tree = proto_tree_add_subtree_format(tree, tvb, offset, subsection_length, ett_conf_phnam, + NULL, "%ss (%u)", prefix, cnt); + + /* dissect the 'cnt' channel names */ + for (i = 0; i < cnt; i++) { + char *str; + + name_length = get_name_length(tvb, offset); + str = (char *)tvb_get_string_enc(wmem_packet_scope(), tvb, offset + 1, name_length, ENC_ASCII); + chnam_tree = proto_tree_add_subtree_format(temp_tree, tvb, offset, name_length + 1, ett_conf, + NULL, "%s #%i: \"%s\"", prefix, i + 1, str); + + proto_tree_add_item(chnam_tree, hf_conf_chnam_len, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + proto_tree_add_string(chnam_tree, hf_conf_chnam, tvb, offset, 1, str); + offset += name_length; + } + + return offset; +} + +/* dissects a configuration frame (type 1 and 2) and adds fields to 'config_item' */ +static int dissect_config_frame(tvbuff_t *tvb, proto_item *config_item) +{ + proto_tree *config_tree; + gint offset = 0; + guint16 num_pmu, j; + + proto_item_set_text (config_item, "Configuration data"); + config_tree = proto_item_add_subtree(config_item, ett_conf); + + /* TIME_BASE and NUM_PMU */ + offset += 1; /* skip the reserved byte */ + proto_tree_add_item(config_tree, hf_conf_timebase, tvb, offset, 3, ENC_BIG_ENDIAN); offset += 3; + proto_tree_add_item(config_tree, hf_conf_numpmu, tvb, offset, 2, ENC_BIG_ENDIAN); + /* add number of included PMUs to the text in the list view */ + num_pmu = tvb_get_ntohs(tvb, offset); offset += 2; + proto_item_append_text(config_item, ", %"PRIu16" PMU(s) included", num_pmu); + + /* dissect the repeating PMU blocks */ + for (j = 0; j < num_pmu; j++) { + guint16 num_ph, num_an, num_dg; + proto_item *station_item; + proto_tree *station_tree; + proto_tree *temp_tree; + char *str; + + gint oldoffset = offset; /* to calculate the length of the whole PMU block later */ + + /* STN with new tree to add the rest of the PMU block */ + str = (char *)tvb_get_string_enc(wmem_packet_scope(), tvb, offset, CHNAM_LEN, ENC_ASCII); + station_tree = proto_tree_add_subtree_format(config_tree, tvb, offset, CHNAM_LEN, + ett_conf_station, &station_item, + "Station #%i: \"%s\"", j + 1, str); + offset += CHNAM_LEN; + + /* IDCODE */ + proto_tree_add_item(station_tree, hf_idcode_data_source, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; + + /* FORMAT */ + temp_tree = proto_tree_add_subtree(station_tree, tvb, offset, 2, ett_conf_format, NULL, + "Data format in data frame"); + proto_tree_add_item(temp_tree, hf_conf_formatb3, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_conf_formatb2, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_conf_formatb1, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_conf_formatb0, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* PHNMR, ANNMR, DGNMR */ + num_ph = tvb_get_ntohs(tvb, offset ); + num_an = tvb_get_ntohs(tvb, offset + 2); + num_dg = tvb_get_ntohs(tvb, offset + 4); + proto_tree_add_uint(station_tree, hf_synphasor_num_phasors, tvb, offset, 2, num_ph); + proto_tree_add_uint(station_tree, hf_synphasor_num_analog_values, tvb, offset + 2, 2, num_an); + proto_tree_add_uint(station_tree, hf_synphasor_num_digital_status_words, tvb, offset + 4, 2, num_dg); + offset += 6; + + /* CHNAM, the channel names */ + offset = dissect_CHNAM(tvb, station_tree, offset, num_ph , "Phasor name" ); + offset = dissect_CHNAM(tvb, station_tree, offset, num_an , "Analog value" ); + offset = dissect_CHNAM(tvb, station_tree, offset, num_dg * 16, "Digital status label"); + + /* PHUNIT, ANUINT and DIGUNIT */ + offset = dissect_PHUNIT (tvb, station_tree, offset, num_ph); + offset = dissect_ANUNIT (tvb, station_tree, offset, num_an); + offset = dissect_DIGUNIT(tvb, station_tree, offset, num_dg); + + /* FNOM and CFGCNT */ + proto_tree_add_item(station_tree, hf_conf_fnom, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; + proto_tree_add_item(station_tree, hf_conf_cfgcnt, tvb, offset, 2, ENC_BIG_ENDIAN); offset += 2; + + /* set the correct length for the "Station :" item */ + proto_item_set_len(station_item, offset - oldoffset); + } /* for() PMU blocks */ + + /* DATA_RATE */ + { + gint16 tmp = tvb_get_ntohis(tvb, offset); + if (tmp > 0) + proto_tree_add_int_format_value(config_tree, hf_synphasor_rate_of_transmission, tvb, offset, 2, tmp, + "%d frame(s) per second", tmp); + else + proto_tree_add_int_format_value(config_tree, hf_synphasor_rate_of_transmission, tvb, offset, 2, tmp, + "1 frame per %d second(s)", (gint16)-tmp); + offset += 2; + } + + return offset; +} /* dissect_config_frame() */ + +/* dissects a configuration frame type 3 and adds fields to 'config_item' */ +static int dissect_config_3_frame(tvbuff_t *tvb, proto_item *config_item) +{ + proto_tree *config_tree, *wgs84_tree; + gint offset = 0; + guint16 num_pmu, j; + + proto_item_set_text(config_item, "Configuration data"); + config_tree = proto_item_add_subtree(config_item, ett_conf); + + /* CONT_IDX */ + proto_tree_add_item(config_tree, hf_cont_idx, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* TIME_BASE and NUM_PMU */ + offset += 1; /* skip the reserved byte */ + + proto_tree_add_item(config_tree, hf_conf_timebase, tvb, offset, 3, ENC_BIG_ENDIAN); + offset += 3; + + proto_tree_add_item(config_tree, hf_conf_numpmu, tvb, offset, 2, ENC_BIG_ENDIAN); + + /* add number of included PMUs to the text in the list view */ + num_pmu = tvb_get_ntohs(tvb, offset); + offset += 2; + + proto_item_append_text(config_item, ", %"PRIu16" PMU(s) included", num_pmu); + + /* dissect the repeating PMU blocks */ + for (j = 0; j < num_pmu; j++) { + guint16 num_ph, num_an, num_dg, i; + guint8 name_length; + gint oldoffset; + gfloat pmu_lat, pmu_long, pmu_elev; + proto_item *station_item; + proto_tree *station_tree; + proto_tree *temp_tree; + char *str, *service_class; + char *unspecified_location = "Unspecified Location"; + guint8 g_pmu_id_array[G_PMU_ID_LEN]; + + oldoffset = offset; /* to calculate the length of the whole PMU block later */ + + /* STN with new tree to add the rest of the PMU block */ + name_length = get_name_length(tvb, offset); + str = (char *)tvb_get_string_enc(wmem_packet_scope(), tvb, offset + 1, name_length, ENC_ASCII); + station_tree = proto_tree_add_subtree_format(config_tree, tvb, offset, name_length + 1, + ett_conf_station, &station_item, + "Station #%i: \"%s\"", j + 1, str); + + /* Station Name Length */ + proto_tree_add_item(station_tree, hf_station_name_len, tvb, offset, 1, ENC_BIG_ENDIAN); + offset += 1; + + /* Station Name */ + proto_tree_add_string(station_tree, hf_station_name, tvb, offset, 1, str); + offset += name_length; + + /* IDCODE */ + proto_tree_add_item(station_tree, hf_idcode_data_source, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* G_PMU_ID */ + /* A 128 bit display as raw bytes */ + for (i = 0; i < G_PMU_ID_LEN; i++) { + g_pmu_id_array[i] = tvb_get_guint8(tvb, offset + i); + } + + proto_tree_add_bytes_format(station_tree, hf_g_pmu_id, tvb, offset, G_PMU_ID_LEN, 0, + "Global PMU ID (raw bytes): %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", + g_pmu_id_array[0], g_pmu_id_array[1], g_pmu_id_array[2], g_pmu_id_array[3], + g_pmu_id_array[4], g_pmu_id_array[5], g_pmu_id_array[6], g_pmu_id_array[7], + g_pmu_id_array[8], g_pmu_id_array[9], g_pmu_id_array[10], g_pmu_id_array[11], + g_pmu_id_array[12], g_pmu_id_array[13], g_pmu_id_array[14], g_pmu_id_array[15]); + offset += G_PMU_ID_LEN; + + /* FORMAT */ + temp_tree = proto_tree_add_subtree(station_tree, tvb, offset, 2, ett_conf_format, NULL, + "Data format in data frame"); + proto_tree_add_item(temp_tree, hf_conf_formatb3, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_conf_formatb2, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_conf_formatb1, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_conf_formatb0, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* PHNMR, ANNMR, DGNMR */ + num_ph = tvb_get_ntohs(tvb, offset ); + num_an = tvb_get_ntohs(tvb, offset + 2); + num_dg = tvb_get_ntohs(tvb, offset + 4); + proto_tree_add_uint(station_tree, hf_synphasor_num_phasors, tvb, offset, 2, num_ph); + proto_tree_add_uint(station_tree, hf_synphasor_num_analog_values, tvb, offset + 2, 2, num_an); + proto_tree_add_uint(station_tree, hf_synphasor_num_digital_status_words, tvb, offset + 4, 2, num_dg); + offset += 6; + + /* CHNAM, the channel names */ + offset = dissect_config_3_CHNAM(tvb, station_tree, offset, num_ph, "Phasor name"); + offset = dissect_config_3_CHNAM(tvb, station_tree, offset, num_an, "Analog value"); + offset = dissect_config_3_CHNAM(tvb, station_tree, offset, num_dg * 16, "Digital label"); + + /* PHUNIT, ANUINT and DIGUNIT */ + offset = dissect_PHSCALE(tvb, station_tree, offset, num_ph); + offset = dissect_ANSCALE(tvb, station_tree, offset, num_an); + + offset = dissect_DIGUNIT(tvb, station_tree, offset, num_dg); + + /* subtree for coordinate info*/ + wgs84_tree = proto_tree_add_subtree_format(station_tree, tvb, offset, 12, ett_conf_wgs84, NULL, + "World Geodetic System 84 data"); + + /* preview latitude, longitude, and elevation values */ + /* INFINITY is an unspecified location, otherwise use the actual float value */ + pmu_lat = tvb_get_ntohieee_float(tvb, offset); + pmu_long = tvb_get_ntohieee_float(tvb, offset + 4); + pmu_elev = tvb_get_ntohieee_float(tvb, offset + 8); + + /* PMU_LAT */ + if (isinf(pmu_lat)) { + proto_tree_add_float_format_value(wgs84_tree, hf_conf_pmu_lat_unknown, tvb, offset, + 4, INFINITY, "%s", unspecified_location); + } + else { + proto_tree_add_item(wgs84_tree, hf_conf_pmu_lat, tvb, offset, 4, ENC_BIG_ENDIAN); + } + offset += 4; + + /* PMU_LON */ + if (isinf(pmu_long)) { + proto_tree_add_float_format_value(wgs84_tree, hf_conf_pmu_lon_unknown, tvb, offset, + 4, INFINITY, "%s", unspecified_location); + } + else { + proto_tree_add_item(wgs84_tree, hf_conf_pmu_lon, tvb, offset, 4, ENC_BIG_ENDIAN); + } + offset += 4; + + /* PMU_ELEV */ + if (isinf(pmu_elev)) { + proto_tree_add_float_format_value(wgs84_tree, hf_conf_pmu_elev_unknown, tvb, offset, + 4, INFINITY, "%s", unspecified_location); + } + else { + proto_tree_add_item(wgs84_tree, hf_conf_pmu_elev, tvb, offset, 4, ENC_BIG_ENDIAN); + } + offset += 4; + + /* SVC_CLASS */ + service_class = (char *)tvb_get_string_enc(wmem_packet_scope(), tvb, offset, 1, ENC_ASCII); + if ((strcmp(service_class, "P") == 0) || (strcmp(service_class, "p") == 0)) { + proto_tree_add_string(station_tree, hf_conf_svc_class, tvb, offset, 1, "Protection"); + } + else if ((strcmp(service_class, "M") == 0) || (strcmp(service_class, "m") == 0)) { + proto_tree_add_string(station_tree, hf_conf_svc_class, tvb, offset, 1, "Monitoring"); + } + else { + proto_tree_add_string(station_tree, hf_conf_svc_class, tvb, offset, 1, "Unknown"); + } + offset += 1; + + /* WINDOW */ + proto_tree_add_item(station_tree, hf_conf_window, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + /*GRP_DLY */ + proto_tree_add_item(station_tree, hf_conf_grp_dly, tvb, offset, 4, ENC_BIG_ENDIAN); + offset += 4; + + /* FNOM and CFGCNT */ + proto_tree_add_item(station_tree, hf_conf_fnom, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + proto_tree_add_item(station_tree, hf_conf_cfgcnt, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* set the correct length for the "Station :" item */ + proto_item_set_len(station_item, offset - oldoffset); + } /* for() PMU blocks */ + + /* DATA_RATE */ + { + gint16 tmp = tvb_get_ntohis(tvb, offset); + if (tmp > 0) { + proto_tree_add_int_format_value(config_tree, hf_synphasor_rate_of_transmission, tvb, offset, 2, tmp, + "%d frame(s) per second", tmp); + } + else { + proto_tree_add_int_format_value(config_tree, hf_synphasor_rate_of_transmission, tvb, offset, 2, tmp, + "1 frame per %d second(s)", (gint16)-tmp); + } + offset += 2; + } + + return offset; +} /* dissect_config_3_frame() */ + +/* calculates the size (in bytes) of a data frame that the config_block describes */ +#define SYNP_BLOCKSIZE(x) (2 /* STAT */ \ + + wmem_array_get_count((x).phasors) * (integer == (x).format_ph ? 4 : 8) /* PHASORS */ \ + + (integer == (x).format_fr ? 4 : 8) /* (D)FREQ */ \ + + wmem_array_get_count((x).analogs) * (integer == (x).format_an ? 2 : 4) /* ANALOG */ \ + + (x).num_dg * 2) /* DIGITAL */ + +/* Dissects a data frame */ +static int dissect_data_frame(tvbuff_t *tvb, + proto_item *data_item, /* all items are placed beneath this item */ + packet_info *pinfo) /* used to find the data from a CFG-2 or CFG-3 frame */ +{ + proto_tree *data_tree; + gint offset = 0; + guint i; + config_frame *conf; + + proto_item_set_text(data_item, "Measurement data"); + data_tree = proto_item_add_subtree(data_item, ett_data); + + /* search for configuration information to dissect the frame */ + { + gboolean config_found = FALSE; + conf = (config_frame *)p_get_proto_data(wmem_file_scope(), pinfo, proto_synphasor, 0); + + if (conf) { + /* check if the size of the current frame is the + size of the frame the config_frame describes */ + size_t reported_size = 0; + for (i = 0; i < wmem_array_get_count(conf->config_blocks); i++) { + config_block *block = (config_block*)wmem_array_index(conf->config_blocks, i); + reported_size += SYNP_BLOCKSIZE(*block); + } + + if (tvb_reported_length(tvb) == reported_size) { + // Add link to CFG Frame + proto_item* item = proto_tree_add_uint(data_tree, hf_cfg_frame_num, tvb, 0,0, conf->fnum); + proto_item_set_generated(item); + config_found = TRUE; + } + } + + if (!config_found) { + proto_item_append_text(data_item, ", no configuration frame found"); + return 0; + } + } + + /* dissect a PMU block for every config_block in the frame */ + for (i = 0; i < wmem_array_get_count(conf->config_blocks); i++) { + config_block *block = (config_block*)wmem_array_index(conf->config_blocks, i); + + proto_tree *block_tree = proto_tree_add_subtree_format(data_tree, tvb, offset, SYNP_BLOCKSIZE(*block), + ett_data_block, NULL, + "Station: \"%s\"", block->name); + + /* STAT */ + proto_tree *temp_tree = proto_tree_add_subtree(block_tree, tvb, offset, 2, ett_data_stat, NULL, "Flags"); + + proto_item *temp_item = proto_tree_add_item(temp_tree, hf_data_statb15to14, tvb, offset, 2, ENC_BIG_ENDIAN); + guint16 flag_bits = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN) >> 14; // Get bits 15-14 + if (flag_bits != 0) { + expert_add_info(pinfo, temp_item, &ei_synphasor_data_error); + } + temp_item = proto_tree_add_item(temp_tree, hf_data_statb13, tvb, offset, 2, ENC_BIG_ENDIAN); + flag_bits = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN); // Get flag bits + if ((flag_bits >> 13)&1) { // Check 13 bit + expert_add_info(pinfo, temp_item, &ei_synphasor_pmu_not_sync); + } + proto_tree_add_item(temp_tree, hf_data_statb12, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_data_statb11, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_data_statb10, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_data_statb09, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_data_statb08to06, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_data_statb05to04, tvb, offset, 2, ENC_BIG_ENDIAN); + proto_tree_add_item(temp_tree, hf_data_statb03to00, tvb, offset, 2, ENC_BIG_ENDIAN); + offset += 2; + + /* PHASORS, (D)FREQ, ANALOG, and DIGITAL */ + offset = dissect_PHASORS(tvb, block_tree, block, offset); + offset = dissect_DFREQ (tvb, block_tree, block, offset); + offset = dissect_ANALOG (tvb, block_tree, block, offset); + offset = dissect_DIGITAL(tvb, block_tree, block, offset); + } + return offset; +} /* dissect_data_frame() */ + +/* Dissects a command frame and adds fields to config_item. + * + * 'pinfo' is used to add the type of command + * to the INFO column in the packet list. + */ +static int dissect_command_frame(tvbuff_t *tvb, + proto_item *command_item, + packet_info *pinfo) +{ + proto_tree *command_tree; + guint tvbsize = tvb_reported_length(tvb); + const char *s; + + proto_item_set_text(command_item, "Command data"); + command_tree = proto_item_add_subtree(command_item, ett_command); + + /* CMD */ + proto_tree_add_item(command_tree, hf_command, tvb, 0, 2, ENC_BIG_ENDIAN); + + s = rval_to_str_const(tvb_get_ntohs(tvb, 0), command_names, "invalid command"); + col_append_str(pinfo->cinfo, COL_INFO, ", "); + col_append_str(pinfo->cinfo, COL_INFO, s); + + if (tvbsize > 2) { + if (tvb_get_ntohs(tvb, 0) == 0x0008) { + /* Command: Extended Frame, the extra data is ok */ + proto_item *ti = proto_tree_add_item(command_tree, hf_synphasor_extended_frame_data, tvb, 2, tvbsize - 2, ENC_NA); + if (tvbsize % 2) + expert_add_info(pinfo, ti, &ei_synphasor_extended_frame_data); + } + else + proto_tree_add_item(command_tree, hf_synphasor_unknown_data, tvb, 2, tvbsize - 2, ENC_NA); + } + + return tvbsize; +} /* dissect_command_frame() */ + +/* Dissects the header (common to all types of frames) and then calls + * one of the subdissectors (declared above) for the rest of the frame. + */ +static int dissect_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) +{ + guint8 frame_type; + guint16 crc; + guint tvbsize = tvb_reported_length(tvb); + + /* some heuristics */ + if (tvbsize < 17 /* 17 bytes = header frame with only a + NULL character, useless but valid */ + || tvb_get_guint8(tvb, 0) != 0xAA) /* every synchrophasor frame starts with 0xAA */ + return 0; + + /* write the protocol name to the info column */ + col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME); + + frame_type = tvb_get_guint8(tvb, 1) >> 4; + + col_add_str(pinfo->cinfo, COL_INFO, val_to_str_const(frame_type, typenames, "invalid packet type")); + + /* CFG-2, CFG3, and DATA frames need special treatment during the first run: + * For CFG-2 & CFG-3 frames, a 'config_frame' struct is created to hold the + * information necessary to decode DATA frames. A pointer to this + * struct is saved in the conversation and is copied to the + * per-packet information if a DATA frame is dissected. + */ + if (!pinfo->fd->visited) { + if (CFG2 == frame_type && + check_crc(tvb, &crc)) { + conversation_t *conversation; + + /* fill the config_frame */ + config_frame *frame = config_frame_fast(tvb); + frame->fnum = pinfo->num; + + /* find a conversation, create a new one if none exists */ + conversation = find_or_create_conversation(pinfo); + + /* remove data from a previous CFG-2 frame, only + * the most recent configuration frame is relevant */ + if (conversation_get_proto_data(conversation, proto_synphasor)) + conversation_delete_proto_data(conversation, proto_synphasor); + + conversation_add_proto_data(conversation, proto_synphasor, frame); + } + else if ((CFG3 == frame_type) && check_crc(tvb, &crc)) { + conversation_t *conversation; + config_frame *frame; + + /* fill the config_frame */ + frame = config_3_frame_fast(tvb); + frame->fnum = pinfo->num; + + /* find a conversation, create a new one if none exists */ + conversation = find_or_create_conversation(pinfo); + + /* remove data from a previous CFG-3 frame, only + * the most recent configuration frame is relevant */ + if (conversation_get_proto_data(conversation, proto_synphasor)) { + conversation_delete_proto_data(conversation, proto_synphasor); + } + + conversation_add_proto_data(conversation, proto_synphasor, frame); + } + // Add conf to any frame for dissection fracsec + conversation_t *conversation = find_conversation_pinfo(pinfo, 0); + if (conversation) { + config_frame *conf = (config_frame *)conversation_get_proto_data(conversation, proto_synphasor); + /* no problem if 'conf' is NULL, the frame dissector checks this again */ + p_add_proto_data(wmem_file_scope(), pinfo, proto_synphasor, 0, conf); + } + } /* if (!visited) */ + + { + proto_tree *synphasor_tree; + proto_item *temp_item; + proto_item *sub_item; + + gint offset; + guint16 framesize; + tvbuff_t *sub_tvb; + gboolean crc_good; + + temp_item = proto_tree_add_item(tree, proto_synphasor, tvb, 0, -1, ENC_NA); + proto_item_append_text(temp_item, ", %s", val_to_str_const(frame_type, typenames, + ", invalid packet type")); + + /* synphasor_tree is where from now on all new elements for this protocol get added */ + synphasor_tree = proto_item_add_subtree(temp_item, ett_synphasor); + // Add pinfo for dissection fracsec + framesize = dissect_header(tvb, synphasor_tree, pinfo); + offset = 14; /* header is 14 bytes long */ + + /* check CRC, call appropriate subdissector for the rest of the frame if CRC is correct*/ + sub_item = proto_tree_add_item(synphasor_tree, hf_synphasor_data, tvb, offset, tvbsize - 16, ENC_NA); + crc_good = check_crc(tvb, &crc); + proto_tree_add_checksum(synphasor_tree, tvb, tvbsize - 2, hf_synphasor_checksum, hf_synphasor_checksum_status, &ei_synphasor_checksum, + pinfo, crc16_x25_ccitt_tvb(tvb, tvb_get_ntohs(tvb, 2) - 2), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY); + if (!crc_good) { + proto_item_append_text(sub_item, ", not dissected because of wrong checksum"); + } + else { + /* create a new tvb to pass to the subdissector + '-16': length of header + 2 CRC bytes */ + sub_tvb = tvb_new_subset_length_caplen(tvb, offset, tvbsize - 16, framesize - 16); + + /* call subdissector */ + switch (frame_type) { + case DATA: + dissect_data_frame(sub_tvb, sub_item, pinfo); + break; + case HEADER: /* no further dissection is done/needed */ + proto_item_append_text(sub_item, "Header Frame"); + break; + case CFG1: + case CFG2: + dissect_config_frame(sub_tvb, sub_item); + break; + case CMD: + dissect_command_frame(sub_tvb, sub_item, pinfo); + break; + case CFG3: + /* Note: The C37.118-2.2001 stanadard is vague on how to handle fragmented frames. + Until further clarification is given, fragmented frames with the CONT_IDX + are not supported. */ + if (tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN) != 0) { + proto_item_append_text(sub_item, ", CFG-3 Fragmented Frame (Not Supported)"); + } + else { + dissect_config_3_frame(sub_tvb, sub_item); + } + break; + default: + proto_item_append_text(sub_item, " of unknown type"); + } + proto_item_append_text(temp_item, " [correct]"); + } + + /* remaining 2 bytes are the CRC */ + } + + return tvb_reported_length(tvb); +} /* dissect_common() */ + +/* called for synchrophasors over UDP */ +static int dissect_udp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) +{ + return dissect_common(tvb, pinfo, tree, data); +} + +/* callback for 'tcp_dissect_pdus()' to give it the length of the frame */ +static guint get_pdu_length(packet_info *pinfo _U_, tvbuff_t *tvb, + int offset, void *data _U_) +{ + return tvb_get_ntohs(tvb, offset + 2); +} + +static int dissect_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) +{ + tcp_dissect_pdus(tvb, pinfo, tree, TRUE, 4, get_pdu_length, dissect_common, data); + + return tvb_reported_length(tvb); +} + +/*******************************************************************/ +/* after this line: Wireshark Register Routines */ +/*******************************************************************/ + +/* Register Synchrophasor Protocol with Wireshark*/ +void proto_register_synphasor(void) +{ + static hf_register_info hf[] = { + /* Sync word */ + { &hf_sync, + { "Synchronization word", "synphasor.sync", FT_UINT16, BASE_HEX, + NULL, 0x0, NULL, HFILL }}, + + /* Flags in the Sync word */ + { &hf_sync_frtype, + { "Frame Type", "synphasor.frtype", FT_UINT16, BASE_HEX, + VALS(typenames), 0x0070, NULL, HFILL }}, + + { &hf_sync_version, + { "Version", "synphasor.version", FT_UINT16, BASE_DEC, + VALS(versionnames), 0x000F, NULL, HFILL }}, + + { &hf_frsize, + { "Framesize", "synphasor.frsize", FT_UINT16, BASE_DEC | BASE_UNIT_STRING, + &units_byte_bytes, 0x0, NULL, HFILL }}, + + { &hf_station_name_len, + { "Station name length", "synphasor.station_name_len", FT_UINT8, + BASE_DEC | BASE_UNIT_STRING, &units_byte_bytes, 0x0, NULL, HFILL }}, + + { &hf_station_name, + { "Station name", "synphasor.station_name", FT_STRING, BASE_NONE, + NULL, 0x0, NULL, HFILL }}, + + { &hf_idcode_stream_source, + { "PMU/DC ID number (Stream source ID)", "synphasor.idcode_stream_source", FT_UINT16, BASE_DEC, + NULL, 0x0, NULL, HFILL }}, + + { &hf_idcode_data_source, + { "PMU/DC ID number (Data source ID)", "synphasor.idcode_data_source", FT_UINT16, BASE_DEC, + NULL, 0x0, NULL, HFILL }}, + + { &hf_g_pmu_id, + { "Global PMU ID (raw hex bytes)", "synphasor.gpmuid", FT_BYTES, BASE_NONE, + NULL, 0x0, NULL, HFILL }}, + + { &hf_soc, + { "SOC time stamp", "synphasor.soc", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, + NULL, 0x0, NULL, HFILL }}, + + /* Time quality flags in fracsec */ + { &hf_timeqal_lsdir, + { "Leap second direction", "synphasor.timeqal.lsdir", FT_BOOLEAN, 8, + TFS(&leapseconddir), 0x40, NULL, HFILL }}, + + { &hf_timeqal_lsocc, + { "Leap second occurred", "synphasor.timeqal.lsocc", FT_BOOLEAN, 8, + NULL, 0x20, NULL, HFILL }}, + + { &hf_timeqal_lspend, + { "Leap second pending", "synphasor.timeqal.lspend", FT_BOOLEAN, 8, + NULL, 0x10, NULL, HFILL }}, + + { &hf_timeqal_timequalindic, + { "Message Time Quality indicator code", "synphasor.timeqal.timequalindic", FT_UINT8, BASE_HEX, + VALS(timequalcodes), 0x0F, NULL, HFILL }}, + + /* Fraction of second */ + { &hf_fracsec_raw, + { "Fraction of second (raw)", "synphasor.fracsec_raw", FT_UINT24, BASE_DEC, + NULL, 0x0, NULL, HFILL }}, + + { &hf_fracsec_ms, + { "Fraction of second", "synphasor.fracsec_ms", FT_FLOAT, BASE_NONE | BASE_UNIT_STRING, + &units_millisecond_milliseconds, 0x0, NULL, HFILL }}, + + /* Data types for configuration frames */ + { &hf_cont_idx, + { "Continuation index", "synphasor.conf.contindx", FT_UINT16, BASE_DEC, + NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_timebase, + { "Resolution of fractional second time stamp", "synphasor.conf.timebase", FT_UINT24, BASE_DEC, + NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_numpmu, + { "Number of PMU blocks included in the frame", "synphasor.conf.numpmu", FT_UINT16, BASE_DEC, + NULL, 0x0, NULL, HFILL }}, + + /* Bits in the FORMAT word */ + { &hf_conf_formatb3, + { "FREQ/DFREQ format", "synphasor.conf.dfreq_format", FT_BOOLEAN, 16, + TFS(&conf_formatb123names), 0x8, NULL, HFILL }}, + + { &hf_conf_formatb2, + { "Analog values format", "synphasor.conf.analog_format", FT_BOOLEAN, 16, + TFS(&conf_formatb123names), 0x4, NULL, HFILL }}, + + { &hf_conf_formatb1, + { "Phasor format", "synphasor.conf.phasor_format", FT_BOOLEAN, 16, + TFS(&conf_formatb123names), 0x2, NULL, HFILL }}, + + { &hf_conf_formatb0, + { "Phasor notation", "synphasor.conf.phasor_notation", FT_BOOLEAN, 16, + TFS(&conf_formatb0names), 0x1, NULL, HFILL }}, + + { &hf_conf_chnam_len, + { "Channel name length", "synphasor.conf.chnam_len", FT_UINT8, + BASE_DEC | BASE_UNIT_STRING, &units_byte_bytes, 0x0, NULL, HFILL }}, + + { &hf_conf_chnam, + { "Channel name", "synphasor.conf.chnam", FT_STRING, BASE_NONE, + NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b15, + { "Modification", "synphasor.conf.phasor_mod.type_not_def", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b15), 0x8000, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b10, + { "Modification", "synphasor.conf.phasor_mod.pseudo_phasor", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b10), 0x0400, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b09, + { "Modification", "synphasor.conf.phasor_mod.phase_rotation", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b09), 0x0200, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b08, + { "Modification", "synphasor.conf.phasor_mod.phase_calibration", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b08), 0x0100, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b07, + { "Modification", "synphasor.conf.phasor_mod.mag_calibration", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b07), 0x0080, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b06, + { "Modification", "synphasor.conf.phasor_mod.filtered", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b06), 0x0040, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b05, + { "Modification", "synphasor.conf.phasor_mod.downsampled", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b05), 0x0020, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b04, + { "Modification", "synphasor.conf.phasor_mod.downsampled_fir", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b04), 0x0010, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b03, + { "Modification", "synphasor.conf.phasor_mod.downsampled_reselect", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b03), 0x0008, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b02, + { "Modification", "synphasor.conf.phasor_mod.upsampled_extrapolation", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b02), 0x0004, NULL, HFILL }}, + + { &hf_conf_phasor_mod_b01, + { "Modification", "synphasor.conf.phasor_mod.upsampled_interpolation", FT_BOOLEAN, 16, + TFS(&conf_phasor_mod_b01), 0x0002, NULL, HFILL }}, + + { &hf_conf_phasor_type_b03, + { "Phasor Type", "synphasor.conf.phasor_type", FT_BOOLEAN, 8, + TFS(&conf_phasor_type_b03), 0x8, NULL, HFILL }}, + + { &hf_conf_phasor_type_b02to00, + { "Phasor Type", "synphasor.conf.phasor_component", FT_UINT8, BASE_HEX, + VALS(conf_phasor_type_b02to00), 0x7, NULL, HFILL }}, + + { &hf_conf_phasor_user_data, + { "Binary format", "synphasor.conf.phasor_user_flags", FT_BOOLEAN, 8, + TFS(&conf_phasor_user_defined), 0xff, NULL, HFILL }}, + + { &hf_conf_phasor_scale_factor, + { "Phasor scale factor", "synphasor.conf.phasor_scale_factor", FT_FLOAT, + BASE_NONE, NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_phasor_angle_offset, + { "Phasor angle offset", "synphasor.conf.phasor_angle_offset", FT_FLOAT, + BASE_NONE | BASE_UNIT_STRING, &units_degree_degrees, 0x0, NULL, HFILL }}, + + { &hf_conf_analog_scale_factor, + { "Analog scale factor", "synphasor.conf.analog_scale_factor", FT_FLOAT, + BASE_NONE, NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_analog_offset, + { "Analog offset", "synphasor.conf.analog_offset", FT_FLOAT, + BASE_NONE, NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_pmu_lat, + { "PMU Latitude", "synphasor.conf.pmu_latitude", FT_FLOAT, + BASE_NONE | BASE_UNIT_STRING, &units_degree_degrees, 0x0, NULL, HFILL }}, + + { &hf_conf_pmu_lon, + { "PMU Longitude", "synphasor.conf.pmu_longitude", FT_FLOAT, + BASE_NONE | BASE_UNIT_STRING, &units_degree_degrees, 0x0, NULL, HFILL }}, + + { &hf_conf_pmu_elev, + { "PMU Elevation", "synphasor.conf.pmu_elevation", FT_FLOAT, + BASE_NONE | BASE_UNIT_STRING, &units_meter_meters, 0x0, NULL, HFILL }}, + + { &hf_conf_pmu_lat_unknown, + { "PMU Latitude", "synphasor.conf.pmu_latitude", FT_FLOAT, BASE_NONE, + NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_pmu_lon_unknown, + { "PMU Longitude", "synphasor.conf.pmu_longitude", FT_FLOAT, BASE_NONE, + NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_pmu_elev_unknown, + { "PMU Elevation", "synphasor.conf.pmu_elevation", FT_FLOAT, BASE_NONE, + NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_svc_class, + { "Service class", "synphasor.conf.svc_class", FT_STRING, BASE_NONE, + NULL, 0x0, NULL, HFILL }}, + + { &hf_conf_window, + { "PM window length", "synphasor.conf.window", FT_UINT32, + BASE_DEC | BASE_UNIT_STRING, &units_microsecond_microseconds, 0x0, NULL, HFILL }}, + + { &hf_conf_grp_dly, + { "PM group delay", "synphasor.conf.grp_dly", FT_UINT32, + BASE_DEC | BASE_UNIT_STRING, &units_microsecond_microseconds, 0x0, NULL, HFILL }}, + + { &hf_conf_fnom, + { "Nominal line frequency", "synphasor.conf.fnom", FT_BOOLEAN, 16, + TFS(&conf_fnomnames), 0x0001, NULL, HFILL }}, + + { &hf_conf_cfgcnt, + { "Configuration change count", "synphasor.conf.cfgcnt", FT_UINT16, BASE_DEC, + NULL, 0, NULL, HFILL }}, + + /* Data types for data frames */ + /* Link to CFG Frame */ + { &hf_cfg_frame_num, + { "Dissected using configuration from frame", "synphasor.data.conf_frame", FT_FRAMENUM, BASE_NONE, NULL, 0x0,"", HFILL }}, + + /* Flags in the STAT word */ + { &hf_data_statb15to14, + { "Data error", "synphasor.data.status", FT_UINT16, BASE_HEX, + VALS(data_statb15to14names), 0xC000, NULL, HFILL }}, + + { &hf_data_statb13, + { "Time synchronized", "synphasor.data.sync", FT_BOOLEAN, 16, + TFS(&data_statb13names), 0x2000, NULL, HFILL }}, + + { &hf_data_statb12, + { "Data sorting", "synphasor.data.sorting", FT_BOOLEAN, 16, + TFS(&data_statb12names), 0x1000, NULL, HFILL }}, + + { &hf_data_statb11, + { "Trigger detected", "synphasor.data.trigger", FT_BOOLEAN, 16, + TFS(&data_statb11names), 0x0800, NULL, HFILL }}, + + { &hf_data_statb10, + { "Configuration changed", "synphasor.data.CFGchange", FT_BOOLEAN, 16, + TFS(&data_statb10names), 0x0400, NULL, HFILL }}, + + { &hf_data_statb09, + { "Data modified indicator", "synphasor.data.data_modified", FT_BOOLEAN, 16, + TFS(&data_statb09names), 0x0200, NULL, HFILL }}, + + { &hf_data_statb08to06, + { "PMU Time Quality", "synphasor.data.pmu_tq", FT_UINT16, BASE_HEX, + VALS(data_statb08to06names), 0x01C0, NULL, HFILL }}, + + { &hf_data_statb05to04, + { "Unlocked time", "synphasor.data.t_unlock", FT_UINT16, BASE_HEX, + VALS(data_statb05to04names), 0x0030, NULL, HFILL }}, + + { &hf_data_statb03to00, + { "Trigger reason", "synphasor.data.trigger_reason", FT_UINT16, BASE_HEX, + VALS(data_statb03to00names), 0x000F, NULL, HFILL }}, + + /* Data type for command frame */ + { &hf_command, + { "Command", "synphasor.command", FT_UINT16, BASE_HEX|BASE_RANGE_STRING, + RVALS(command_names), 0x0, NULL, HFILL }}, + + /* Generated from convert_proto_tree_add_text.pl */ + { &hf_synphasor_data, { "Data", "synphasor.data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_checksum, { "Checksum", "synphasor.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_checksum_status, { "Checksum Status", "synphasor.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0, NULL, HFILL }}, + { &hf_synphasor_num_phasors, { "Number of phasors", "synphasor.num_phasors", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_num_analog_values, { "Number of analog values", "synphasor.num_analog_values", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_num_digital_status_words, { "Number of digital status words", "synphasor.num_digital_status_words", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_rate_of_transmission, { "Rate of transmission", "synphasor.rate_of_transmission", FT_INT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_phasor, { "Phasor", "synphasor.phasor", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_actual_frequency_value, { "Actual frequency value", "synphasor.actual_frequency_value", FT_FLOAT, BASE_NONE|BASE_UNIT_STRING, &units_hz, 0x0, NULL, HFILL }}, + { &hf_synphasor_rate_change_frequency, { "Rate of change of frequency", "synphasor.rate_change_frequency", FT_FLOAT, BASE_NONE|BASE_UNIT_STRING, &units_hz_s, 0x0, NULL, HFILL }}, + { &hf_synphasor_frequency_deviation_from_nominal, { "Frequency deviation from nominal", "synphasor.frequency_deviation_from_nominal", FT_INT16, BASE_DEC, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_analog_value, { "Analog value", "synphasor.analog_value", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_digital_status_word, { "Digital status word", "synphasor.digital_status_word", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_conversion_factor, { "conversion factor", "synphasor.conversion_factor", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_factor_for_analog_value, { "Factor for analog value", "synphasor.factor_for_analog_value", FT_UINT32, BASE_DEC, NULL, 0x000000FF, NULL, HFILL }}, + { &hf_synphasor_channel_name, { "Channel name", "synphasor.channel_name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_extended_frame_data, { "Extended frame data", "synphasor.extended_frame_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_unknown_data, { "Unknown data", "synphasor.data.unknown", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }}, + { &hf_synphasor_status_word_mask_normal_state, { "Normal state", "synphasor.status_word_mask.normal_state", FT_UINT16, BASE_HEX, NULL, 0xFFFF, NULL, HFILL }}, + { &hf_synphasor_status_word_mask_valid_bits, { "Valid bits", "synphasor.status_word_mask.valid_bits", FT_UINT16, BASE_HEX, NULL, 0xFFFF, NULL, HFILL }}, + }; + + /* protocol subtree array */ + static gint *ett[] = { + &ett_synphasor, + &ett_frtype, + &ett_timequal, + &ett_conf, + &ett_conf_station, + &ett_conf_format, + &ett_conf_phnam, + &ett_conf_annam, + &ett_conf_dgnam, + &ett_conf_phconv, + &ett_conf_phlist, + &ett_conf_phflags, + &ett_conf_phmod_flags, + &ett_conf_ph_user_flags, + &ett_conf_anconv, + &ett_conf_anlist, + &ett_conf_dgmask, + &ett_conf_chnam, + &ett_conf_wgs84, + &ett_data, + &ett_data_block, + &ett_data_stat, + &ett_data_phasors, + &ett_data_analog, + &ett_data_digital, + &ett_command, + &ett_status_word_mask + }; + + static ei_register_info ei[] = { + { &ei_synphasor_extended_frame_data, { "synphasor.extended_frame_data.unaligned", PI_PROTOCOL, PI_WARN, "Size not multiple of 16-bit word", EXPFILL }}, + { &ei_synphasor_checksum, { "synphasor.bad_checksum", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }}, + { &ei_synphasor_data_error, { "synphasor.data_error", PI_RESPONSE_CODE, PI_NOTE, "Data Error flag set", EXPFILL }}, + { &ei_synphasor_pmu_not_sync, { "synphasor.pmu_not_sync", PI_RESPONSE_CODE, PI_NOTE, "PMU not sync flag set", EXPFILL }}, + }; + + expert_module_t* expert_synphasor; + + /* register protocol */ + proto_synphasor = proto_register_protocol(PNAME, PSNAME, PFNAME); + + /* Registering protocol to be called by another dissector */ + synphasor_udp_handle = register_dissector("synphasor", dissect_udp, proto_synphasor); + synphasor_tcp_handle = register_dissector("synphasor.tcp", dissect_tcp, proto_synphasor); + + proto_register_field_array(proto_synphasor, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_synphasor = expert_register_protocol(proto_synphasor); + expert_register_field_array(expert_synphasor, ei, array_length(ei)); + +} /* proto_register_synphasor() */ + +/* called at startup and when the preferences change */ +void proto_reg_handoff_synphasor(void) +{ + dissector_add_for_decode_as("rtacser.data", synphasor_udp_handle); + dissector_add_uint_with_preference("udp.port", SYNPHASOR_UDP_PORT, synphasor_udp_handle); + dissector_add_uint_with_preference("tcp.port", SYNPHASOR_TCP_PORT, synphasor_tcp_handle); +} /* proto_reg_handoff_synphasor() */ + +/* + * Editor modelines - https://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 8 + * tab-width: 8 + * indent-tabs-mode: t + * End: + * + * vi: set shiftwidth=8 tabstop=8 noexpandtab: + * :indentSize=8:tabSize=8:noTabs=false: + */ |