/* file-blf.c

 * BLF File Format.

 * By Dr. Lars Völker <lars.voelker@technica-engineering.de>

 * Copyright 2020-2025 Dr. Lars Völker

  *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 *

 * This dissector allows to parse BLF files.

 */

 /*

  * The following was used as a reference for the file format:

  *     https://bitbucket.org/tobylorenz/vector_blf

  * The repo above includes multiple examples files as well.

  */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/unit_strings.h>

#include <epan/dissectors/packet-socketcan.h>

#include <wiretap/blf.h>

#include <wsutil/array.h>

static int proto_blf;

static int proto_blf_ethernetstatus_obj;

static int proto_blf_ethernetphystate_obj;

static dissector_handle_t xml_handle;

static int hf_blf_file_header;

static int hf_blf_file_header_magic;

static int hf_blf_file_header_length;

static int hf_blf_file_header_api;

static int hf_blf_file_header_app;

static int hf_blf_file_header_comp_level;

static int hf_blf_file_header_app_major;

static int hf_blf_file_header_app_minor;

static int hf_blf_file_header_len_comp;

static int hf_blf_file_header_len_uncomp;

static int hf_blf_file_header_obj_count;

static int hf_blf_file_header_app_build;

static int hf_blf_file_header_start_date;

static int hf_blf_file_header_end_date;

static int hf_blf_file_header_restore_point_offset;

static int hf_blf_lobj;

static int hf_blf_lobj_hdr;

static int hf_blf_lobj_magic;

static int hf_blf_lobj_hdr_len;

static int hf_blf_lobj_hdr_type;

static int hf_blf_lobj_obj_len;

static int hf_blf_lobj_obj_type;

static int hf_blf_lobj_obj_flags;

static int hf_blf_lobj_obj_flags_time_ten_ms;

static int hf_blf_lobj_obj_flags_time_one_ns;

static int hf_blf_lobj_client_index;

static int hf_blf_lobj_time_stamp_status;

static int hf_blf_lobj_reserved;

static int hf_blf_lobj_obj_version;

static int hf_blf_lobj_obj_timestamp;

static int hf_blf_lobj_org_timestamp;

static int hf_blf_lobj_hdr_remains;

static int hf_blf_lobj_payload;

static int hf_blf_lobj_payload_channel_8bit;

static int hf_blf_lobj_payload_channel_16bit;

static int hf_blf_cont_comp_method;

static int hf_blf_cont_res1;

static int hf_blf_cont_res2;

static int hf_blf_cont_uncomp_size;

static int hf_blf_cont_res4;

static int hf_blf_cont_payload;

static int hf_blf_app_text_source;

static int hf_blf_app_text_reservedapptext1;

static int hf_blf_app_text_textlength;

static int hf_blf_app_text_reservedapptext2;

static int hf_blf_app_text_data_version;

static int hf_blf_app_text_channelno;

static int hf_blf_app_text_busstype;

static int hf_blf_app_text_can_fd_channel;

static int hf_blf_app_text_metadata_remaining_length;

static int hf_blf_app_text_metadata_type;

static int hf_blf_app_text_traceline_source;

static int hf_blf_app_text_traceline_display_in_tracewindow;

static int hf_blf_app_text_traceline_ascii_conversion_wo_comment_indicator_timestamp;

static int hf_blf_app_text_text;

static int hf_blf_trigg_cond_state;

static int hf_blf_trigg_cond_triggerblocknamelength;

static int hf_blf_trigg_cond_triggerconditionlength;

static int hf_blf_trigg_cond_triggerblockname;

static int hf_blf_trigg_cond_triggercondition;

static int hf_blf_sys_var_type;

static int hf_blf_sys_var_rep;

static int hf_blf_sys_var_reservedsystemvariable1;

static int hf_blf_sys_var_namelength;

static int hf_blf_sys_var_datalength;

static int hf_blf_sys_var_reservedsystemvariable2;

static int hf_blf_sys_var_name;

static int hf_blf_sys_var_data;

static int hf_blf_eth_status_channel;

static int hf_blf_eth_status_flags1_b0;

static int hf_blf_eth_status_flags1_b1;

static int hf_blf_eth_status_flags1_b2;

static int hf_blf_eth_status_flags1_b3;

static int hf_blf_eth_status_flags1_b4;

static int hf_blf_eth_status_flags1_b5;

static int hf_blf_eth_status_flags1_b6;

static int hf_blf_eth_status_flags1_b7;

static int hf_blf_eth_status_flags1_b8;

static int hf_blf_eth_status_flags1_b9;

static int hf_blf_eth_status_linkstatus;

static int hf_blf_eth_status_ethernetphy;

static int hf_blf_eth_status_duplex;

static int hf_blf_eth_status_mdi;

static int hf_blf_eth_status_connector;

static int hf_blf_eth_status_clockmode;

static int hf_blf_eth_status_pairs;

static int hf_blf_eth_status_hardwarechannel;

static int hf_blf_eth_status_bitrate;

static int hf_blf_eth_status_linkupduration;

static int hf_blf_eth_frame_ext_structlength;

static int hf_blf_eth_frame_ext_flags;

static int hf_blf_eth_frame_ext_channel;

static int hf_blf_eth_frame_ext_hardwarechannel;

static int hf_blf_eth_frame_ext_frameduration;

static int hf_blf_eth_frame_ext_framechecksum;

static int hf_blf_eth_frame_ext_dir;

static int hf_blf_eth_frame_ext_framelength;

static int hf_blf_eth_frame_ext_framehandle;

static int hf_blf_eth_frame_ext_reservedethernetframeex;

static int hf_blf_eth_phystate_channel;

static int hf_blf_eth_phy_state_flags1_b0;

static int hf_blf_eth_phy_state_flags1_b1;

static int hf_blf_eth_phy_state_flags1_b2;

static int hf_blf_eth_phy_state_phystate;

static int hf_blf_eth_phy_state_eventstate;

static int hf_blf_eth_phy_state_hardwarechannel;

static int hf_blf_eth_phy_state_res1;

static int hf_blf_canxl_tx_count_number;

static int hf_blf_canxl_tx_count_attempts;

static int hf_blf_canxl_tx_dir;

static int hf_blf_canxl_res1;

static int hf_blf_canxl_frame_duration_in_ns;

static int hf_blf_canxl_bit_count;

static int hf_blf_canxl_res2;

static int hf_blf_canxl_id;

static int hf_blf_canxl_sdt;

static int hf_blf_canxl_res3;

static int hf_blf_canxl_dlc;

static int hf_blf_canxl_data_length;

static int hf_blf_canxl_sbc;

static int hf_blf_canxl_pcrc;

static int hf_blf_canxl_vcid;

static int hf_blf_canxl_res4;

static int hf_blf_canxl_af;

static int hf_blf_canxl_stuff_count;

static int hf_blf_canxl_res5;

static int hf_blf_canxl_res6;

static int hf_blf_canxl_fcrc;

static int hf_blf_canxl_time_offset_brs;

static int hf_blf_canxl_time_offset_crc_delim;

static int hf_blf_canxl_flags;

static int hf_blf_canxl_res;

static int hf_blf_canxl_arbitration_data_bit_timing;

static int hf_blf_canxl_arbitration_data_hardware_channel_setting;

static int hf_blf_canxl_fd_phase_bit_timing;

static int hf_blf_canxl_fd_phasea_hardware_channel_setting;

static int hf_blf_canxl_xl_phase_bit_timing;

static int hf_blf_canxl_xl_phase_hardware_channel_setting;

static int hf_blf_canxl_data;

static expert_field ei_blf_file_header_length_too_short;

static expert_field ei_blf_object_header_length_too_short;

static expert_field ei_blf_object_length_less_than_header_length;

static int ett_blf;

static int ett_blf_header;

static int ett_blf_obj;

static int ett_blf_obj_header;

static int ett_blf_obj_header_flags;

static int ett_blf_obj_payload;

static int ett_blf_logcontainer_payload;

static int ett_blf_app_text_payload;

static const value_string blf_object_names[] = {

    { BLF_OBJTYPE_UNKNOWN,                          "Unknown" },

    { BLF_OBJTYPE_CAN_MESSAGE,                      "CAN Message" },

    { BLF_OBJTYPE_CAN_ERROR,                        "CAN Error" },

    { BLF_OBJTYPE_CAN_OVERLOAD,                     "CAN Overload" },

    { BLF_OBJTYPE_CAN_STATISTIC,                    "CAN Statistics" },

    { BLF_OBJTYPE_APP_TRIGGER,                      "App Trigger" },

    { BLF_OBJTYPE_ENV_INTEGER,                      "Env Integer" },

    { BLF_OBJTYPE_ENV_DOUBLE,                       "Env Double" },

    { BLF_OBJTYPE_ENV_STRING,                       "Env String" },

    { BLF_OBJTYPE_ENV_DATA,                         "Env Data" },

    { BLF_OBJTYPE_LOG_CONTAINER,                    "Log Container" },

    { BLF_OBJTYPE_LIN_MESSAGE,                      "LIN Message" },

    { BLF_OBJTYPE_LIN_CRC_ERROR,                    "LIN CRC Error" },

    { BLF_OBJTYPE_LIN_DLC_INFO,                     "LIN DLC Info" },

    { BLF_OBJTYPE_LIN_RCV_ERROR,                    "LIN Receive Error" },

    { BLF_OBJTYPE_LIN_SND_ERROR,                    "LIN Send Error" },

    { BLF_OBJTYPE_LIN_SLV_TIMEOUT,                  "LIN Slave Timeout" },

    { BLF_OBJTYPE_LIN_SCHED_MODCH,                  "LIN Schedule Mode Change" },

    { BLF_OBJTYPE_LIN_SYN_ERROR,                    "LIN Sync Error" },

    { BLF_OBJTYPE_LIN_BAUDRATE,                     "LIN Baudrate" },

    { BLF_OBJTYPE_LIN_SLEEP,                        "LIN Sleep" },

    { BLF_OBJTYPE_LIN_WAKEUP,                       "LIN Wakeup" },

    { BLF_OBJTYPE_MOST_SPY,                         "MOST Spy" },

    { BLF_OBJTYPE_MOST_CTRL,                        "MOST Control" },

    { BLF_OBJTYPE_MOST_LIGHTLOCK,                   "MOST Light Lock" },

    { BLF_OBJTYPE_MOST_STATISTIC,                   "MOST Statistics" },

    { BLF_OBJTYPE_FLEXRAY_DATA,                     "FlexRay Data" },

    { BLF_OBJTYPE_FLEXRAY_SYNC,                     "FlexRay Sync" },

    { BLF_OBJTYPE_CAN_DRIVER_ERROR,                 "CAN Driver Error" },

    { BLF_OBJTYPE_MOST_PKT,                         "MOST Packet" },

    { BLF_OBJTYPE_MOST_PKT2,                        "MOST Packet 2" },

    { BLF_OBJTYPE_MOST_HWMODE,                      "MOST Hardware Mode" },

    { BLF_OBJTYPE_MOST_REG,                         "MOST Register Data" },

    { BLF_OBJTYPE_MOST_GENREG,                      "MOST Register Data" },

    { BLF_OBJTYPE_MOST_NETSTATE,                    "MOST Net State" },

    { BLF_OBJTYPE_MOST_DATALOST,                    "MOST Data Lost" },

    { BLF_OBJTYPE_MOST_TRIGGER,                     "MOST Trigger" },

    { BLF_OBJTYPE_FLEXRAY_CYCLE,                    "FlexRay Cycle" },

    { BLF_OBJTYPE_FLEXRAY_MESSAGE,                  "FlexRay Message" },

    { BLF_OBJTYPE_LIN_CHECKSUM_INFO,                "LIN Checksum Info" },

    { BLF_OBJTYPE_LIN_SPIKE_EVENT,                  "LIN Spike Event" },

    { BLF_OBJTYPE_CAN_DRIVER_SYNC,                  "CAN Driver Sync" },

    { BLF_OBJTYPE_FLEXRAY_STATUS,                   "FlexRay Status" },

    { BLF_OBJTYPE_GPS_EVENT,                        "GPS Event" },

    { BLF_OBJTYPE_FLEXRAY_ERROR,                    "FlexRay Error" },

    { BLF_OBJTYPE_FLEXRAY_STATUS2,                  "FlexRay Status 2" },

    { BLF_OBJTYPE_FLEXRAY_STARTCYCLE,               "FlexRay Start Cycle" },

    { BLF_OBJTYPE_FLEXRAY_RCVMESSAGE,               "FlexRay Receive Message" },

    { BLF_OBJTYPE_REALTIMECLOCK,                    "Realtime Clock" },

    { BLF_OBJTYPE_LIN_STATISTIC,                    "LIN Statistics" },

    { BLF_OBJTYPE_J1708_MESSAGE,                    "J1708 Message" },

    { BLF_OBJTYPE_J1708_VIRTUAL_MSG,                "J1708 Virtual Message" },

    { BLF_OBJTYPE_LIN_MESSAGE2,                     "LIN Message 2" },

    { BLF_OBJTYPE_LIN_SND_ERROR2,                   "LIN Send Error 2" },

    { BLF_OBJTYPE_LIN_SYN_ERROR2,                   "LIN Sync Error 2" },

    { BLF_OBJTYPE_LIN_CRC_ERROR2,                   "LIN CRC Error 2" },

    { BLF_OBJTYPE_LIN_RCV_ERROR2,                   "LIN Receive Error 2" },

    { BLF_OBJTYPE_LIN_WAKEUP2,                      "LIN Wakeup 2" },

    { BLF_OBJTYPE_LIN_SPIKE_EVENT2,                 "LIN Spike Event 2" },

    { BLF_OBJTYPE_LIN_LONG_DOM_SIG,                 "LIN Long Dominant Signal" },

    { BLF_OBJTYPE_APP_TEXT,                         "Text" },

    { BLF_OBJTYPE_FLEXRAY_RCVMESSAGE_EX,            "FlexRay Receive Message Ext" },

    { BLF_OBJTYPE_MOST_STATISTICEX,                 "MOST Statistics Ext" },

    { BLF_OBJTYPE_MOST_TXLIGHT,                     "MOST TX Light" },

    { BLF_OBJTYPE_MOST_ALLOCTAB,                    "MOST Allocation Table" },

    { BLF_OBJTYPE_MOST_STRESS,                      "MOST Stress" },

    { BLF_OBJTYPE_ETHERNET_FRAME,                   "Ethernet Frame" },

    { BLF_OBJTYPE_SYS_VARIABLE,                     "System Variable" },

    { BLF_OBJTYPE_CAN_ERROR_EXT,                    "CAN Error Ext" },

    { BLF_OBJTYPE_CAN_DRIVER_ERROR_EXT,             "CAN Driver Error Ext" },

    { BLF_OBJTYPE_LIN_LONG_DOM_SIG2,                "LIN Long Dominant Signal 2" },

    { BLF_OBJTYPE_MOST_150_MESSAGE,                 "MOST150 Message" },

    { BLF_OBJTYPE_MOST_150_PKT,                     "MOST150 Packet" },

    { BLF_OBJTYPE_MOST_ETHERNET_PKT,                "MOST Ethernet Packet" },

    { BLF_OBJTYPE_MOST_150_MESSAGE_FRAGMENT,        "MOST150 Message Fragment" },

    { BLF_OBJTYPE_MOST_150_PKT_FRAGMENT,            "MOST150 Packet Fragment" },

    { BLF_OBJTYPE_MOST_ETHERNET_PKT_FRAGMENT,       "MOST Ethernet Packet Fragment" },

    { BLF_OBJTYPE_MOST_SYSTEM_EVENT,                "MOST System Event" },

    { BLF_OBJTYPE_MOST_150_ALLOCTAB,                "MOST150 Allocation Table" },

    { BLF_OBJTYPE_MOST_50_MESSAGE,                  "MOST50 Message" },

    { BLF_OBJTYPE_MOST_50_PKT,                      "MOST50 Packet" },

    { BLF_OBJTYPE_CAN_MESSAGE2,                     "CAN Message 2" },

    { BLF_OBJTYPE_LIN_UNEXPECTED_WAKEUP,            "LIN Unexpected Wakeup" },

    { BLF_OBJTYPE_LIN_SHORT_OR_SLOW_RESPONSE,       "LIN Short or Slow Response" },

    { BLF_OBJTYPE_LIN_DISTURBANCE_EVENT,            "LIN Disturbance" },

    { BLF_OBJTYPE_SERIAL_EVENT,                     "Serial" },

    { BLF_OBJTYPE_OVERRUN_ERROR,                    "Overrun Error" },

    { BLF_OBJTYPE_EVENT_COMMENT,                    "Comment" },

    { BLF_OBJTYPE_WLAN_FRAME,                       "WLAN Frame" },

    { BLF_OBJTYPE_WLAN_STATISTIC,                   "WLAN Statistics" },

    { BLF_OBJTYPE_MOST_ECL,                         "MOST Electric Control Line" },

    { BLF_OBJTYPE_GLOBAL_MARKER,                    "Global Marker" },

    { BLF_OBJTYPE_AFDX_FRAME,                       "AFDX Frame" },

    { BLF_OBJTYPE_AFDX_STATISTIC,                   "AFDX Statistics" },

    { BLF_OBJTYPE_KLINE_STATUSEVENT,                "KLINE Status" },

    { BLF_OBJTYPE_CAN_FD_MESSAGE,                   "CANFD Message" },

    { BLF_OBJTYPE_CAN_FD_MESSAGE_64,                "CANFD Message 64" },

    { BLF_OBJTYPE_ETHERNET_RX_ERROR,                "Ethernet RX Error" },

    { BLF_OBJTYPE_ETHERNET_STATUS,                  "Ethernet Status" },

    { BLF_OBJTYPE_CAN_FD_ERROR_64,                  "CANFD Error 64" },

    { BLF_OBJTYPE_AFDX_STATUS,                      "AFDX Status" },

    { BLF_OBJTYPE_AFDX_BUS_STATISTIC,               "AFDX Bus Statistics" },

    { BLF_OBJTYPE_AFDX_ERROR_EVENT,                 "AFDX Error" },

    { BLF_OBJTYPE_A429_ERROR,                       "A429 Error" },

    { BLF_OBJTYPE_A429_STATUS,                      "A429 Status" },

    { BLF_OBJTYPE_A429_BUS_STATISTIC,               "A429 Bus Statistics" },

    { BLF_OBJTYPE_A429_MESSAGE,                     "A429 Message" },

    { BLF_OBJTYPE_ETHERNET_STATISTIC,               "Ethernet Statistics" },

    { BLF_OBJTYPE_TEST_STRUCTURE,                   "Test Structure" },

    { BLF_OBJTYPE_DIAG_REQUEST_INTERPRETATION,      "Diagnostics Request Interpretation" },

    { BLF_OBJTYPE_ETHERNET_FRAME_EX,                "Ethernet Frame Ext" },

    { BLF_OBJTYPE_ETHERNET_FRAME_FORWARDED,         "Ethernet Frame Forwarded" },

    { BLF_OBJTYPE_ETHERNET_ERROR_EX,                "Ethernet Error Ext" },

    { BLF_OBJTYPE_ETHERNET_ERROR_FORWARDED,         "Ethernet Error Forwarded" },

    { BLF_OBJTYPE_FUNCTION_BUS,                     "Function Bus" },

    { BLF_OBJTYPE_DATA_LOST_BEGIN,                  "Data Lost Begin" },

    { BLF_OBJTYPE_DATA_LOST_END,                    "Data Lost End" },

    { BLF_OBJTYPE_WATER_MARK_EVENT,                 "Watermark" },

    { BLF_OBJTYPE_TRIGGER_CONDITION,                "Trigger Condition" },

    { BLF_OBJTYPE_CAN_SETTING_CHANGED,              "CAN Settings Changed" },

    { BLF_OBJTYPE_DISTRIBUTED_OBJECT_MEMBER,        "Distributed Object Member" },

    { BLF_OBJTYPE_ATTRIBUTE_EVENT,                  "Attribute Event" },

    { BLF_OBJTYPE_DISTRIBUTED_OBJECT_CHANGE,        "Distributed Object Change" },

    { BLF_OBJTYPE_ETHERNET_PHY_STATE,               "Ethernet PHY State" },

    { BLF_OBJTYPE_MACSEC_STATUS,                    "MACsec Status" },

    { BLF_OBJTYPE_10BASET1S_STATUS,                 "10BASE-T1S Status" },

    { BLF_OBJTYPE_10BASET1S_STATISTIC,              "10BASE-T1S Statistic" },

    { BLF_OBJTYPE_TUNNEL_PROTO_DECODER_EVENT,       "Tunnel Protocol Decoder Event" },

    { BLF_OBJTYPE_CAN_XL_CHANNEL_FRAME,             "CAN XL Channel Frame" },

    { BLF_OBJTYPE_CAN_XL_CHANNEL_ERRORFRAME,        "CAN XL Channel Error" },

    { 0, NULL }

};

/* blf.c has the same table! */

static const value_string application_names[] = {

    { 0,    "Unknown" },

    { 1,    "Vector CANalyzer" },

    { 2,    "Vector CANoe" },

    { 3,    "Vector CANstress" },

    { 4,    "Vector CANlog" },

    { 5,    "Vector CANape" },

    { 6,    "Vector CANcaseXL log" },

    { 7,    "Vector Logger Configurator" },

    { 200,  "Porsche Logger" },

    { 201,  "CAETEC Logger" },

    { 202,  "Vector Network Simulator" },

    { 203,  "IPETRONIK logger" },

    { 204,  "RT PK" },

    { 205,  "PikeTec" },

    { 206,  "Sparks" },

    { 0, NULL }

};

#define BLF_COMPRESSION_NONE    0

#define BLF_COMPRESSION_ZLIB    2

static const value_string blf_compression_names[] = {

    { BLF_COMPRESSION_NONE,     "No Compression" },

    { BLF_COMPRESSION_ZLIB,     "Compression ZLIB" },

    { 0, NULL }

};

static const value_string blf_app_text_source_vals[] = {

    { 0,     "Measurement comment" },

    { 1,     "Database channel information" },

    { 2,     "Meta data" },

    { 3,     "Attachment" },

    { 4,     "Trace line" },

    { 0, NULL }

};

static const value_string blf_trigger_cond_state_vals[] = {

    { 0,     "Unknown" },

    { 1,     "Start" },

    { 2,     "Stop" },

    { 3,     "StartStop"},

    { 0, NULL }

};

static const value_string blf_sys_var_type_vals[] = {

    { 1,     "Double" },

    { 2,     "Long" },

    { 3,     "String"},

    { 4,     "DoubleArray"},

    { 5,     "LongArray"},

    { 6,     "LongLong"},

    { 7,     "ByteArray"},

    { 0, NULL }

};

static const value_string blf_eth_status_linkstatus_vals[] = {

    { 0,     "UnknownLinkStatus" },

    { 1,     "LinkDown" },

    { 2,     "LinkUp"},

    { 3,     "Negotiate"},

    { 4,     "LinkError"},

    { 0, NULL }

};

static const value_string blf_eth_status_ethernetphy_vals[] = {

    { 0,     "UnknownEthernetPhy" },

    { 1,     "Ieee802_3" },

    { 2,     "BroadR_Reach"},

    { 0, NULL }

};

static const value_string blf_eth_status_duplex_vals[] = {

    { 0,     "UnknownDuplex" },

    { 1,     "HalfDuplex" },

    { 2,     "FullDuplex"},

    { 0, NULL }

};

static const value_string blf_eth_status_mdi_vals[] = {

    { 0,     "UnknownMDI" },

    { 1,     "Direct" },

    { 2,     "Crossover"},

    { 0, NULL }

};

static const value_string blf_eth_status_connector_vals[] = {

    { 0,     "UnknownConnector" },

    { 1,     "RJ45" },

    { 2,     "D-sub"},

    { 0, NULL }

};

static const value_string blf_eth_status_clockmode_vals[] = {

    { 0,     "UnknownClockMode" },

    { 1,     "Master" },

    { 2,     "Slave"},

    { 0, NULL }

};

static const value_string blf_eth_status_pairs_vals[] = {

    { 0,     "UnknownPairs" },

    { 1,     "1" },

    { 2,     "2"},

    { 3,     "4"},

    { 0, NULL }

};

static const value_string blf_bustype_vals[] = {

    { BLF_BUSTYPE_CAN,      "CAN" },

    { BLF_BUSTYPE_LIN,      "LIN" },

    { BLF_BUSTYPE_MOST,     "MOST"},

    { BLF_BUSTYPE_FLEXRAY,  "FLEXRAY"},

    { BLF_BUSTYPE_J1708,    "J1708"},

    { BLF_BUSTYPE_ETHERNET, "ETHERNET"},

    { BLF_BUSTYPE_WLAN,     "WLAN"},

    { BLF_BUSTYPE_AFDX,     "AFDX"},

    { 0, NULL }

};

static const value_string blf_app_text_metadata_type_vals[] = {

    { 1,     "General" },

    { 2,     "Channels" },

    { 3,     "Identity" },

    { 0, NULL }

};

static const value_string hf_blf_app_text_traceline_source_vals[] = {

    { 0,     "Write to log" },

    { 1,     "Timer" },

    { 2,     "Write to X" },

    { 3,     "Node layer" },

    { 4,     "CAPL on board" },

    { 0, NULL }

};

static const value_string blf_eth_phystate_phystate_vals[] = {

    { 0,     "Invalid" },

    { 1,     "Normal" },

    { 2,     "Sleep"},

    { 3,     "PowerOff"},

    { 4,     "SleepRequest"},

    { 0, NULL }

};

static const value_string blf_eth_phystate_eventstate_vals[] = {

    { 0,     "Invalid" },

    { 1,     "SleepReceived" },

    { 2,     "SleepSent"},

    { 3,     "SleepAbort"},

    { 4,     "SleepAckReceived"},

    { 5,     "SleepForwarded"},

    { 8,     "WakeUpReceived"},

    { 9,     "WakeUpSent"},

    { 10,    "WakeUpForwarded"},

    { 17,    "PowerOff"},

    { 18,    "PowerOn"},

    { 25,    "Activated"},

    { 0, NULL }

};

static const value_string blf_direction[] = {

    { 0, "RX" },

    { 1, "TX" },

    { 0, NULL }

};

void proto_register_file_blf(void);

void proto_reg_handoff_file_blf(void);

static int dissect_blf_next_object(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, uint32_t *frame_number);

#define MAGIC_NUMBER_SIZE 4

static const uint8_t blf_file_magic[MAGIC_NUMBER_SIZE] = { 'L', 'O', 'G', 'G' };

static const uint8_t blf_lobj_magic[MAGIC_NUMBER_SIZE] = { 'L', 'O', 'B', 'J' };

static proto_item *

dissect_blf_header_date(proto_tree *tree, packet_info* pinfo, int hf, tvbuff_t *tvb, int offset, int length) {

    static const value_string weekday_names[] = {

    { 0,    "Sunday"},

    { 1,    "Monday"},

    { 2,    "Tuesday"},

    { 3,    "Wednesday"},

    { 4,    "Thursday"},

    { 5,    "Friday"},

    { 6,    "Saturday"},

    { 0, NULL }

    };

    nstime_t ns_ts;

    struct tm tm = { 0 };

    uint16_t year        = tvb_get_letohs(tvb, offset +  0);

    tm.tm_year = year;

    if (tm.tm_year != 0)

        tm.tm_year -= 1900;

    tm.tm_mon            = tvb_get_letohs(tvb, offset +  2);

    tm.tm_wday           = tvb_get_letohs(tvb, offset +  4);

    tm.tm_mday           = tvb_get_letohs(tvb, offset +  6);

    tm.tm_hour           = tvb_get_letohs(tvb, offset +  8);

    tm.tm_min            = tvb_get_letohs(tvb, offset + 10);

    tm.tm_sec            = tvb_get_letohs(tvb, offset + 12);

    tm.tm_isdst          = -1; // Let mktime() determine if DST is in effect

    uint16_t ms = tvb_get_letohs(tvb, offset + 14);

    ns_ts.secs = mktime(&tm);

    ns_ts.nsecs = ms * 1000000;

    return proto_tree_add_time_format_value(tree, hf, tvb, offset, length, &ns_ts,

                                            "%s %d-%02d-%02d %02d:%02d:%02d.%03d",

                                            val_to_str(pinfo->pool, tm.tm_mday, weekday_names, "%d"),

                                            year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, ms);

}

static void

version_format(char* string, uint32_t value)

{

    uint8_t patch = value % 100;

    value /= 100;

    uint8_t build = value % 100;

    value /= 100;

    uint8_t minor = value % 100;

    value /= 100;

    uint8_t major = value % 100;

    snprintf(string, ITEM_LABEL_LENGTH, "%d.%d.%d.%d", major, minor, build, patch);

}

static int

// NOLINTNEXTLINE(misc-no-recursion)

dissect_blf_lobj(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset_orig, uint32_t *frame_number) {

    proto_item    *ti_root = NULL;

    proto_item    *ti = NULL;

    proto_item    *ti_lobj_hdr;

    proto_tree    *objtree = NULL;

    proto_tree    *subtree = NULL;

    volatile int   offset = offset_orig;

    tvbuff_t      *sub_tvb;

    uint32_t       hdr_length;

    uint32_t       hdr_type;

    uint32_t       obj_length;

    unsigned       obj_type;

    uint32_t       comp_method;

    uint32_t       channel;

    /* this should never happen since we should only be called with at least 16 Bytes present */

    if (tvb_captured_length_remaining(tvb, offset_orig) < 16) {

        return tvb_captured_length_remaining(tvb, offset_orig);

    }

    ti_root = proto_tree_add_item(tree, hf_blf_lobj, tvb, offset, -1, ENC_NA);

    objtree = proto_item_add_subtree(ti_root, ett_blf_obj);

    ti_lobj_hdr = proto_tree_add_item(objtree, hf_blf_lobj_hdr, tvb, offset, -1, ENC_NA);

    subtree = proto_item_add_subtree(ti_lobj_hdr, ett_blf_obj_header);

    proto_tree_add_item(subtree, hf_blf_lobj_magic, tvb, offset, 4, ENC_NA);

    offset += 4;

    ti = proto_tree_add_item_ret_uint(subtree, hf_blf_lobj_hdr_len, tvb, offset, 2, ENC_LITTLE_ENDIAN, &hdr_length);

    if (hdr_length < sizeof (struct blf_blockheader)) {

        expert_add_info(pinfo, ti, &ei_blf_object_header_length_too_short);

    }

    offset += 2;

    proto_tree_add_item_ret_uint(subtree, hf_blf_lobj_hdr_type, tvb, offset, 2, ENC_LITTLE_ENDIAN, &hdr_type);

    offset += 2;

    ti = proto_tree_add_item_ret_uint(subtree, hf_blf_lobj_obj_len, tvb, offset, 4, ENC_LITTLE_ENDIAN, &obj_length);

    if (obj_length < hdr_length) {

        expert_add_info(pinfo, ti, &ei_blf_object_length_less_than_header_length);

    }

    offset += 4;

    proto_tree_add_item_ret_uint(subtree, hf_blf_lobj_obj_type, tvb, offset, 4, ENC_LITTLE_ENDIAN, &obj_type);

    offset += 4;

    if ((int)hdr_length > 16 && (hdr_type == 1 || hdr_type == 2)) {

        static int* const obj_header_flags[] = {

            &hf_blf_lobj_obj_flags_time_ten_ms,

            &hf_blf_lobj_obj_flags_time_one_ns,

            NULL

        };

        proto_tree_add_bitmask(subtree, tvb, offset, hf_blf_lobj_obj_flags, ett_blf_obj_header_flags, obj_header_flags, ENC_LITTLE_ENDIAN);

        offset += 4;

        if (hdr_type == 1) {

            proto_tree_add_item(subtree, hf_blf_lobj_client_index, tvb, offset, 2, ENC_LITTLE_ENDIAN);

        } else if (hdr_type == 2) {

            proto_tree_add_item(subtree, hf_blf_lobj_time_stamp_status, tvb, offset, 1, ENC_NA);

            proto_tree_add_item(subtree, hf_blf_lobj_reserved, tvb, offset + 1, 1, ENC_NA);

        }

        offset += 2;

        proto_tree_add_item(subtree, hf_blf_lobj_obj_version, tvb, offset, 2, ENC_LITTLE_ENDIAN);

        offset += 2;

        proto_tree_add_item(subtree, hf_blf_lobj_obj_timestamp, tvb, offset, 8, ENC_LITTLE_ENDIAN);

        offset += 8;

        if (hdr_type == 2) {

            proto_tree_add_item(subtree, hf_blf_lobj_org_timestamp, tvb, offset, 8, ENC_LITTLE_ENDIAN);

            offset += 8;

        }

    }

    if ((offset - offset_orig) - hdr_length > 0) {

        proto_tree_add_item(subtree, hf_blf_lobj_hdr_remains, tvb, offset, hdr_length - (offset - offset_orig), ENC_NA);

        offset = offset_orig + hdr_length;

    }

    proto_item_set_end(ti_lobj_hdr, tvb, offset);

    /* check if the whole object is present or if it was truncated */

    if (tvb_captured_length_remaining(tvb, offset_orig) < obj_length) {

        proto_item_set_end(ti_root, tvb, offset_orig + tvb_captured_length_remaining(tvb, offset_orig));

        proto_item_append_text(ti_root, " TRUNCATED");

        return tvb_captured_length_remaining(tvb, offset_orig);

    }

    proto_item_set_end(ti_root, tvb, offset_orig + obj_length);

    if (obj_type != BLF_OBJTYPE_LOG_CONTAINER) {

        proto_item_append_text(ti_root, " [%d] (%s)", *frame_number, val_to_str(pinfo->pool, obj_type, blf_object_names, "%d"));

        (*frame_number)++;

    } else {

        proto_item_append_text(ti_root, " (%s)", val_to_str(pinfo->pool, obj_type, blf_object_names, "%d"));

    }

    switch (obj_type) {

        case BLF_OBJTYPE_LOG_CONTAINER:

            proto_tree_add_item_ret_uint(objtree, hf_blf_cont_comp_method, tvb, offset, 2, ENC_LITTLE_ENDIAN, &comp_method);

            offset += 2;

            proto_tree_add_item(objtree, hf_blf_cont_res1, tvb, offset, 2, ENC_LITTLE_ENDIAN);

            offset += 2;

            proto_tree_add_item(objtree, hf_blf_cont_res2, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(objtree, hf_blf_cont_uncomp_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(objtree, hf_blf_cont_res4, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            if (comp_method == BLF_COMPRESSION_NONE) {

                sub_tvb = tvb_new_subset_length(tvb, offset, offset_orig + obj_length - offset);

            } else {

                sub_tvb = tvb_child_uncompress_zlib(tvb, tvb, offset, offset_orig + obj_length - offset);

                if (sub_tvb) {

                    add_new_data_source(pinfo, sub_tvb, "Decompressed Data");

                }

            }

            /* TODO: actually the objects might overlap containers, which we do not consider here... */

            if (sub_tvb && tvb_captured_length(sub_tvb) > 0) {

                unsigned offset_sub = 0;

                ti = proto_tree_add_item(objtree, hf_blf_cont_payload, sub_tvb, 0, offset_orig + obj_length - offset, ENC_NA);

                subtree = proto_item_add_subtree(ti, ett_blf_logcontainer_payload);

                unsigned tmp = 42;

                while ((offset_sub + 16 <= offset_orig + obj_length - offset) && (tmp > 0)) {

                    tmp = dissect_blf_next_object(sub_tvb, pinfo, subtree, offset_sub, frame_number);

                    offset_sub += tmp;

                }

            }

            break;

        case BLF_OBJTYPE_APP_TEXT:

        {

            uint32_t source;

            uint32_t remaining = 0;

            uint32_t textlength;

            ti = proto_tree_add_item(objtree, hf_blf_lobj_payload, tvb, offset, obj_length - hdr_length, ENC_NA);

            subtree = proto_item_add_subtree(ti, ett_blf_app_text_payload);

            proto_tree_add_item_ret_uint(subtree, hf_blf_app_text_source, tvb, offset, 4, ENC_LITTLE_ENDIAN, &source);

            offset += 4;

            /*uint32_t reservedAppText1 {};*/

            switch (source) {

            case BLF_APPTEXT_CHANNEL:

                /* 1: Database channel information

                 * - reserved contains channel information. The following

                 * - table show how the 4 bytes are used:

                 *   - Bit 0-7: Version of the data

                 *   - Bit 8-15: Channel number

                 *   - Bit 15-23: Bus type of the channel. One of the

                 *     following values:

                 *     - 1: BL_BUSTYPE_CAN

                 *     - 5: BL_BUSTYPE_LIN

                 *     - 6: BL_BUSTYPE_MOST

                 *     - 7: BL_BUSTYPE_FLEXRAY

                 *     - 9: BL_BUSTYPE_J1708

                 *     - 10: BL_BUSTYPE_ETHERNET

                 *     - 13: BL_BUSTYPE_WLAN

                 *     - 14: BL_BUSTYPE_AFDX

                 *   - Bit 24: Flag, that determines, if channel is a CAN-

                 *     FD channel

                 *   - Bit 25-31: Unused at the moment

                 * - text contains database information for the specific

                 *   channel. Each database is defined by the database path and

                 *   the cluster name (if available). The single databases and the

                 *   cluster name are separated by a semicolon. Example:

                 *   \<Path1\>;\<ClusterName1\>;\<Path2\>;\<ClusterName2\>;...

                 *   If for a database there's no cluster name available, an

                 *   empty string is written as cluster name.

                 */

                proto_tree_add_item(subtree, hf_blf_app_text_data_version, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                proto_tree_add_item_ret_uint(subtree, hf_blf_app_text_channelno, tvb, offset, 4, ENC_LITTLE_ENDIAN, &channel);

                proto_item_append_text(ti_root, " (Channel: %d)", channel);

                proto_tree_add_item(subtree, hf_blf_app_text_busstype, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                proto_tree_add_item(subtree, hf_blf_app_text_can_fd_channel, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                break;

            case BLF_APPTEXT_METADATA:

                proto_tree_add_item_ret_uint(subtree, hf_blf_app_text_metadata_remaining_length, tvb, offset, 4, ENC_LITTLE_ENDIAN, &remaining);

                proto_tree_add_item(subtree, hf_blf_app_text_metadata_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                break;

            case BLF_APPTEXT_TRACELINE:

                proto_tree_add_item(subtree, hf_blf_app_text_traceline_source, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                proto_tree_add_item(subtree, hf_blf_app_text_traceline_display_in_tracewindow, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                proto_tree_add_item(subtree, hf_blf_app_text_traceline_ascii_conversion_wo_comment_indicator_timestamp, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                break;

            default:

                proto_tree_add_item(subtree, hf_blf_app_text_reservedapptext1, tvb, offset, 4, ENC_LITTLE_ENDIAN);

                break;

            }

            offset += 4;

            /*uint32_t textLength {};*/

            proto_tree_add_item_ret_uint(subtree, hf_blf_app_text_textlength, tvb, offset, 4, ENC_LITTLE_ENDIAN, &textlength);

            offset += 4;

            /*uint32_t reservedAppText2 {};*/

            proto_tree_add_item(subtree, hf_blf_app_text_reservedapptext2, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            /* If there is less than 38 characters this is not XML

             * <?xml version="1.0" encoding="UTF-8"?>

             */

            if ((textlength > 37) && (tvb_strncaseeql(tvb, offset, "<?xml", 5) == 0) &&( xml_handle)) {

                tvbuff_t* new_tvb = tvb_new_subset_length(tvb, offset, textlength);

                call_dissector(xml_handle, new_tvb, pinfo, subtree);

            } else {

                proto_tree_add_item(subtree, hf_blf_app_text_text, tvb, offset, textlength, ENC_UTF_8|ENC_NA);

            }

            if (remaining != 0 && remaining > textlength) {

                /* This is not the final Meta Data packet, so we need to adjust */

                (*frame_number)--;

            }

        }

            break;

        case BLF_OBJTYPE_SYS_VARIABLE:

        {

            uint32_t namelength;

            uint32_t datalength;

            ti = proto_tree_add_item(objtree, hf_blf_lobj_payload, tvb, offset, obj_length - hdr_length, ENC_NA);

            subtree = proto_item_add_subtree(ti, ett_blf_obj_payload);

            /* uint32_t type {}; */

            proto_tree_add_item(subtree, hf_blf_sys_var_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            /* uint32_t representation {}; */

            proto_tree_add_item(subtree, hf_blf_sys_var_rep, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            /* uint64_t reservedSystemVariable1 {}; */

            proto_tree_add_item(subtree, hf_blf_sys_var_reservedsystemvariable1, tvb, offset, 8, ENC_LITTLE_ENDIAN);

            offset += 8;

            /* uint32_t nameLength {}; */

            proto_tree_add_item_ret_uint(subtree, hf_blf_sys_var_namelength, tvb, offset, 4, ENC_LITTLE_ENDIAN, &namelength);

            offset += 4;

            /* uint32_t dataLength {}; */

            proto_tree_add_item_ret_uint(subtree, hf_blf_sys_var_datalength, tvb, offset, 4, ENC_LITTLE_ENDIAN, &datalength);

            offset += 4;

            /* uint64_t reservedSystemVariable2 {}; */

            proto_tree_add_item(subtree, hf_blf_sys_var_reservedsystemvariable2, tvb, offset, 8, ENC_LITTLE_ENDIAN);

            offset += 8;

            proto_tree_add_item(subtree, hf_blf_sys_var_name, tvb, offset, namelength, ENC_UTF_8);

            offset += namelength;

            proto_tree_add_item(subtree, hf_blf_sys_var_data, tvb, offset, datalength, ENC_NA);

            offset += datalength;

        }

        break;

        case BLF_OBJTYPE_ETHERNET_STATUS:

        {

            static int* const flags1[] = {

                &hf_blf_eth_status_flags1_b9,

                &hf_blf_eth_status_flags1_b8,

                &hf_blf_eth_status_flags1_b7,

                &hf_blf_eth_status_flags1_b6,

                &hf_blf_eth_status_flags1_b5,

                &hf_blf_eth_status_flags1_b4,

                &hf_blf_eth_status_flags1_b3,

                &hf_blf_eth_status_flags1_b2,

                &hf_blf_eth_status_flags1_b1,

                &hf_blf_eth_status_flags1_b0,

                NULL

            };

            ti = proto_tree_add_item(objtree, hf_blf_lobj_payload, tvb, offset, obj_length - hdr_length, ENC_NA);

            subtree = proto_item_add_subtree(ti, ett_blf_obj_payload);

            /* uint16_t channel {}; */

            proto_tree_add_item_ret_uint(subtree, hf_blf_eth_status_channel, tvb, offset, 2, ENC_LITTLE_ENDIAN, &channel);

            proto_item_append_text(ti_root, " (Channel: %d)", channel);

            offset += 2;

            /* uint16_t flags; */

            proto_tree_add_bitmask_list(subtree, tvb, offset, 2, flags1, ENC_LITTLE_ENDIAN);

            offset += 2;

            /* uint8_t linkStatus {}; */

            proto_tree_add_item(subtree, hf_blf_eth_status_linkstatus, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            /* uint8_t ethernetPhy {};*/

            proto_tree_add_item(subtree, hf_blf_eth_status_ethernetphy, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            /* uint8_t duplex {}; */

            proto_tree_add_item(subtree, hf_blf_eth_status_duplex, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            /* uint8_t mdi {}; */

            proto_tree_add_item(subtree, hf_blf_eth_status_mdi, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            /* uint8_t connector {};*/

            proto_tree_add_item(subtree, hf_blf_eth_status_connector, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            /* uint8_t clockMode {}; */

            proto_tree_add_item(subtree, hf_blf_eth_status_clockmode, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            /* uint8_t pairs {}; */

            proto_tree_add_item(subtree, hf_blf_eth_status_pairs, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            /* uint8_t hardwareChannel {};*/

            proto_tree_add_item(subtree, hf_blf_eth_status_hardwarechannel, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            /* uint32_t bitrate {}; */

            proto_tree_add_item(subtree, hf_blf_eth_status_bitrate, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            if (offset_orig + obj_length - offset >= 8) {

                proto_tree_add_item(subtree, hf_blf_eth_status_linkupduration, tvb, offset, 8, ENC_LITTLE_ENDIAN);

            }

        }

            break;

        case BLF_OBJTYPE_ETHERNET_FRAME_EX:

        {

            ti = proto_tree_add_item(objtree, hf_blf_lobj_payload, tvb, offset, obj_length - hdr_length, ENC_NA);

            subtree = proto_item_add_subtree(ti, ett_blf_obj_payload);

            /* uint16_t structLength {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_structlength, tvb, offset, 2, ENC_LITTLE_ENDIAN);

            offset += 2;

            /* uint16_t flags {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_flags, tvb, offset, 2, ENC_LITTLE_ENDIAN);

            offset += 2;

            /* uint16_t channel {}; */

            proto_tree_add_item_ret_uint(subtree, hf_blf_eth_frame_ext_channel, tvb, offset, 2, ENC_LITTLE_ENDIAN, &channel);

            proto_item_append_text(ti_root, " (Channel: %d)", channel);

            offset += 2;

            /* uint16_t hardwareChannel {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_hardwarechannel, tvb, offset, 2, ENC_LITTLE_ENDIAN);

            offset += 2;

            /* uint64_t frameDuration {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_frameduration, tvb, offset, 8, ENC_LITTLE_ENDIAN);

            offset += 8;

            /* uint32_t frameChecksum {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_framechecksum, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            /* uint16_t dir {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_dir, tvb, offset, 2, ENC_LITTLE_ENDIAN);

            offset += 2;

            /* uint16_t frameLength {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_framelength, tvb, offset, 2, ENC_LITTLE_ENDIAN);

            offset += 2;

            /* uint32_t frameHandle {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_framehandle, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            /* uint32_t reservedEthernetFrameEx {}; */

            proto_tree_add_item(subtree, hf_blf_eth_frame_ext_reservedethernetframeex, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

        }

            break;

        case BLF_OBJTYPE_TRIGGER_CONDITION:

        {

            uint32_t triggerblocknamelength;

            uint32_t triggerconditionlength;

            ti = proto_tree_add_item(objtree, hf_blf_lobj_payload, tvb, offset, obj_length - hdr_length, ENC_NA);

            subtree = proto_item_add_subtree(ti, ett_blf_obj_payload);

            /* uint32_t state {}; */

            proto_tree_add_item(subtree, hf_blf_trigg_cond_state, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            /* uint32_t triggerBlockNameLength {}; */

            proto_tree_add_item_ret_uint(subtree, hf_blf_trigg_cond_triggerblocknamelength, tvb, offset, 4, ENC_LITTLE_ENDIAN,&triggerblocknamelength);

            offset += 4;

            /* uint32_t triggerConditionLength {};*/

            proto_tree_add_item_ret_uint(subtree, hf_blf_trigg_cond_triggerconditionlength, tvb, offset, 4, ENC_LITTLE_ENDIAN, &triggerconditionlength);

            offset += 4;

            /* std::string triggerBlockName {};*/

            proto_tree_add_item(subtree, hf_blf_trigg_cond_triggerblockname, tvb, offset, triggerblocknamelength, ENC_UTF_8 | ENC_NA);

            offset += triggerblocknamelength;

            /* std::string triggerCondition {};*/

            proto_tree_add_item(subtree, hf_blf_trigg_cond_triggercondition, tvb, offset, triggerconditionlength, ENC_UTF_8 | ENC_NA);

            offset += triggerconditionlength;

        }

            break;

        case BLF_OBJTYPE_ETHERNET_PHY_STATE:

        {

            static int* const flags1[] = {

                &hf_blf_eth_phy_state_flags1_b2,

                &hf_blf_eth_phy_state_flags1_b1,

                &hf_blf_eth_phy_state_flags1_b0,

                NULL

            };

            ti = proto_tree_add_item(objtree, hf_blf_lobj_payload, tvb, offset, obj_length - hdr_length, ENC_NA);

            subtree = proto_item_add_subtree(ti, ett_blf_obj_payload);

            /* uint16_t channel {}; */

            proto_tree_add_item_ret_uint(subtree, hf_blf_eth_phystate_channel, tvb, offset, 2, ENC_LITTLE_ENDIAN, &channel);

            proto_item_append_text(ti_root, " (Channel: %d)", channel);

            offset += 2;

            /* uint16_t flags; */

            proto_tree_add_bitmask_list(subtree, tvb, offset, 2, flags1, ENC_LITTLE_ENDIAN);

            offset += 2;

            /* uint8_t phyState {}; */

            proto_tree_add_item(subtree, hf_blf_eth_phy_state_phystate, tvb, offset, 1, ENC_NA);

            offset += 1;

            /* uint8_t eventState {}; */

            proto_tree_add_item(subtree, hf_blf_eth_phy_state_eventstate, tvb, offset, 1, ENC_NA);

            offset += 1;

            /* uint8_t hardwareChannel {}; */

            proto_tree_add_item(subtree, hf_blf_eth_phy_state_hardwarechannel, tvb, offset, 1, ENC_NA);

            offset += 1;

            /* uint8_t res1 {}; */

            proto_tree_add_item(subtree, hf_blf_eth_phy_state_res1, tvb, offset, 1, ENC_NA);

            offset += 1;

        }

            break;

        case BLF_OBJTYPE_CAN_XL_CHANNEL_FRAME:

        {

            ti = proto_tree_add_item(objtree, hf_blf_lobj_payload, tvb, offset, obj_length - hdr_length, ENC_NA);

            subtree = proto_item_add_subtree(ti, ett_blf_obj_payload);

            proto_tree_add_item_ret_uint(subtree, hf_blf_lobj_payload_channel_8bit, tvb, offset, 1, ENC_NA, &channel);

            proto_item_append_text(ti_root, " (Channel: %d)", channel);

            offset += 1;

            proto_tree_add_item(subtree, hf_blf_canxl_tx_count_number, tvb, offset, 1, ENC_NA);

            proto_tree_add_item(subtree, hf_blf_canxl_tx_count_attempts, tvb, offset, 1, ENC_NA);

            offset += 1;

            proto_tree_add_item(subtree, hf_blf_canxl_tx_dir, tvb, offset, 1, ENC_NA);

            offset += 1;