/builds/wireshark/wireshark/wiretap/blf.c

Bug Summary

File:	wiretap/blf.c
Warning:	line 3993, column 14 Potential leak of memory pointed to by 'newdata'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name blf.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-20/lib/clang/20 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -isystem /usr/include/libxml2 -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_BUILD_DLL -D WS_DEBUG -D WS_DEBUG_UTF_8 -D wiretap_EXPORTS -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/wiretap -I /builds/wireshark/wireshark/build/wiretap -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-20/lib/clang/20/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-truncation -Wno-format-nonliteral -Wno-pointer-sign -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /builds/wireshark/wireshark/sbout/2025-09-09-100415-3933-1 -x c /builds/wireshark/wireshark/wiretap/blf.c
1/* blf.c
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <[email protected]>
*
* File format support for the Binary Log File (BLF) file format from
* Vector Informatik decoder
* Copyright (c) 2021-2025 by Dr. Lars Völker <[email protected]>
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

/*
* 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.
*/

19#include <config.h>
20#define WS_LOG_DOMAIN"Wiretap" LOG_DOMAIN_WIRETAP"Wiretap"

22#include "blf.h"

24#include <epan/dissectors/packet-socketcan.h>
25#include <epan/dissectors/packet-flexray.h>
26#include <epan/dissectors/packet-lin.h>
27#include <string.h>
28#include <errno(*__errno_location ()).h>
29#include <wsutil/value_string.h>
30#include <wiretap/wtap.h>
31#include <wiretap/wtap_opttypes.h>
32#include <wsutil/wslog.h>
33#include <wsutil/exported_pdu_tlvs.h>
34#include <wsutil/pint.h>
35#include <wsutil/report_message.h>
36#include <wsutil/strtoi.h>
37#include <wsutil/time_util.h>
38#include <wsutil/zlib_compat.h>
39#include <wsutil/pint.h>
40#include <libxml/tree.h>
41#include <libxml/parser.h>
42#include <libxml/xpath.h>
43#include "file_wrappers.h"
44#include "wtap-int.h"

46static const uint8_t blf_magic[] = { 'L', 'O', 'G', 'G' };
47static const uint8_t blf_obj_magic[] = { 'L', 'O', 'B', 'J' };

49static int blf_file_type_subtype = -1;

51void register_blf(void);

53static bool_Bool blf_read(wtap *wth, wtap_rec *rec, int *err, char **err_info, int64_t *data_offset);
54static bool_Bool blf_seek_read(wtap *wth, int64_t seek_off, wtap_rec* rec, int *err, char **err_info);
55static void blf_close(wtap *wth);

57/*
* The virtual buffer looks like this (skips all headers):
* uncompressed log container data
* uncompressed log container data
* ...
*
* The "real" positions, length, etc. reference this layout and not the file.
*/
65typedef struct blf_log_container {
  int64_t  infile_start_pos;        /* start position of log container in file */
  uint64_t infile_length;           /* length of log container in file */
  uint64_t infile_data_start;       /* start position of data in log container in file */

  uint64_t real_start_pos;          /* decompressed (virtual) start position including header */
  uint64_t real_length;             /* decompressed length */

  uint16_t compression_method;      /* 0: uncompressed, 2: zlib */

  unsigned char  *real_data;        /* cache for decompressed data */
76} blf_log_container_t;

78typedef struct blf_data {
  int64_t     start_of_last_obj;
  int64_t     current_real_seek_pos;
  uint64_t    start_offset_ns;

  GArray     *log_containers;

  GHashTable *channel_to_iface_ht;
  GHashTable *channel_to_name_ht;
  uint32_t    next_interface_id;
88} blf_t;

90typedef struct blf_params {
  wtap     *wth;
  wtap_rec *rec;
  FILE_T    fh;
  bool_Bool      random;
  bool_Bool      pipe;

  blf_t    *blf_data;
98} blf_params_t;

100typedef struct blf_channel_to_iface_entry {
  int             pkt_encap;
  uint16_t        channel;
  uint16_t        hwchannel;
  uint32_t        interface_id;
105} blf_channel_to_iface_entry_t;

107typedef struct blf_metadata_info {
  size_t  metadata_cont;
  size_t  payload_start;
  bool_Bool    valid;
111} blf_metadata_info_t;

113static void
114blf_free_key(void *key) {
  g_free(key);
116}

118static void
119blf_free_channel_to_iface_entry(void *data) {
   g_free(data);
121}

123static void
124blf_free_channel_to_name_entry(void *data) {
  g_free(data);
126}

128static int64_t
129blf_calc_key_value(int pkt_encap, uint16_t channel, uint16_t hwchannel) {
  return (int64_t)(((uint64_t)pkt_encap << 32) | ((uint64_t)hwchannel << 16) | (uint64_t)channel);
131}

133/** Return the Epoch ns time of the capture start
*
* This is not intended to fully validate the date and time,
* but just to check if the values are plausible.
*/
138static uint64_t
139blf_get_start_offset_ns(const blf_date_t* start_date) {
  struct tm timestamp;
  time_t start_offset_s;

  if (start_date != NULL((void*)0) &&
      (start_date->month >= 1 && start_date->month <= 12) &&
      (start_date->day >= 1 && start_date->day <= 31) &&
      (start_date->hour <= 23) && (start_date->mins <= 59) &&
      (start_date->sec <= 61)  /* Apparently can be up to 61 on certain systems */
      ) { /* Not checking if milliseconds are actually less than 1000 */
      timestamp.tm_year = (start_date->year > 1970) ? start_date->year - 1900 : 70;
      timestamp.tm_mon = start_date->month - 1;
      timestamp.tm_mday = start_date->day;
      timestamp.tm_hour = start_date->hour;
      timestamp.tm_min = start_date->mins;
      timestamp.tm_sec = start_date->sec;
      timestamp.tm_isdst = -1;
      start_offset_s = mktime(&timestamp);
      if (start_offset_s >= 0) {
          return (1000 * 1000 * (start_date->ms + (1000 * (uint64_t)start_offset_s)));
      }
  }

  return 0;
163}

165static void add_interface_name(wtap_block_t int_data, int pkt_encap, uint16_t channel, uint16_t hwchannel, char *name) {
  if (name != NULL((void*)0)) {
      wtap_block_add_string_option_format(int_data, OPT_IDB_NAME2, "%s", name);
  } else {
      switch (pkt_encap) {
      case WTAP_ENCAP_ETHERNET1:
          /* we use UINT16_MAX to encode no hwchannel */
          if (hwchannel == UINT16_MAX(65535)) {
              wtap_block_add_string_option_format(int_data, OPT_IDB_NAME2, "ETH-%u", channel);
          } else {
              wtap_block_add_string_option_format(int_data, OPT_IDB_NAME2, "ETH-%u-%u", channel, hwchannel);
          }
          break;
      case WTAP_ENCAP_IEEE_802_1120:
          wtap_block_add_string_option_format(int_data, OPT_IDB_NAME2, "WLAN-%u", channel);
          break;
      case WTAP_ENCAP_FLEXRAY106:
          wtap_block_add_string_option_format(int_data, OPT_IDB_NAME2, "FR-%u", channel);
          break;
      case WTAP_ENCAP_LIN107:
          wtap_block_add_string_option_format(int_data, OPT_IDB_NAME2, "LIN-%u", channel);
          break;
      case WTAP_ENCAP_SOCKETCAN125:
          wtap_block_add_string_option_format(int_data, OPT_IDB_NAME2, "CAN-%u", channel);
          break;
      default:
          wtap_block_add_string_option_format(int_data, OPT_IDB_NAME2, "ENCAP_%d-%u", pkt_encap, channel);
      }
  }

  /* Add a defined description format to recover the original channel/hwchannel mapping, when we ever convert back to BLF */
  /* Changing the names might break the BLF writing! */
  switch (pkt_encap) {
  case WTAP_ENCAP_ETHERNET1:
      wtap_block_add_string_option_format(int_data, OPT_IDB_DESCRIPTION3, "BLF-ETH-0x%04x-0x%04x", channel, hwchannel);
      break;
  case WTAP_ENCAP_IEEE_802_1120:
      wtap_block_add_string_option_format(int_data, OPT_IDB_DESCRIPTION3, "BLF-WLAN-0x%04x", channel);
      break;
  case WTAP_ENCAP_FLEXRAY106:
      wtap_block_add_string_option_format(int_data, OPT_IDB_DESCRIPTION3, "BLF-FR-0x%04x", channel);
      break;
  case WTAP_ENCAP_LIN107:
      wtap_block_add_string_option_format(int_data, OPT_IDB_DESCRIPTION3, "BLF-LIN-0x%04x", channel);
      break;
  case WTAP_ENCAP_SOCKETCAN125:
      wtap_block_add_string_option_format(int_data, OPT_IDB_DESCRIPTION3, "BLF-CAN-0x%04x", channel);
      break;
  default:
      wtap_block_add_string_option_format(int_data, OPT_IDB_DESCRIPTION3, "BLF-ENCAP_%d-0x%04x-0x%04x", pkt_encap, channel, hwchannel);
  }
216}

218static uint32_t
219blf_add_interface(blf_params_t *params, int pkt_encap, uint32_t channel, uint16_t hwchannel, char *name) {
  wtap_block_t int_data = wtap_block_create(WTAP_BLOCK_IF_ID_AND_INFO);
  wtapng_if_descr_mandatory_t *if_descr_mand = (wtapng_if_descr_mandatory_t*)wtap_block_get_mandatory_data(int_data);
  blf_channel_to_iface_entry_t *item = NULL((void*)0);

  if_descr_mand->wtap_encap = pkt_encap;
  add_interface_name(int_data, pkt_encap, channel, hwchannel, name);
  /*
   * The time stamp resolution in these files can be per-record;
   * the maximum resolution is nanoseconds, so we specify that
   * as the interface's resolution.
   *
   * We set the resolution for a record on a per-record basis,
   * based on what the record specifies.
   */
  if_descr_mand->time_units_per_second = 1000 * 1000 * 1000;
  if_descr_mand->tsprecision = WTAP_TSPREC_NSEC9;
  wtap_block_add_uint8_option(int_data, OPT_IDB_TSRESOL9, 9);
  if_descr_mand->snap_len = WTAP_MAX_PACKET_SIZE_STANDARD262144U;
  if_descr_mand->num_stat_entries = 0;
  if_descr_mand->interface_statistics = NULL((void*)0);
  wtap_add_idb(params->wth, int_data);

  if (params->wth->file_encap == WTAP_ENCAP_NONE-2) {
      params->wth->file_encap = if_descr_mand->wtap_encap;
  } else {
      if (params->wth->file_encap != if_descr_mand->wtap_encap) {
          params->wth->file_encap = WTAP_ENCAP_PER_PACKET-1;
      }
  }

  int64_t *key = NULL((void*)0);
  key = g_new(int64_t, 1)((int64_t *) g_malloc_n ((1), sizeof (int64_t)));
  *key = blf_calc_key_value(pkt_encap, channel, hwchannel);

  item = g_new(blf_channel_to_iface_entry_t, 1)((blf_channel_to_iface_entry_t *) g_malloc_n ((1), sizeof (blf_channel_to_iface_entry_t
)));
  item->channel = channel;
  item->hwchannel = hwchannel;
  item->pkt_encap = pkt_encap;
  item->interface_id = params->blf_data->next_interface_id++;
  g_hash_table_insert(params->blf_data->channel_to_iface_ht, key, item);

  return item->interface_id;
262}

264/** This is used to save the interface name without creating it.
*
* This approach allows up to update the name of the interface
* up until the first captured packet.
*/
269static bool_Bool
270// NOLINTNEXTLINE(misc-no-recursion)
271blf_prepare_interface_name(blf_params_t* params, int pkt_encap, uint16_t channel, uint16_t hwchannel, const char* name, bool_Bool force_new_name) {
  int64_t key = blf_calc_key_value(pkt_encap, channel, hwchannel);
  char* old_name;
  char* new_name;
  char* iface_name;
  int64_t* new_key;
  bool_Bool ret;

  if (params->blf_data->channel_to_name_ht == NULL((void*)0)) {
      return false0;
  }

  old_name = (char *)g_hash_table_lookup(params->blf_data->channel_to_name_ht, &key);

  if (old_name != NULL((void*)0) && force_new_name) {
      if (!g_hash_table_remove(params->blf_data->channel_to_name_ht, &key)) {
          return false0;
      }

      old_name = NULL((void*)0);
  }

  if (old_name == NULL((void*)0) && name != NULL((void*)0)) {
      new_key = g_new(int64_t, 1)((int64_t *) g_malloc_n ((1), sizeof (int64_t)));
      *new_key = key;
      new_name = ws_strdup(name)wmem_strdup(((void*)0), name);
      if (!g_hash_table_insert(params->blf_data->channel_to_name_ht, new_key, new_name)) {
          return false0;
      }
  }
  else {
      new_name = old_name;
  }

  if (pkt_encap == WTAP_ENCAP_ETHERNET1) {
      /* Just for Ethernet, prepare the equivalent STATUS interface */
      iface_name = new_name != NULL((void*)0) ? ws_strdup_printf("STATUS-%s", new_name)wmem_strdup_printf(((void*)0), "STATUS-%s", new_name) : NULL((void*)0);

      // We recurse here once.
      ret = blf_prepare_interface_name(params, WTAP_ENCAP_WIRESHARK_UPPER_PDU155, channel, hwchannel, iface_name, force_new_name);
      if (iface_name) {
          g_free(iface_name);
      }
      if (!ret) {
          return false0;
      }
  }

  return true1;
320}

322static uint32_t
323blf_lookup_interface(blf_params_t *params, int pkt_encap, uint16_t channel, uint16_t hwchannel, char *name) {
  int64_t key = blf_calc_key_value(pkt_encap, channel, hwchannel);
  blf_channel_to_iface_entry_t* item;
  char* saved_name;
  uint32_t ret;

  if (params->blf_data->channel_to_iface_ht == NULL((void*)0)) {
      return 0;
  }

  item = (blf_channel_to_iface_entry_t *)g_hash_table_lookup(params->blf_data->channel_to_iface_ht, &key);

  if (item != NULL((void*)0)) {
      return item->interface_id;
  }
  else {
      saved_name = (char*)g_hash_table_lookup(params->blf_data->channel_to_name_ht, &key);

      if (saved_name != NULL((void*)0)) {
          ret = blf_add_interface(params, pkt_encap, channel, hwchannel, saved_name);
          g_hash_table_remove(params->blf_data->channel_to_name_ht, &key);

          return ret;
      }
      else {
          return blf_add_interface(params, pkt_encap, channel, hwchannel, name);
      }
  }
351}

353static void
354fix_endianness_blf_date(blf_date_t *date) {
  date->year = GUINT16_FROM_LE(date->year)(((guint16) (date->year)));
  date->month = GUINT16_FROM_LE(date->month)(((guint16) (date->month)));
  date->dayofweek = GUINT16_FROM_LE(date->dayofweek)(((guint16) (date->dayofweek)));
  date->day = GUINT16_FROM_LE(date->day)(((guint16) (date->day)));
  date->hour = GUINT16_FROM_LE(date->hour)(((guint16) (date->hour)));
  date->mins = GUINT16_FROM_LE(date->mins)(((guint16) (date->mins)));
  date->sec = GUINT16_FROM_LE(date->sec)(((guint16) (date->sec)));
  date->ms = GUINT16_FROM_LE(date->ms)(((guint16) (date->ms)));
363}

365static void
366fix_endianness_blf_fileheader(blf_fileheader_t *header) {
  header->header_length = GUINT32_FROM_LE(header->header_length)(((guint32) (header->header_length)));
  header->api_version = GUINT32_FROM_LE(header->api_version)(((guint32) (header->api_version)));
  header->len_compressed = GUINT64_FROM_LE(header->len_compressed)(((guint64) (header->len_compressed)));
  header->len_uncompressed = GUINT64_FROM_LE(header->len_uncompressed)(((guint64) (header->len_uncompressed)));
  header->obj_count = GUINT32_FROM_LE(header->obj_count)(((guint32) (header->obj_count)));
  header->application_build = GUINT32_FROM_LE(header->application_build)(((guint32) (header->application_build)));
  fix_endianness_blf_date(&(header->start_date));
  fix_endianness_blf_date(&(header->end_date));
  header->restore_point_offset = GUINT32_FROM_LE(header->restore_point_offset)(((guint32) (header->restore_point_offset)));
376}

378static void
379fix_endianness_blf_blockheader(blf_blockheader_t *header) {
  header->header_length = GUINT16_FROM_LE(header->header_length)(((guint16) (header->header_length)));
  header->header_type = GUINT16_FROM_LE(header->header_type)(((guint16) (header->header_type)));
  header->object_length = GUINT32_FROM_LE(header->object_length)(((guint32) (header->object_length)));
  header->object_type = GUINT32_FROM_LE(header->object_type)(((guint32) (header->object_type)));
384}

386static void
387fix_endianness_blf_logcontainerheader(blf_logcontainerheader_t *header) {
  header->compression_method = GUINT16_FROM_LE(header->compression_method)(((guint16) (header->compression_method)));
  header->res1 = GUINT16_FROM_LE(header->res1)(((guint16) (header->res1)));
  header->res2 = GUINT32_FROM_LE(header->res2)(((guint32) (header->res2)));
  header->uncompressed_size = GUINT32_FROM_LE(header->uncompressed_size)(((guint32) (header->uncompressed_size)));
  header->res4 = GUINT32_FROM_LE(header->res4)(((guint32) (header->res4)));
393}

395static void
396fix_endianness_blf_logobjectheader(blf_logobjectheader_t *header) {
  header->flags = GUINT32_FROM_LE(header->flags)(((guint32) (header->flags)));
  header->client_index = GUINT16_FROM_LE(header->client_index)(((guint16) (header->client_index)));
  header->object_version = GUINT16_FROM_LE(header->object_version)(((guint16) (header->object_version)));
  header->object_timestamp = GUINT64_FROM_LE(header->object_timestamp)(((guint64) (header->object_timestamp)));
401}

403static void
404fix_endianness_blf_logobjectheader2(blf_logobjectheader2_t *header) {
  header->flags = GUINT32_FROM_LE(header->flags)(((guint32) (header->flags)));
  header->object_version = GUINT16_FROM_LE(header->object_version)(((guint16) (header->object_version)));
  header->object_timestamp = GUINT64_FROM_LE(header->object_timestamp)(((guint64) (header->object_timestamp)));
  header->original_timestamp = GUINT64_FROM_LE(header->object_timestamp)(((guint64) (header->object_timestamp)));
409}

411static void
412fix_endianness_blf_logobjectheader3(blf_logobjectheader3_t *header) {
  header->flags = GUINT32_FROM_LE(header->flags)(((guint32) (header->flags)));
  header->static_size = GUINT16_FROM_LE(header->static_size)(((guint16) (header->static_size)));
  header->object_version = GUINT16_FROM_LE(header->object_version)(((guint16) (header->object_version)));
  header->object_timestamp = GUINT64_FROM_LE(header->object_timestamp)(((guint64) (header->object_timestamp)));
417}

419static void
420fix_endianness_blf_ethernetframeheader(blf_ethernetframeheader_t *header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->direction = GUINT16_FROM_LE(header->direction)(((guint16) (header->direction)));
  header->ethtype = GUINT16_FROM_LE(header->ethtype)(((guint16) (header->ethtype)));
  header->tpid = GUINT16_FROM_LE(header->tpid)(((guint16) (header->tpid)));
  header->tci = GUINT16_FROM_LE(header->tci)(((guint16) (header->tci)));
  header->payloadlength = GUINT16_FROM_LE(header->payloadlength)(((guint16) (header->payloadlength)));
427}

429static void
430fix_endianness_blf_ethernetframeheader_ex(blf_ethernetframeheader_ex_t *header) {
  header->struct_length = GUINT16_FROM_LE(header->struct_length)(((guint16) (header->struct_length)));
  header->flags = GUINT16_FROM_LE(header->flags)(((guint16) (header->flags)));
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->hw_channel = GUINT16_FROM_LE(header->hw_channel)(((guint16) (header->hw_channel)));
  header->frame_duration = GUINT64_FROM_LE(header->frame_duration)(((guint64) (header->frame_duration)));
  header->frame_checksum = GUINT32_FROM_LE(header->frame_checksum)(((guint32) (header->frame_checksum)));
  header->direction = GUINT16_FROM_LE(header->direction)(((guint16) (header->direction)));
  header->frame_length = GUINT16_FROM_LE(header->frame_length)(((guint16) (header->frame_length)));
  header->frame_handle = GUINT32_FROM_LE(header->frame_handle)(((guint32) (header->frame_handle)));
  header->error = GUINT32_FROM_LE(header->error)(((guint32) (header->error)));
441}

443static void
444fix_endianness_blf_ethernet_rxerror(blf_ethernet_rxerror_t* header) {
  header->struct_length = GUINT16_FROM_LE(header->struct_length)(((guint16) (header->struct_length)));
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->direction = GUINT16_FROM_LE(header->direction)(((guint16) (header->direction)));
  header->hw_channel = GUINT16_FROM_LE(header->hw_channel)(((guint16) (header->hw_channel)));
  header->frame_checksum = GUINT32_FROM_LE(header->frame_checksum)(((guint32) (header->frame_checksum)));
  header->frame_length = GUINT16_FROM_LE(header->frame_length)(((guint16) (header->frame_length)));
  header->error = GUINT32_FROM_LE(header->error)(((guint32) (header->error)));
452}

454static void
455fix_endianness_blf_wlanframeheader(blf_wlanframeheader_t* header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->flags = GUINT16_FROM_LE(header->flags)(((guint16) (header->flags)));
  header->signal_strength = GUINT16_FROM_LE(header->signal_strength)(((guint16) (header->signal_strength)));
  header->signal_quality = GUINT16_FROM_LE(header->signal_quality)(((guint16) (header->signal_quality)));
  header->frame_length = GUINT16_FROM_LE(header->frame_length)(((guint16) (header->frame_length)));
461}

463static void
464fix_endianness_blf_canmessage(blf_canmessage_t *header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->id = GUINT32_FROM_LE(header->id)(((guint32) (header->id)));
467}

469static void
470fix_endianness_blf_canmessage2_trailer(blf_canmessage2_trailer_t *header) {
  header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns)(((guint32) (header->frameLength_in_ns)));
  header->reserved2 = GUINT16_FROM_LE(header->reserved1)(((guint16) (header->reserved1)));
473}

475static void
476fix_endianness_blf_canfdmessage(blf_canfdmessage_t *header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->id = GUINT32_FROM_LE(header->id)(((guint32) (header->id)));
  header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns)(((guint32) (header->frameLength_in_ns)));
  header->reservedCanFdMessage2 = GUINT32_FROM_LE(header->reservedCanFdMessage2)(((guint32) (header->reservedCanFdMessage2)));
481}

483static void
484fix_endianness_blf_canfdmessage64(blf_canfdmessage64_t *header) {
  header->id = GUINT32_FROM_LE(header->id)(((guint32) (header->id)));
  header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns)(((guint32) (header->frameLength_in_ns)));
  header->flags = GUINT32_FROM_LE(header->flags)(((guint32) (header->flags)));
  header->btrCfgArb = GUINT32_FROM_LE(header->btrCfgArb)(((guint32) (header->btrCfgArb)));
  header->btrCfgData = GUINT32_FROM_LE(header->btrCfgData)(((guint32) (header->btrCfgData)));
  header->timeOffsetBrsNs = GUINT32_FROM_LE(header->timeOffsetBrsNs)(((guint32) (header->timeOffsetBrsNs)));
  header->timeOffsetCrcDelNs = GUINT32_FROM_LE(header->timeOffsetCrcDelNs)(((guint32) (header->timeOffsetCrcDelNs)));
  header->bitCount = GUINT16_FROM_LE(header->bitCount)(((guint16) (header->bitCount)));
  header->crc = GUINT32_FROM_LE(header->crc)(((guint32) (header->crc)));
494}

496static void
497fix_endianness_blf_canerror(blf_canerror_t *header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->length = GUINT16_FROM_LE(header->length)(((guint16) (header->length)));
500}

502static void
503fix_endianness_blf_canerrorext(blf_canerrorext_t *header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->length = GUINT16_FROM_LE(header->length)(((guint16) (header->length)));
  header->flags = GUINT32_FROM_LE(header->flags)(((guint32) (header->flags)));
  header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns)(((guint32) (header->frameLength_in_ns)));
  header->id = GUINT32_FROM_LE(header->id)(((guint32) (header->id)));
  header->errorCodeExt = GUINT16_FROM_LE(header->errorCodeExt)(((guint16) (header->errorCodeExt)));
510}

512static void
513fix_endianness_blf_canfderror64(blf_canfderror64_t *header) {
  header->flags = GUINT16_FROM_LE(header->flags)(((guint16) (header->flags)));
  header->errorCodeExt = GUINT16_FROM_LE(header->errorCodeExt)(((guint16) (header->errorCodeExt)));
  header->extFlags = GUINT16_FROM_LE(header->extFlags)(((guint16) (header->extFlags)));
  header->id = GUINT32_FROM_LE(header->id)(((guint32) (header->id)));
  header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns)(((guint32) (header->frameLength_in_ns)));
  header->btrCfgArb = GUINT32_FROM_LE(header->btrCfgArb)(((guint32) (header->btrCfgArb)));
  header->btrCfgData = GUINT32_FROM_LE(header->btrCfgData)(((guint32) (header->btrCfgData)));
  header->timeOffsetBrsNs = GUINT32_FROM_LE(header->timeOffsetBrsNs)(((guint32) (header->timeOffsetBrsNs)));
  header->timeOffsetCrcDelNs = GUINT32_FROM_LE(header->timeOffsetCrcDelNs)(((guint32) (header->timeOffsetCrcDelNs)));
  header->crc = GUINT32_FROM_LE(header->crc)(((guint32) (header->crc)));
  header->errorPosition = GUINT16_FROM_LE(header->errorPosition)(((guint16) (header->errorPosition)));
525}

527static void
528fix_endianness_blf_canxlchannelframe(blf_canxlchannelframe_t *header) {
  header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns)(((guint32) (header->frameLength_in_ns)));
  header->bitCount = GUINT16_FROM_LE(header->bitCount)(((guint16) (header->bitCount)));
  header->res2 = GUINT16_FROM_LE(header->res2)(((guint16) (header->res2)));
  header->frameIdentifier = GUINT32_FROM_LE(header->frameIdentifier)(((guint32) (header->frameIdentifier)));
  header->dlc = GUINT16_FROM_LE(header->dlc)(((guint16) (header->dlc)));
  header->dataLength = GUINT16_FROM_LE(header->dataLength)(((guint16) (header->dataLength)));
  header->stuffBitCount = GUINT16_FROM_LE(header->stuffBitCount)(((guint16) (header->stuffBitCount)));
  header->prefaceCRC = GUINT16_FROM_LE(header->prefaceCRC)(((guint16) (header->prefaceCRC)));
  header->acceptanceField = GUINT32_FROM_LE(header->acceptanceField)(((guint32) (header->acceptanceField)));
  header->res5 = GUINT16_FROM_LE(header->res5)(((guint16) (header->res5)));
  header->crc = GUINT32_FROM_LE(header->crc)(((guint32) (header->crc)));
  header->timeOffsetBrsNs = GUINT32_FROM_LE(header->timeOffsetBrsNs)(((guint32) (header->timeOffsetBrsNs)));
  header->timeOffsetCrcDelNs = GUINT32_FROM_LE(header->timeOffsetCrcDelNs)(((guint32) (header->timeOffsetCrcDelNs)));
  header->flags = GUINT32_FROM_LE(header->flags)(((guint32) (header->flags)));
  header->reserved = GUINT32_FROM_LE(header->reserved)(((guint32) (header->reserved)));
  header->arbitrationDataBitTimingConfig = GUINT64_FROM_LE(header->arbitrationDataBitTimingConfig)(((guint64) (header->arbitrationDataBitTimingConfig)));
  header->arbitrationDataHwChannelSettings = GUINT64_FROM_LE(header->arbitrationDataHwChannelSettings)(((guint64) (header->arbitrationDataHwChannelSettings)));
  header->fdPhaseBitTimingConfig = GUINT64_FROM_LE(header->fdPhaseBitTimingConfig)(((guint64) (header->fdPhaseBitTimingConfig)));
  header->fdPhaseHwChannelSettings = GUINT64_FROM_LE(header->fdPhaseHwChannelSettings)(((guint64) (header->fdPhaseHwChannelSettings)));
  header->xlPhaseBitTimingConfig = GUINT64_FROM_LE(header->xlPhaseBitTimingConfig)(((guint64) (header->xlPhaseBitTimingConfig)));
  header->xlPhaseHwChannelSettings = GUINT64_FROM_LE(header->xlPhaseHwChannelSettings)(((guint64) (header->xlPhaseHwChannelSettings)));
550}


553static void
554fix_endianness_blf_flexraydata(blf_flexraydata_t *header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->messageId = GUINT16_FROM_LE(header->messageId)(((guint16) (header->messageId)));
  header->crc = GUINT16_FROM_LE(header->crc)(((guint16) (header->crc)));
  header->reservedFlexRayData2 = GUINT16_FROM_LE(header->reservedFlexRayData2)(((guint16) (header->reservedFlexRayData2)));
559}

561static void
562fix_endianness_blf_flexraymessage(blf_flexraymessage_t *header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->fpgaTick = GUINT32_FROM_LE(header->fpgaTick)(((guint32) (header->fpgaTick)));
  header->fpgaTickOverflow = GUINT32_FROM_LE(header->fpgaTickOverflow)(((guint32) (header->fpgaTickOverflow)));
  header->clientIndexFlexRayV6Message = GUINT32_FROM_LE(header->clientIndexFlexRayV6Message)(((guint32) (header->clientIndexFlexRayV6Message)));
  header->clusterTime = GUINT32_FROM_LE(header->clusterTime)(((guint32) (header->clusterTime)));
  header->frameId = GUINT16_FROM_LE(header->frameId)(((guint16) (header->frameId)));
  header->headerCrc = GUINT16_FROM_LE(header->headerCrc)(((guint16) (header->headerCrc)));
  header->frameState = GUINT16_FROM_LE(header->frameState)(((guint16) (header->frameState)));
  header->reservedFlexRayV6Message2 = GUINT16_FROM_LE(header->reservedFlexRayV6Message2)(((guint16) (header->reservedFlexRayV6Message2)));
572}

574static void
575fix_endianness_blf_flexrayrcvmessage(blf_flexrayrcvmessage_t *header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->version = GUINT16_FROM_LE(header->version)(((guint16) (header->version)));
  header->channelMask = GUINT16_FROM_LE(header->channelMask)(((guint16) (header->channelMask)));
  header->dir = GUINT16_FROM_LE(header->dir)(((guint16) (header->dir)));
  header->clientIndex = GUINT32_FROM_LE(header->clientIndex)(((guint32) (header->clientIndex)));
  header->clusterNo = GUINT32_FROM_LE(header->clusterNo)(((guint32) (header->clusterNo)));
  header->frameId = GUINT16_FROM_LE(header->frameId)(((guint16) (header->frameId)));
  header->headerCrc1 = GUINT16_FROM_LE(header->headerCrc1)(((guint16) (header->headerCrc1)));
  header->headerCrc2 = GUINT16_FROM_LE(header->headerCrc2)(((guint16) (header->headerCrc2)));
  header->payloadLength = GUINT16_FROM_LE(header->payloadLength)(((guint16) (header->payloadLength)));
  header->payloadLengthValid = GUINT16_FROM_LE(header->payloadLengthValid)(((guint16) (header->payloadLengthValid)));
  header->cycle = GUINT16_FROM_LE(header->cycle)(((guint16) (header->cycle)));
  header->tag = GUINT32_FROM_LE(header->tag)(((guint32) (header->tag)));
  header->data = GUINT32_FROM_LE(header->data)(((guint32) (header->data)));
  header->frameFlags = GUINT32_FROM_LE(header->frameFlags)(((guint32) (header->frameFlags)));
  header->appParameter = GUINT32_FROM_LE(header->appParameter)(((guint32) (header->appParameter)));
592/*  this would be extra for ext format:
  header->frameCRC = GUINT32_FROM_LE(header->frameCRC);
  header->frameLengthInNs = GUINT32_FROM_LE(header->frameLengthInNs);
  header->frameId1 = GUINT16_FROM_LE(header->frameId1);
  header->pduOffset = GUINT16_FROM_LE(header->pduOffset);
  header->blfLogMask = GUINT16_FROM_LE(header->blfLogMask);
598*/
599}

601static void
602fix_endianness_blf_linmessage(blf_linmessage_t* message) {
  message->channel = GUINT16_FROM_LE(message->channel)(((guint16) (message->channel)));
  message->crc = GUINT16_FROM_LE(message->crc)(((guint16) (message->crc)));
605/*  skip the optional part
  message->res2 = GUINT32_FROM_LE(message->res2);
607*/
608}

610static void
611fix_endianness_blf_linbusevent(blf_linbusevent_t* linbusevent) {
  linbusevent->sof = GUINT64_FROM_LE(linbusevent->sof)(((guint64) (linbusevent->sof)));
  linbusevent->eventBaudrate = GUINT32_FROM_LE(linbusevent->eventBaudrate)(((guint32) (linbusevent->eventBaudrate)));
  linbusevent->channel = GUINT16_FROM_LE(linbusevent->channel)(((guint16) (linbusevent->channel)));
615}

617static void
618fix_endianness_blf_linsynchfieldevent(blf_linsynchfieldevent_t* linsynchfieldevent) {
  fix_endianness_blf_linbusevent(&linsynchfieldevent->linBusEvent);
  linsynchfieldevent->synchBreakLength = GUINT64_FROM_LE(linsynchfieldevent->synchBreakLength)(((guint64) (linsynchfieldevent->synchBreakLength)));
  linsynchfieldevent->synchDelLength = GUINT64_FROM_LE(linsynchfieldevent->synchDelLength)(((guint64) (linsynchfieldevent->synchDelLength)));
622}

624static void
625fix_endianness_blf_linmessagedescriptor(blf_linmessagedescriptor_t* linmessagedescriptor) {
  fix_endianness_blf_linsynchfieldevent(&linmessagedescriptor->linSynchFieldEvent);
  linmessagedescriptor->supplierId = GUINT16_FROM_LE(linmessagedescriptor->supplierId)(((guint16) (linmessagedescriptor->supplierId)));
  linmessagedescriptor->messageId = GUINT16_FROM_LE(linmessagedescriptor->messageId)(((guint16) (linmessagedescriptor->messageId)));
629}

631static void
632fix_endianness_blf_lindatabytetimestampevent(blf_lindatabytetimestampevent_t* lindatabytetimestampevent) {
  int i;
  fix_endianness_blf_linmessagedescriptor(&lindatabytetimestampevent->linMessageDescriptor);
  for (i = 0; i < 9; i++) {
      lindatabytetimestampevent->databyteTimestamps[i] = GUINT64_FROM_LE(lindatabytetimestampevent->databyteTimestamps[i])(((guint64) (lindatabytetimestampevent->databyteTimestamps
[i])));
  }
638}

640static void
641fix_endianness_blf_linmessage2(blf_linmessage2_t* message) {
  fix_endianness_blf_lindatabytetimestampevent(&message->linDataByteTimestampEvent);
  message->crc = GUINT16_FROM_LE(message->crc)(((guint16) (message->crc)));
644/*  skip the optional part
  message->respBaudrate = GUINT32_FROM_LE(message->respBaudrate);
  message->exactHeaderBaudrate = GUINT64_FROM_LE(message->exactHeaderBaudrate);
  message->earlyStopBitOffset = GUINT32_FROM_LE(message->earlyStopBitOffset);
  message->earlyStopBitOffsetResponse = GUINT32_FROM_LE(message->earlyStopBitOffsetResponse);
649*/
650}

652static void
653fix_endianness_blf_lincrcerror2(blf_lincrcerror2_t* message) {
  fix_endianness_blf_lindatabytetimestampevent(&message->linDataByteTimestampEvent);
  message->crc = GUINT16_FROM_LE(message->crc)(((guint16) (message->crc)));
656/*  skip the optional part
  message->respBaudrate = GUINT32_FROM_LE(message->respBaudrate);
  message->exactHeaderBaudrate = GUINT64_FROM_LE(message->exactHeaderBaudrate);
  message->earlyStopBitOffset = GUINT32_FROM_LE(message->earlyStopBitOffset);
  message->earlyStopBitOffsetResponse = GUINT32_FROM_LE(message->earlyStopBitOffsetResponse);
661*/
662}

664static void
665fix_endianness_blf_linrcverror2(blf_linrcverror2_t* message) {
  fix_endianness_blf_lindatabytetimestampevent(&message->linDataByteTimestampEvent);
667/*  skip the optional part
  message->respBaudrate = GUINT32_FROM_LE(message->respBaudrate);
  message->exactHeaderBaudrate = GUINT64_FROM_LE(message->exactHeaderBaudrate);
  message->earlyStopBitOffset = GUINT32_FROM_LE(message->earlyStopBitOffset);
  message->earlyStopBitOffsetResponse = GUINT32_FROM_LE(message->earlyStopBitOffsetResponse);
672*/
673}

675static void
676fix_endianness_blf_linsenderror2(blf_linsenderror2_t* message) {
  fix_endianness_blf_linmessagedescriptor(&message->linMessageDescriptor);
  message->eoh = GUINT64_FROM_LE(message->eoh)(((guint64) (message->eoh)));
679/*  skip the optional part
  message->exactHeaderBaudrate = GUINT64_FROM_LE(message->exactHeaderBaudrate);
  message->earlyStopBitOffset = GUINT32_FROM_LE(message->earlyStopBitOffset);
682*/
683}

685static void
686fix_endianness_blf_linwakeupevent2(blf_linwakeupevent2_t* message) {
  fix_endianness_blf_linbusevent(&message->linBusEvent);
688}

690static void
691fix_endianness_blf_apptext_header(blf_apptext_t *header) {
  header->source = GUINT32_FROM_LE(header->source)(((guint32) (header->source)));
  header->reservedAppText1 = GUINT32_FROM_LE(header->reservedAppText1)(((guint32) (header->reservedAppText1)));
  header->textLength = GUINT32_FROM_LE(header->textLength)(((guint32) (header->textLength)));
  header->reservedAppText2 = GUINT32_FROM_LE(header->reservedAppText2)(((guint32) (header->reservedAppText2)));
696}

698static void
699fix_endianness_blf_ethernet_status_header(blf_ethernet_status_t* header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->flags = GUINT16_FROM_LE(header->flags)(((guint16) (header->flags)));
  /*uint8_t linkStatus;*/
  /*uint8_t ethernetPhy;*/
  /*uint8_t duplex;*/
  /*uint8_t mdi;*/
  /*uint8_t connector;*/
  /*uint8_t clockMode;*/
  /*uint8_t pairs;*/
  /*uint8_t hardwareChannel;*/
  header->bitrate = GUINT32_FROM_LE(header->bitrate)(((guint32) (header->bitrate)));
711}

713static void
714fix_endianness_blf_ethernet_phystate_header(blf_ethernet_phystate_t* header) {
  header->channel = GUINT16_FROM_LE(header->channel)(((guint16) (header->channel)));
  header->flags = GUINT16_FROM_LE(header->flags)(((guint16) (header->flags)));
717}

719static void
720blf_init_logcontainer(blf_log_container_t *tmp) {
  tmp->infile_start_pos = 0;
  tmp->infile_length = 0;
  tmp->infile_data_start = 0;
  tmp->real_start_pos = 0;
  tmp->real_length = 0;
  tmp->real_data = NULL((void*)0);
  tmp->compression_method = 0;
728}

730int
731blf_logcontainers_cmp(const void *a, const void *b) {
  const blf_log_container_t* container_a = (blf_log_container_t*)a;
  const blf_log_container_t* container_b = (blf_log_container_t*)b;

  if (container_a->real_start_pos < container_b->real_start_pos) {
      return -1;
  }
  else if (container_a->real_start_pos > container_b->real_start_pos) {
      return 1;
  }
  else {
      return 0;
  }
744}

746int
747blf_logcontainers_search(const void *a, const void *b) {
  const blf_log_container_t* container_a = (blf_log_container_t*)a;
  uint64_t pos = *(uint64_t*)b;

  if (container_a->real_start_pos > pos) {
      return 1;
  }
  else if (pos >= container_a->real_start_pos + container_a->real_length) {
      return -1;
  }
  else {
      return 0;
  }
760}

762/** Ensures the given log container is in memory
*
* If the log container already is not already in memory,
* it reads it from the current seek position, allocating a
* properly sized buffer.
* The file offset must be set to the start of the container
* data (container->infile_data_start) before calling this function.
*/
770static bool_Bool
771blf_pull_logcontainer_into_memory(blf_params_t *params, blf_log_container_t *container, int *err, char **err_info) {

  if (container == NULL((void*)0)) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup("blf_pull_logcontainer_into_memory called with NULL container")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory called with NULL container"
);
      return false0;
  }

  if (container->real_data != NULL((void*)0)) {
      return true1;
  }

  /* pull compressed data into buffer */
  if (container->infile_start_pos < 0) {
      /*
       * XXX - does this represent a bug (WTAP_ERR_INTERNAL) or a
       * malformed file (WTAP_ERR_BAD_FILE)?
       */
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: container.infile_start_pos (%" PRId64 ") < 0",wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: container.infile_start_pos (%"
 "l" "d" ") < 0", container->infile_start_pos)
          container->infile_start_pos)wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: container.infile_start_pos (%"
 "l" "d" ") < 0", container->infile_start_pos);
      return false0;
  }
  if (container->infile_data_start < (uint64_t)container->infile_start_pos) {
      /*
       * XXX - does this represent a bug (WTAP_ERR_INTERNAL) or a
       * malformed file (WTAP_ERR_BAD_FILE)?
       */
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: container.infile_data_start (%" PRIu64 ") < container.infile_start_pos (%" PRId64 ")",wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: container.infile_data_start (%"
 "l" "u" ") < container.infile_start_pos (%" "l" "d" ")", container
->infile_data_start, container->infile_start_pos)
          container->infile_data_start, container->infile_start_pos)wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: container.infile_data_start (%"
 "l" "u" ") < container.infile_start_pos (%" "l" "d" ")", container
->infile_data_start, container->infile_start_pos);
      return false0;
  }
  if (container->infile_length < container->infile_data_start - (uint64_t)container->infile_start_pos) {
      /*
       * XXX - does this represent a bug (WTAP_ERR_INTERNAL) or a
       * malformed file (WTAP_ERR_BAD_FILE)?
       */
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: container.infile_length (%" PRIu64 ") < (container.infile_data_start (%" PRIu64 ") - container.infile_start_pos (%" PRId64 ")) = %" PRIu64,wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: container.infile_length (%"
 "l" "u" ") < (container.infile_data_start (%" "l" "u" ") - container.infile_start_pos (%"
 "l" "d" ")) = %" "l" "u", container->infile_length, container
->infile_data_start, container->infile_start_pos, container
->infile_data_start - (uint64_t)container->infile_start_pos
)
          container->infile_length,wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: container.infile_length (%"
 "l" "u" ") < (container.infile_data_start (%" "l" "u" ") - container.infile_start_pos (%"
 "l" "d" ")) = %" "l" "u", container->infile_length, container
->infile_data_start, container->infile_start_pos, container
->infile_data_start - (uint64_t)container->infile_start_pos
)
          container->infile_data_start, container->infile_start_pos,wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: container.infile_length (%"
 "l" "u" ") < (container.infile_data_start (%" "l" "u" ") - container.infile_start_pos (%"
 "l" "d" ")) = %" "l" "u", container->infile_length, container
->infile_data_start, container->infile_start_pos, container
->infile_data_start - (uint64_t)container->infile_start_pos
)
          container->infile_data_start - (uint64_t)container->infile_start_pos)wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: container.infile_length (%"
 "l" "u" ") < (container.infile_data_start (%" "l" "u" ") - container.infile_start_pos (%"
 "l" "d" ")) = %" "l" "u", container->infile_length, container
->infile_data_start, container->infile_start_pos, container
->infile_data_start - (uint64_t)container->infile_start_pos
);
      return false0;
  }
  uint64_t data_length = container->infile_length - (container->infile_data_start - (uint64_t)container->infile_start_pos);
  if (data_length > UINT_MAX(2147483647 *2U +1U)) {
      /*
       * XXX - does this represent a bug (WTAP_ERR_INTERNAL) or a
       * malformed file (WTAP_ERR_BAD_FILE)?
       */
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: data_length (%" PRIu64 ") > UINT_MAX",wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: data_length (%"
 "l" "u" ") > UINT_MAX", data_length)
          data_length)wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: data_length (%"
 "l" "u" ") > UINT_MAX", data_length);
      return false0;
  }

  if (container->real_length == 0) {
      ws_info("blf_pull_logcontainer_into_memory: found container with 0 length")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_INFO, ((void*)
0), -1, ((void*)0), "blf_pull_logcontainer_into_memory: found container with 0 length"
); } } while (0);
      /* Skip empty container */
      if (!wtap_read_bytes_or_eof(params->fh, NULL((void*)0), (unsigned int)data_length, err, err_info)) {
          if (*err == WTAP_ERR_SHORT_READ-12) {
              /*
               * XXX - our caller will turn this into an EOF.
               * How *should* it be treated?
               * For now, we turn it into Yet Another Internal Error,
               * pending having better documentation of the file
               * format.
               */
              *err = WTAP_ERR_INTERNAL-21;
              *err_info = ws_strdup("blf_pull_logcontainer_into_memory: short read on 0-length container")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: short read on 0-length container"
);
          }
          return false0;
      }
      return true1;
  }

  if (container->compression_method == BLF_COMPRESSION_NONE0) {
      unsigned char* buf = g_try_malloc((size_t)container->real_length);
      if (buf == NULL((void*)0)) {
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup("blf_pull_logcontainer_into_memory: cannot allocate memory")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: cannot allocate memory"
);
          return false0;
      }
      if (!wtap_read_bytes_or_eof(params->fh, buf, (unsigned int)data_length, err, err_info)) {
          g_free(buf);
          if (*err == WTAP_ERR_SHORT_READ-12) {
              /*
               * XXX - our caller will turn this into an EOF.
               * How *should* it be treated?
               * For now, we turn it into Yet Another Internal Error,
               * pending having better documentation of the file
               * format.
               */
              *err = WTAP_ERR_INTERNAL-21;
              *err_info = ws_strdup("blf_pull_logcontainer_into_memory: short read on uncompressed data")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: short read on uncompressed data"
);
          }
          return false0;
      }
      container->real_data = buf;
      return true1;

  }
  else if (container->compression_method == BLF_COMPRESSION_ZLIB2) {
875#ifdef USE_ZLIB_OR_ZLIBNG
      unsigned char *compressed_data = g_try_malloc((size_t)data_length);
      if (compressed_data == NULL((void*)0)) {
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup("blf_pull_logcontainer_into_memory: cannot allocate memory")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: cannot allocate memory"
);
          return false0;
      }
      if (!wtap_read_bytes_or_eof(params->fh, compressed_data, (unsigned int)data_length, err, err_info)) {
          g_free(compressed_data);
          if (*err == WTAP_ERR_SHORT_READ-12) {
              /*
               * XXX - our caller will turn this into an EOF.
               * How *should* it be treated?
               * For now, we turn it into Yet Another Internal Error,
               * pending having better documentation of the file
               * format.
               */
              *err = WTAP_ERR_INTERNAL-21;
              *err_info = ws_strdup("blf_pull_logcontainer_into_memory: short read on compressed data")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: short read on compressed data"
);
          }
          return false0;
      }

      unsigned char *buf = g_try_malloc((size_t)container->real_length);
      if (buf == NULL((void*)0)) {
          g_free(compressed_data);
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup("blf_pull_logcontainer_into_memory: cannot allocate memory")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: cannot allocate memory"
);
          return false0;
      }
      zlib_stream infstream = {0};

      infstream.avail_in  = (unsigned int)data_length;
      infstream.next_in   = compressed_data;
      infstream.avail_out = (unsigned int)container->real_length;
      infstream.next_out  = buf;

      /* the actual DE-compression work. */
      if (Z_OK0 != ZLIB_PREFIX(inflateInit)(&infstream)inflateInit_((&infstream), "1.3", (int)sizeof(z_stream))) {
          /*
           * XXX - check the error code and handle this appropriately.
           */
          g_free(buf);
          g_free(compressed_data);
          *err = WTAP_ERR_INTERNAL-21;
          if (infstream.msg != NULL((void*)0)) {
              *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: inflateInit failed for LogContainer, message\"%s\"",wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: inflateInit failed for LogContainer, message\"%s\""
, infstream.msg)
                                            infstream.msg)wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: inflateInit failed for LogContainer, message\"%s\""
, infstream.msg);
          } else {
              *err_info = ws_strdup("blf_pull_logcontainer_into_memory: inflateInit failed for LogContainer")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: inflateInit failed for LogContainer"
);
          }
          ws_debug("inflateInit failed for LogContainer")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 926, __func__, "inflateInit failed for LogContainer"); } } while
 (0);
          if (infstream.msg != NULL((void*)0)) {
              ws_debug("inflateInit returned: \"%s\"", infstream.msg)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 928, __func__, "inflateInit returned: \"%s\"", infstream.msg
); } } while (0);
          }
          return false0;
      }

      int ret = ZLIB_PREFIX(inflate)inflate(&infstream, Z_NO_FLUSH0);
      /* Z_OK should not happen here since we know how big the buffer should be */
      if (Z_STREAM_END1 != ret) {
          switch (ret) {

          case Z_NEED_DICT2:
              *err = WTAP_ERR_DECOMPRESS-20;
              *err_info = ws_strdup("preset dictionary needed")wmem_strdup(((void*)0), "preset dictionary needed");
              break;

          case Z_STREAM_ERROR(-2):
              *err = WTAP_ERR_INTERNAL-21;
              *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: Z_STREAM_ERROR from inflate(), message \"%s\"",wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: Z_STREAM_ERROR from inflate(), message \"%s\""
, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)")
                                           (infstream.msg != NULL) ? infstream.msg : "(none)")wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: Z_STREAM_ERROR from inflate(), message \"%s\""
, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)");
              break;

          case Z_MEM_ERROR(-4):
              /* This means "not enough memory". */
              *err = ENOMEM12;
              *err_info = NULL((void*)0);
              break;

          case Z_DATA_ERROR(-3):
              /* This means "deflate stream invalid" */
              *err = WTAP_ERR_DECOMPRESS-20;
              *err_info = (infstream.msg != NULL((void*)0)) ? ws_strdup(infstream.msg)wmem_strdup(((void*)0), infstream.msg) : NULL((void*)0);
              break;

          case Z_BUF_ERROR(-5):
              /* XXX - this is recoverable; what should we do here? */
              *err = WTAP_ERR_INTERNAL-21;
              *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: Z_BUF_ERROR from inflate(), message \"%s\"",wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: Z_BUF_ERROR from inflate(), message \"%s\""
, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)")
                                           (infstream.msg != NULL) ? infstream.msg : "(none)")wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: Z_BUF_ERROR from inflate(), message \"%s\""
, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)");
              break;

          case Z_VERSION_ERROR(-6):
              *err = WTAP_ERR_INTERNAL-21;
              *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: Z_VERSION_ERROR from inflate(), message \"%s\"",wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: Z_VERSION_ERROR from inflate(), message \"%s\""
, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)")
                                           (infstream.msg != NULL) ? infstream.msg : "(none)")wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: Z_VERSION_ERROR from inflate(), message \"%s\""
, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)");
              break;

          default:
              *err = WTAP_ERR_INTERNAL-21;
              *err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: unexpected error %d from inflate(), message \"%s\"",wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: unexpected error %d from inflate(), message \"%s\""
, ret, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)"
)
                                           ret,wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: unexpected error %d from inflate(), message \"%s\""
, ret, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)"
)
                                           (infstream.msg != NULL) ? infstream.msg : "(none)")wmem_strdup_printf(((void*)0), "blf_pull_logcontainer_into_memory: unexpected error %d from inflate(), message \"%s\""
, ret, (infstream.msg != ((void*)0)) ? infstream.msg : "(none)"
);
              break;
          }
          g_free(buf);
          g_free(compressed_data);
          ws_debug("inflate failed (return code %d) for LogContainer", ret)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 983, __func__, "inflate failed (return code %d) for LogContainer"
, ret); } } while (0);
          if (infstream.msg != NULL((void*)0)) {
              ws_debug("inflate returned: \"%s\"", infstream.msg)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 985, __func__, "inflate returned: \"%s\"", infstream.msg); }
 } while (0);
          }
          /* Free up any dynamically-allocated memory in infstream */
          ZLIB_PREFIX(inflateEnd)inflateEnd(&infstream);
          return false0;
      }

      if (Z_OK0 != ZLIB_PREFIX(inflateEnd)inflateEnd(&infstream)) {
          /*
           * The zlib manual says this only returns Z_OK on success
           * and Z_STREAM_ERROR if the stream state was inconsistent.
           *
           * It's not clear what useful information can be reported
           * for Z_STREAM_ERROR; a look at the 1.2.11 source indicates
           * that no string is returned to indicate what the problem
           * was.
           *
           * It's also not clear what to do about infstream if this
           * fails.
           */
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup("blf_pull_logcontainer_into_memory: inflateEnd failed for LogContainer")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: inflateEnd failed for LogContainer"
);
          g_free(buf);
          g_free(compressed_data);
          ws_debug("inflateEnd failed for LogContainer")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1009, __func__, "inflateEnd failed for LogContainer"); } } while
 (0);
          if (infstream.msg != NULL((void*)0)) {
              ws_debug("inflateEnd returned: \"%s\"", infstream.msg)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1011, __func__, "inflateEnd returned: \"%s\"", infstream.msg
); } } while (0);
          }
          return false0;
      }

      g_free(compressed_data);
      container->real_data = buf;
      return true1;
1019#else /* USE_ZLIB_OR_ZLIBNG */
      (void) params;
      *err = WTAP_ERR_DECOMPRESSION_NOT_SUPPORTED-26;
      *err_info = ws_strdup("blf_pull_logcontainer_into_memory: reading gzip-compressed containers isn't supported")wmem_strdup(((void*)0), "blf_pull_logcontainer_into_memory: reading gzip-compressed containers isn't supported"
);
      return false0;
1024#endif /* USE_ZLIB_OR_ZLIBNG */
  }

  return false0;
1028}

1030/** Finds the next log container starting at the current file offset
*
* Adds the container to the containers array for later access
*/
1034static bool_Bool
1035blf_find_next_logcontainer(blf_params_t* params, int* err, char** err_info) {
  blf_blockheader_t           header;
  blf_logcontainerheader_t    logcontainer_header;
  blf_log_container_t         tmp;
  unsigned char*              header_ptr;
  unsigned int                i;

  uint64_t current_real_start;
  if (params->blf_data->log_containers->len == 0) {
      current_real_start = 0;
  }
  else {
      const blf_log_container_t* container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, params->blf_data->log_containers->len - 1)(((blf_log_container_t*) (void *) (params->blf_data->log_containers
)->data) [(params->blf_data->log_containers->len -
 1)]);
      current_real_start = container->real_start_pos + container->real_length;
  }

  header_ptr = (unsigned char*)&header;
  i = 0;

  /** Find Object
   *
   * We read one byte at a time so that we don't have to seek backward (allows us to do a linear read)
   */
  while (i < sizeof(blf_obj_magic)) {
      if (!wtap_read_bytes_or_eof(params->fh, &header_ptr[i], 1, err, err_info)) {
          ws_debug("we found end of file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1060, __func__, "we found end of file"); } } while (0);
          return false0;
      }
      if (header_ptr[i] != blf_obj_magic[i]) {
          if (params->pipe) {
              ws_debug("container object magic is not LOBJ")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1065, __func__, "container object magic is not LOBJ"); } } while
 (0);
          }
          else {
              ws_debug("container object magic is not LOBJ (pos: 0x%" PRIx64 ")", file_tell(params->fh) - 1)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1068, __func__, "container object magic is not LOBJ (pos: 0x%"
 "l" "x" ")", file_tell(params->fh) - 1); } } while (0);
          }
          if (i > 0) {
              int j = i;

              while (memcmp(&header_ptr[i - j + 1], blf_obj_magic, j)) {
                  /* Check if the last j bytes match the first j bytes of the magic */
                  j--;
              }

              /* The last j bytes match, and the first j bytes are already in the buffer, since j<=i */
              i = j;
          }
      }
      else {
          /* Character matches */
          i++;
      }
  }

  if (!wtap_read_bytes_or_eof(params->fh, &header.header_length, sizeof(blf_blockheader_t) - sizeof(blf_obj_magic), err, err_info)) {
      ws_debug("we found end of file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1089, __func__, "we found end of file"); } } while (0);
      return false0;
  }

  fix_endianness_blf_blockheader(&header);

  if (header.header_length < sizeof(blf_blockheader_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: header length too short while looking for object")wmem_strdup(((void*)0), "blf: header length too short while looking for object"
);
      return false0;
  }

  if (header.header_type != BLF_HEADER_TYPE_DEFAULT1) {
      *err = WTAP_ERR_UNSUPPORTED-4;
      *err_info = ws_strdup_printf("blf: unknown header type (%u), I know only BLF_HEADER_TYPE_DEFAULT (1)", header.header_type)wmem_strdup_printf(((void*)0), "blf: unknown header type (%u), I know only BLF_HEADER_TYPE_DEFAULT (1)"
, header.header_type);
      return false0;
  }

  if (header.object_length < header.header_length) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: header object length less than header length while looking for objects")wmem_strdup(((void*)0), "blf: header object length less than header length while looking for objects"
);
      return false0;
  }

  if (header.object_type == BLF_OBJTYPE_LOG_CONTAINER10) {
      /* skip unknown header part if needed */
      if (header.header_length > sizeof(blf_blockheader_t)) {
          /* seek over unknown header part */
          if (!wtap_read_bytes(params->fh, NULL((void*)0), header.header_length - sizeof(blf_blockheader_t), err, err_info)) {
              ws_debug("error skipping unknown header bytes in log container")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1118, __func__, "error skipping unknown header bytes in log container"
); } } while (0);
              return false0;
          }
      }

      /* Read the log container header */
      if (!wtap_read_bytes_or_eof(params->fh, &logcontainer_header, sizeof(blf_logcontainerheader_t), err, err_info)) {
          ws_debug("not enough bytes for log container header")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1125, __func__, "not enough bytes for log container header"
); } } while (0);
          return false0;
      }

      fix_endianness_blf_logcontainerheader(&logcontainer_header);

      blf_init_logcontainer(&tmp);

      if (params->pipe) {
          tmp.infile_start_pos = 0;
          tmp.infile_data_start = sizeof(blf_logcontainerheader_t) + header.header_length;
      }
      else {
          tmp.infile_data_start = file_tell(params->fh);
          tmp.infile_start_pos = tmp.infile_data_start - sizeof(blf_logcontainerheader_t) - header.header_length;
      }
      tmp.infile_length = header.object_length;

      tmp.real_start_pos = current_real_start;
      tmp.real_length = logcontainer_header.uncompressed_size;
      tmp.compression_method = logcontainer_header.compression_method;

      ws_debug("found log container with real_pos=0x%" PRIx64 ", real_length=0x%" PRIx64, tmp.real_start_pos, tmp.real_length)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1147, __func__, "found log container with real_pos=0x%" "l"
 "x" ", real_length=0x%" "l" "x", tmp.real_start_pos, tmp.real_length
); } } while (0);
  }
  else {
      ws_debug("found BLF object without log container")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1150, __func__, "found BLF object without log container"); }
 } while (0);

      /* Create a fake log container for the lone object.
       * In order to avoid seeking backwards, we need to pull the fake log container now.
       */
      unsigned char* buf = g_try_malloc((size_t)header.object_length);
      if (buf == NULL((void*)0)) {
          /*
           * XXX - we need an "out of memory" error code here.
           */
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup("blf_find_next_logcontainer: cannot allocate memory")wmem_strdup(((void*)0), "blf_find_next_logcontainer: cannot allocate memory"
);
          return false0;
      }

      memcpy(buf, &header, sizeof(blf_blockheader_t));

      if (header.object_length > sizeof(blf_blockheader_t)) {
          if (!wtap_read_bytes(params->fh, buf + sizeof(blf_blockheader_t), header.object_length - sizeof(blf_blockheader_t), err, err_info)) {
              g_free(buf);
              ws_debug("cannot pull object without log container")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1170, __func__, "cannot pull object without log container")
; } } while (0);
              return false0;
          }
      }

      blf_init_logcontainer(&tmp);

      tmp.infile_start_pos = params->pipe ? 0 : (file_tell(params->fh) - header.object_length);
      tmp.infile_data_start = tmp.infile_start_pos;
      tmp.infile_length = header.object_length;

      tmp.real_start_pos = current_real_start;
      tmp.real_length = header.object_length;
      tmp.compression_method = BLF_COMPRESSION_NONE0;

      tmp.real_data = buf;

      ws_debug("found non-log-container object with real_pos=0x%" PRIx64 ", real_length=0x%" PRIx64, tmp.real_start_pos, tmp.real_length)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1187, __func__, "found non-log-container object with real_pos=0x%"
 "l" "x" ", real_length=0x%" "l" "x", tmp.real_start_pos, tmp
.real_length); } } while (0);
  }

  g_array_append_val(params->blf_data->log_containers, tmp)g_array_append_vals (params->blf_data->log_containers, &
(tmp), 1);

  return true1;
1193}

1195static bool_Bool
1196// NOLINTNEXTLINE(misc-no-recursion)
1197blf_pull_next_logcontainer(blf_params_t* params, int* err, char** err_info) {
  blf_log_container_t* container;

  if (!blf_find_next_logcontainer(params, err, err_info)) {
      return false0;
  }

  /* Is there a next log container to pull? */
  if (params->blf_data->log_containers->len == 0) {
      /* No. */
      return false0;
  }

  container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, params->blf_data->log_containers->len - 1)(((blf_log_container_t*) (void *) (params->blf_data->log_containers
)->data) [(params->blf_data->log_containers->len -
 1)]);
  if (!blf_pull_logcontainer_into_memory(params, container, err, err_info)) {
      if (*err == WTAP_ERR_DECOMPRESS-20) {
          report_warning("Error while decompressing BLF log container number %u (file pos. 0x%" PRIx64"l" "x" "): %s",
                          params->blf_data->log_containers->len - 1, container->infile_start_pos, *err_info ? *err_info : "(none)");
          *err = 0;
          g_free(*err_info);
          *err_info = NULL((void*)0);

          /* Skip this log container and try to get the next one. */
          g_array_remove_index(params->blf_data->log_containers, params->blf_data->log_containers->len - 1);
          /* Calling blf_pull_logcontainer_into_memory advances the file pointer. Eventually we will reach the end of the file and stop recursing. */
          return blf_pull_next_logcontainer(params, err, err_info);
      }

      return false0;
  }

  return true1;
1229}

1231static bool_Bool
1232blf_read_bytes_or_eof(blf_params_t *params, uint64_t real_pos, void *target_buffer, uint64_t count, int *err, char **err_info) {
  blf_log_container_t*    container;
  unsigned container_index;

  uint64_t end_pos = real_pos + count;

  uint64_t copied = 0;
  uint64_t data_left;
  uint64_t start_in_buf;

  unsigned char *buf = (unsigned char *)target_buffer;

  if (count == 0) {
      ws_debug("called blf_read_bytes_or_eof with 0 count")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1245, __func__, "called blf_read_bytes_or_eof with 0 count"
); } } while (0);
      return false0;
  }

  if (count > UINT32_MAX(4294967295U)) {
      ws_debug("trying to read too many bytes")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1250, __func__, "trying to read too many bytes"); } } while
 (0);
      return false0;
  }

  if (params->random) {
      /*
       * Do a binary search for the container in which real_pos
       * is included.
       */
      if (!g_array_binary_search(params->blf_data->log_containers, &real_pos, blf_logcontainers_search, &container_index)) {
          /*
           * XXX - why is this treated as an EOF rather than an error?
           * *err appears to be 0, which means our caller treats it as an
           * EOF, at least when reading the log object header.
           */
          ws_debug("cannot read data because start position cannot be mapped")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1265, __func__, "cannot read data because start position cannot be mapped"
); } } while (0);
          return false0;
      }
      container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, container_index)(((blf_log_container_t*) (void *) (params->blf_data->log_containers
)->data) [(container_index)]);
  }
  else {
      if (params->blf_data->log_containers->len == 0) {
          /*
           * This is the first (linear) pass, and we haven't yet
           * added any containers.  Pull the next log container
           * into memory, so that the array isn't empty.
           */
          if (!blf_pull_next_logcontainer(params, err, err_info)) {
              return false0;
          }
      }

      /*
       * Search backwards in the array, from the last entry to the
       * first, to find the log container in which real_pos is
       * included.
       */
      container_index = params->blf_data->log_containers->len;
      do {
          container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, --container_index)(((blf_log_container_t*) (void *) (params->blf_data->log_containers
)->data) [(--container_index)]);
      } while (real_pos < container->real_start_pos && container_index > 0);  /* For some reason we skipped past the correct container */
  }

  while (real_pos < end_pos) {

      while (real_pos >= container->real_start_pos + container->real_length) {
          container_index++;
          if (!params->random) {  /* First (linear) pass */
              if (!blf_pull_next_logcontainer(params, err, err_info)) {
                  return false0;
              }
          }
          if (container_index >= params->blf_data->log_containers->len) {
              ws_debug("cannot find real_pos in container")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1303, __func__, "cannot find real_pos in container"); } } while
 (0);
              return false0;
          }
          container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, container_index)(((blf_log_container_t*) (void *) (params->blf_data->log_containers
)->data) [(container_index)]);
          if (real_pos < container->real_start_pos) {
              ws_debug("cannot find real_pos in container")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1308, __func__, "cannot find real_pos in container"); } } while
 (0);
              return false0;
          }
      }

      if (real_pos < container->real_start_pos) {
          ws_debug("cannot find real_pos in container")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1314, __func__, "cannot find real_pos in container"); } } while
 (0);
          return false0;
      }

      start_in_buf = real_pos - container->real_start_pos;

      if (params->random) {
          if (file_seek(params->fh, container->infile_data_start, SEEK_SET0, err) == -1) {
              return false0;
          }
          if (!blf_pull_logcontainer_into_memory(params, container, err, err_info)) {
              return false0;
          }
      }

      data_left = container->real_length - start_in_buf;

      if (data_left < (count - copied)) {
          memcpy(buf + copied, container->real_data + start_in_buf, data_left);
          copied += data_left;
          real_pos += data_left;
      }
      else {
          memcpy(buf + copied, container->real_data + start_in_buf, count - copied);
          return true1;
      }

  }

  /*
   * XXX - does this represent a bug (WTAP_ERR_INTERNAL) or a
   * malformed file (WTAP_ERR_BAD_FILE)?
   */
  *err = WTAP_ERR_INTERNAL-21;
  *err_info = ws_strdup("blf_read_bytes_or_eof: ran out of containers")wmem_strdup(((void*)0), "blf_read_bytes_or_eof: ran out of containers"
);
  return false0;
1350}

1352static bool_Bool
1353blf_read_bytes(blf_params_t *params, uint64_t real_pos, void *target_buffer, uint64_t count, int *err, char **err_info) {
  if (!blf_read_bytes_or_eof(params, real_pos, target_buffer, count, err, err_info)) {
      if (*err == 0) {
          *err = WTAP_ERR_SHORT_READ-12;
      }
      return false0;
  }
  return true1;
1361}

1363static void
1364blf_init_rec(blf_params_t *params, uint32_t flags, uint64_t object_timestamp, int pkt_encap, uint16_t channel, uint16_t hwchannel, unsigned caplen, unsigned len) {
  wtap_setup_packet_rec(params->rec, pkt_encap);
  params->rec->block = wtap_block_create(WTAP_BLOCK_PACKET);
  params->rec->presence_flags = WTAP_HAS_CAP_LEN0x00000002 | WTAP_HAS_INTERFACE_ID0x00000004;
  params->rec->ts_rel_cap_valid = false0;
  switch (flags) {
  case BLF_TIMESTAMP_RESOLUTION_10US1:
      params->rec->presence_flags |= WTAP_HAS_TS0x00000001;
      params->rec->tsprec = WTAP_TSPREC_10_USEC5;
      object_timestamp *= 10000;
      object_timestamp += params->blf_data->start_offset_ns;
      params->rec->ts_rel_cap_valid = true1;
      break;

  case BLF_TIMESTAMP_RESOLUTION_1NS2:
      params->rec->presence_flags |= WTAP_HAS_TS0x00000001;
      params->rec->tsprec = WTAP_TSPREC_NSEC9;
      object_timestamp += params->blf_data->start_offset_ns;
      params->rec->ts_rel_cap_valid = true1;
      break;

  default:
      /* Metadata objects have both flags and timestamp equal to zero, so that combination is not an error. */
      if (flags != 0 || object_timestamp != 0) {
          /*
           * XXX - report this as an error?
           *
           * Or provide a mechanism to allow file readers to report
           * a warning (an error that the reader tries to work
           * around and that the caller should report)?
           */
          ws_debug("Unknown combination of flags and timestamp (0x%x, %" PRIu64 ")", flags, object_timestamp)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1395, __func__, "Unknown combination of flags and timestamp (0x%x, %"
 "l" "u" ")", flags, object_timestamp); } } while (0);
          object_timestamp = 0;
      }
      break;
  }
  params->rec->ts.secs = object_timestamp / (1000 * 1000 * 1000);
  params->rec->ts.nsecs = object_timestamp % (1000 * 1000 * 1000);
  params->rec->rec_header.packet_header.caplen = caplen;
  params->rec->rec_header.packet_header.len = len;

  nstime_t tmp_ts;
  tmp_ts.secs = params->blf_data->start_offset_ns / (1000 * 1000 * 1000);
  tmp_ts.nsecs = params->blf_data->start_offset_ns % (1000 * 1000 * 1000);
  nstime_delta(&params->rec->ts_rel_cap, &params->rec->ts, &tmp_ts);

  params->rec->rec_header.packet_header.interface_id = blf_lookup_interface(params, pkt_encap, channel, hwchannel, NULL((void*)0));

  /* TODO: before we had to remove comments and verdict here to not leak memory but APIs have changed ... */
1413}

1415static void
1416blf_add_direction_option(blf_params_t *params, uint16_t direction) {
  uint32_t tmp = PACK_FLAGS_DIRECTION_INBOUND1; /* dont care */

  switch (direction) {
  case BLF_DIR_RX0:
      tmp = PACK_FLAGS_DIRECTION_INBOUND1; /* inbound */
      break;
  case BLF_DIR_TX1:
  case BLF_DIR_TX_RQ2:
      tmp = PACK_FLAGS_DIRECTION_OUTBOUND2; /* outbound */
      break;
  }

  wtap_block_add_uint32_option(params->rec->block, OPT_PKT_FLAGS2, tmp);
1430}

1432static bool_Bool
1433blf_read_log_object_header(blf_params_t *params, int *err, char **err_info, int64_t header2_start, int64_t data_start, blf_logobjectheader_t *logheader) {
  if (data_start - header2_start < (int64_t)sizeof(blf_logobjectheader_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: not enough bytes for log object header")wmem_strdup(((void*)0), "blf: not enough bytes for log object header"
);
      ws_debug("not enough bytes for timestamp header")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1437, __func__, "not enough bytes for timestamp header"); }
 } while (0);
      return false0;
  }

  if (!blf_read_bytes_or_eof(params, header2_start, logheader, sizeof(*logheader), err, err_info)) {
      ws_debug("not enough bytes for logheader")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1442, __func__, "not enough bytes for logheader"); } } while
 (0);
      return false0;
  }
  fix_endianness_blf_logobjectheader(logheader);
  return true1;
1447}

1449static bool_Bool
1450blf_read_log_object_header2(blf_params_t *params, int *err, char **err_info, int64_t header2_start, int64_t data_start, blf_logobjectheader2_t *logheader) {
  if (data_start - header2_start < (int64_t)sizeof(blf_logobjectheader2_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: not enough bytes for log object header")wmem_strdup(((void*)0), "blf: not enough bytes for log object header"
);
      ws_debug("not enough bytes for timestamp header")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1454, __func__, "not enough bytes for timestamp header"); }
 } while (0);
      return false0;
  }

  if (!blf_read_bytes_or_eof(params, header2_start, logheader, sizeof(*logheader), err, err_info)) {
      ws_debug("not enough bytes for logheader")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1459, __func__, "not enough bytes for logheader"); } } while
 (0);
      return false0;
  }
  fix_endianness_blf_logobjectheader2(logheader);
  return true1;
1464}

1466static bool_Bool
1467blf_read_log_object_header3(blf_params_t *params, int *err, char **err_info, int64_t header2_start, int64_t data_start, blf_logobjectheader3_t *logheader) {
  if (data_start - header2_start < (int64_t)sizeof(blf_logobjectheader3_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: not enough bytes for log object header")wmem_strdup(((void*)0), "blf: not enough bytes for log object header"
);
      ws_debug("not enough bytes for timestamp header")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1471, __func__, "not enough bytes for timestamp header"); }
 } while (0);
      return false0;
  }

  if (!blf_read_bytes_or_eof(params, header2_start, logheader, sizeof(*logheader), err, err_info)) {
      ws_debug("not enough bytes for logheader")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1476, __func__, "not enough bytes for logheader"); } } while
 (0);
      return false0;
  }
  fix_endianness_blf_logobjectheader3(logheader);
  return true1;
1481}

1483static bool_Bool
1484blf_read_ethernetframe(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_ethernetframeheader_t ethheader;
  uint8_t tmpbuf[18];
  unsigned caplen, len;

  if (object_length < (data_start - block_start) + (int) sizeof(blf_ethernetframeheader_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: ETHERNET_FRAME: not enough bytes for ethernet frame header in object")wmem_strdup(((void*)0), "blf: ETHERNET_FRAME: not enough bytes for ethernet frame header in object"
);
      ws_debug("not enough bytes for ethernet frame header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1492, __func__, "not enough bytes for ethernet frame header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &ethheader, sizeof(ethheader), err, err_info)) {
      ws_debug("not enough bytes for ethernet frame header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1497, __func__, "not enough bytes for ethernet frame header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_ethernetframeheader(&ethheader);

  /*
   * BLF breaks up and reorders the Ethernet header and VLAN tag fields.
   * This is a really bad design and makes this format one of the worst.
   * If you want a fast format that keeps your data intact, avoid this format!
   * So, lets hope we can reconstruct the original packet successfully.
   */

  tmpbuf[0] = ethheader.dst_addr[0];
  tmpbuf[1] = ethheader.dst_addr[1];
  tmpbuf[2] = ethheader.dst_addr[2];
  tmpbuf[3] = ethheader.dst_addr[3];
  tmpbuf[4] = ethheader.dst_addr[4];
  tmpbuf[5] = ethheader.dst_addr[5];

  tmpbuf[6] = ethheader.src_addr[0];
  tmpbuf[7] = ethheader.src_addr[1];
  tmpbuf[8] = ethheader.src_addr[2];
  tmpbuf[9] = ethheader.src_addr[3];
  tmpbuf[10] = ethheader.src_addr[4];
  tmpbuf[11] = ethheader.src_addr[5];

  if (ethheader.tpid != 0 && ethheader.tci != 0) {
      phtonu16(tmpbuf + 12, ethheader.tpid);
      phtonu16(tmpbuf + 14, ethheader.tci);
      phtonu16(tmpbuf + 16, ethheader.ethtype);
      ws_buffer_assure_space(&params->rec->data, (size_t)18 + ethheader.payloadlength);
      ws_buffer_append(&params->rec->data, tmpbuf, (size_t)18);
      caplen = ((uint32_t)18 + ethheader.payloadlength);
      len = ((uint32_t)18 + ethheader.payloadlength);
  } else {
      phtonu16(tmpbuf + 12, ethheader.ethtype);
      ws_buffer_assure_space(&params->rec->data, (size_t)14 + ethheader.payloadlength);
      ws_buffer_append(&params->rec->data, tmpbuf, (size_t)14);
      caplen = ((uint32_t)14 + ethheader.payloadlength);
      len = ((uint32_t)14 + ethheader.payloadlength);
  }

  if (!blf_read_bytes(params, data_start + sizeof(blf_ethernetframeheader_t), ws_buffer_end_ptr(&params->rec->data), ethheader.payloadlength, err, err_info)) {
      ws_debug("copying ethernet frame failed")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1540, __func__, "copying ethernet frame failed"); } } while
 (0);
      return false0;
  }
  ws_buffer_increase_length(&params->rec->data, ethheader.payloadlength);

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_ETHERNET1, ethheader.channel, UINT16_MAX(65535), caplen, len);
  blf_add_direction_option(params, ethheader.direction);

  return true1;
1549}

1551static bool_Bool
1552blf_read_ethernetframe_ext(blf_params_t *params, int *err, char **err_info, int64_t block_start,int64_t data_start,
                          int64_t object_length, uint32_t flags, uint64_t object_timestamp, gboolean error) {
  blf_ethernetframeheader_ex_t ethheader;

  if (object_length < (data_start - block_start) + (int) sizeof(blf_ethernetframeheader_ex_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup_printf("blf: %s: not enough bytes for ethernet frame header in object", error ? "ETHERNET_ERROR_EX" : "ETHERNET_FRAME_EX")wmem_strdup_printf(((void*)0), "blf: %s: not enough bytes for ethernet frame header in object"
, error ? "ETHERNET_ERROR_EX" : "ETHERNET_FRAME_EX");
      ws_debug("not enough bytes for ethernet frame header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1559, __func__, "not enough bytes for ethernet frame header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &ethheader, sizeof(blf_ethernetframeheader_ex_t), err, err_info)) {
      ws_debug("not enough bytes for ethernet frame header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1564, __func__, "not enough bytes for ethernet frame header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_ethernetframeheader_ex(&ethheader);

  if (object_length - (data_start - block_start) - sizeof(blf_ethernetframeheader_ex_t) < ethheader.frame_length) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup_printf("blf: %s: frame too short", error ? "ETHERNET_ERROR_EX" : "ETHERNET_FRAME_EX")wmem_strdup_printf(((void*)0), "blf: %s: frame too short", error
 ? "ETHERNET_ERROR_EX" : "ETHERNET_FRAME_EX");
      ws_debug("frame too short")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1572, __func__, "frame too short"); } } while (0);
      return false0;
  }

  ws_buffer_assure_space(&params->rec->data, ethheader.frame_length);

  if (!blf_read_bytes(params, data_start + sizeof(blf_ethernetframeheader_ex_t), ws_buffer_end_ptr(&params->rec->data), ethheader.frame_length, err, err_info)) {
      ws_debug("copying ethernet frame failed")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1579, __func__, "copying ethernet frame failed"); } } while
 (0);
      return false0;
  }
  ws_buffer_increase_length(&params->rec->data, ethheader.frame_length);

  if (ethheader.flags & BLF_ETHERNET_EX_HARDWARECHANNEL0x0002) {
      blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_ETHERNET1, ethheader.channel, ethheader.hw_channel, ethheader.frame_length, ethheader.frame_length);
      wtap_block_add_uint32_option(params->rec->block, OPT_PKT_QUEUE6, ethheader.hw_channel);
  }
  else {
      blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_ETHERNET1, ethheader.channel, UINT16_MAX(65535), ethheader.frame_length, ethheader.frame_length);
  }

  blf_add_direction_option(params, ethheader.direction);

  return true1;
1595}

1597static bool_Bool
1598blf_read_ethernet_rxerror(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_ethernet_rxerror_t ethheader;

  if (object_length < (data_start - block_start) + (int)sizeof(blf_ethernet_rxerror_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: ETHERNET_RXERROR: not enough bytes for ethernet frame header in object")wmem_strdup(((void*)0), "blf: ETHERNET_RXERROR: not enough bytes for ethernet frame header in object"
);
      ws_debug("not enough bytes for ethernet rx error header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1604, __func__, "not enough bytes for ethernet rx error header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &ethheader, sizeof(blf_ethernet_rxerror_t), err, err_info)) {
      ws_debug("not enough bytes for ethernet rx error header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1609, __func__, "not enough bytes for ethernet rx error header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_ethernet_rxerror(&ethheader);

  if (object_length - (data_start - block_start) < ethheader.frame_length) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: ETHERNET_RXERROR: frame too short")wmem_strdup(((void*)0), "blf: ETHERNET_RXERROR: frame too short"
);
      ws_debug("frame too short")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1617, __func__, "frame too short"); } } while (0);
      return false0;
  }

  ws_buffer_assure_space(&params->rec->data, ethheader.frame_length);

  if (!blf_read_bytes(params, data_start + sizeof(blf_ethernet_rxerror_t), ws_buffer_end_ptr(&params->rec->data), ethheader.frame_length, err, err_info)) {
      ws_debug("copying ethernet rx error failed")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1624, __func__, "copying ethernet rx error failed"); } } while
 (0);
      return false0;
  }
  ws_buffer_increase_length(&params->rec->data, ethheader.frame_length);

  if (ethheader.hw_channel != 0) {    /* In this object type, a value of 0 is considered invalid. */
      blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_ETHERNET1, ethheader.channel, ethheader.hw_channel, ethheader.frame_length, ethheader.frame_length);
      wtap_block_add_uint32_option(params->rec->block, OPT_PKT_QUEUE6, ethheader.hw_channel);
  }
  else {
      blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_ETHERNET1, ethheader.channel, UINT16_MAX(65535), ethheader.frame_length, ethheader.frame_length);
  }
  blf_add_direction_option(params, ethheader.direction);

  return true1;
1639}

1641/*
* XXX - provide radio information to our caller in the pseudo-header.
*/
1644static bool_Bool
1645blf_read_wlanframe(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_wlanframeheader_t wlanheader;

  if (object_length < (data_start - block_start) + (int)sizeof(blf_wlanframeheader_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: WLAN_FRAME: not enough bytes for wlan frame header in object")wmem_strdup(((void*)0), "blf: WLAN_FRAME: not enough bytes for wlan frame header in object"
);
      ws_debug("not enough bytes for wlan frame header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1651, __func__, "not enough bytes for wlan frame header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &wlanheader, sizeof(blf_wlanframeheader_t), err, err_info)) {
      ws_debug("not enough bytes for wlan frame header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1656, __func__, "not enough bytes for wlan frame header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_wlanframeheader(&wlanheader);

  if (object_length - (data_start - block_start) - sizeof(blf_wlanframeheader_t) < wlanheader.frame_length) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: WLAN_FRAME: frame too short")wmem_strdup(((void*)0), "blf: WLAN_FRAME: frame too short");
      ws_debug("frame too short")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1664, __func__, "frame too short"); } } while (0);
      return false0;
  }

  ws_buffer_assure_space(&params->rec->data, wlanheader.frame_length);

  if (!blf_read_bytes(params, data_start + sizeof(blf_wlanframeheader_t), ws_buffer_end_ptr(&params->rec->data), wlanheader.frame_length, err, err_info)) {
      ws_debug("copying wlan frame failed")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1671, __func__, "copying wlan frame failed"); } } while (0);
      return false0;
  }
  ws_buffer_increase_length(&params->rec->data, wlanheader.frame_length);

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_IEEE_802_1120, wlanheader.channel, UINT16_MAX(65535), wlanheader.frame_length, wlanheader.frame_length);
  blf_add_direction_option(params, wlanheader.direction);

  return true1;
1680}

1682static const uint8_t can_dlc_to_length[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8 };
1683static const uint8_t canfd_dlc_to_length[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64 };

1685static bool_Bool
1686blf_can_fill_buf_and_rec(blf_params_t *params, int *err, char **err_info, uint32_t canid, uint8_t payload_length, uint8_t payload_length_valid, uint64_t start_position,
                       uint32_t flags, uint64_t object_timestamp, uint16_t channel, uint8_t canfd_flags) {
  uint8_t  tmpbuf[8];
  unsigned caplen, len;

  phtonu32(tmpbuf, canid);
  tmpbuf[4] = payload_length;
  tmpbuf[5] = canfd_flags;
  tmpbuf[6] = 0;
  tmpbuf[7] = 0;

  ws_buffer_assure_space(&params->rec->data, sizeof(tmpbuf) + payload_length_valid);
  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  caplen = sizeof(tmpbuf) + payload_length_valid;
  len = sizeof(tmpbuf) + payload_length;

  if (payload_length_valid > 0 && !blf_read_bytes(params, start_position, ws_buffer_end_ptr(&params->rec->data), payload_length_valid, err, err_info)) {
      ws_debug("copying can payload failed")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1703, __func__, "copying can payload failed"); } } while (0
);
      return false0;
  }
  ws_buffer_increase_length(&params->rec->data, payload_length_valid);

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN125, channel, UINT16_MAX(65535), caplen, len);

  return true1;
1711}

1713static bool_Bool
1714blf_read_canmessage(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, bool_Bool can_message2) {
  blf_canmessage_t canheader;
  blf_canmessage2_trailer_t can2trailer;

  uint32_t canid;
  uint8_t  payload_length;

  if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup_printf("blf: %s: not enough bytes for can header in object",wmem_strdup_printf(((void*)0), "blf: %s: not enough bytes for can header in object"
, can_message2 ? "CAN_MESSAGE2" : "CAN_MESSAGE")
                                  can_message2 ? "CAN_MESSAGE2" : "CAN_MESSAGE")wmem_strdup_printf(((void*)0), "blf: %s: not enough bytes for can header in object"
, can_message2 ? "CAN_MESSAGE2" : "CAN_MESSAGE");
      ws_debug("not enough bytes for can header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1725, __func__, "not enough bytes for can header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
      ws_debug("not enough bytes for can header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1730, __func__, "not enough bytes for can header in file");
 } } while (0);
      return false0;
  }
  fix_endianness_blf_canmessage(&canheader);

  canheader.dlc &= 0x0f;

  payload_length = canheader.dlc;
  if (payload_length > 8) {
      ws_debug("regular CAN tries more than 8 bytes? Cutting to 8!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1739, __func__, "regular CAN tries more than 8 bytes? Cutting to 8!"
); } } while (0);
      payload_length = 8;
  }

  canid = canheader.id;

  if ((canheader.flags & BLF_CANMESSAGE_FLAG_RTR0x80) == BLF_CANMESSAGE_FLAG_RTR0x80) {
      canid |= CAN_RTR_FLAG0x40000000;
      payload_length = 0;
  }

  if (!blf_can_fill_buf_and_rec(params, err, err_info, canid, payload_length, payload_length, data_start + sizeof(canheader), flags, object_timestamp, canheader.channel, 0)) {
      return false0;
  }

  /* actually, we do not really need the data, right now.... */
  if (can_message2) {
      if (object_length < (data_start - block_start) + (int) sizeof(canheader) + 8 + (int) sizeof(can2trailer)) {
          *err = WTAP_ERR_BAD_FILE-13;
          *err_info = ws_strdup("blf: CAN_MESSAGE2: not enough bytes for can message 2 trailer")wmem_strdup(((void*)0), "blf: CAN_MESSAGE2: not enough bytes for can message 2 trailer"
);
          ws_debug("not enough bytes for can message 2 trailer")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1759, __func__, "not enough bytes for can message 2 trailer"
); } } while (0);
          return false0;
      }
      if (!blf_read_bytes(params, data_start + sizeof(canheader) + 8, &can2trailer, sizeof(can2trailer), err, err_info)) {
          ws_debug("not enough bytes for can message 2 trailer in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1763, __func__, "not enough bytes for can message 2 trailer in file"
); } } while (0);
          return false0;
      }
      fix_endianness_blf_canmessage2_trailer(&can2trailer);
  }

  blf_add_direction_option(params, (canheader.flags & BLF_CANMESSAGE_FLAG_TX0x01) == BLF_CANMESSAGE_FLAG_TX0x01 ? BLF_DIR_TX1: BLF_DIR_RX0);

  return true1;
1772}

1774static bool_Bool
1775blf_read_canfdmessage(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_canfdmessage_t canheader;

  bool_Bool     canfd;
  uint32_t canid;
  uint8_t  payload_length;
  uint8_t  payload_length_valid;
  uint8_t  canfd_flags;

  if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: CAN_FD_MESSAGE: not enough bytes for canfd header in object")wmem_strdup(((void*)0), "blf: CAN_FD_MESSAGE: not enough bytes for canfd header in object"
);
      ws_debug("not enough bytes for canfd header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1787, __func__, "not enough bytes for canfd header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
      ws_debug("not enough bytes for canfd header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1792, __func__, "not enough bytes for canfd header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_canfdmessage(&canheader);

  canheader.dlc &= 0x0f;

  canfd = (canheader.canfdflags & BLF_CANFDMESSAGE_CANFDFLAG_EDL0x01) == BLF_CANFDMESSAGE_CANFDFLAG_EDL0x01;
  if (canfd) {
      payload_length = canfd_dlc_to_length[canheader.dlc];
      canfd_flags = (canheader.canfdflags & BLF_CANFDMESSAGE_CANFDFLAG_EDL0x01) << 2 | (canheader.canfdflags & BLF_CANFDMESSAGE_CANFDFLAG_ESI0x04) >> 1 | (canheader.canfdflags & BLF_CANFDMESSAGE_CANFDFLAG_BRS0x02) >> 1;
  } else {
      if (canheader.dlc > 8) {
          ws_debug("regular CAN tries more than 8 bytes?")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1805, __func__, "regular CAN tries more than 8 bytes?"); } }
 while (0);
      }
      payload_length = can_dlc_to_length[canheader.dlc];
      canfd_flags = 0;
  }

  if (payload_length > canheader.validDataBytes) {
      ws_debug("shortening canfd payload because valid data bytes shorter!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1812, __func__, "shortening canfd payload because valid data bytes shorter!"
); } } while (0);
      payload_length = canheader.validDataBytes;
  }

  canid = canheader.id;

  if (!canfd && (canheader.flags & BLF_CANMESSAGE_FLAG_RTR0x80) == BLF_CANMESSAGE_FLAG_RTR0x80) {
      canid |= CAN_RTR_FLAG0x40000000;
      payload_length = 0; /* Should already be zero from validDataBytes */
  }

  payload_length_valid = payload_length;

  if (payload_length_valid > object_length - (data_start - block_start) + sizeof(canheader)) {
      ws_debug("shortening can payload because buffer is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1826, __func__, "shortening can payload because buffer is too short!"
); } } while (0);
      payload_length_valid = (uint8_t)(object_length - (data_start - block_start));
  }

  if (!blf_can_fill_buf_and_rec(params, err, err_info, canid, payload_length, payload_length_valid, data_start + sizeof(canheader), flags, object_timestamp, canheader.channel, canfd_flags)) {
      return false0;
  }

  blf_add_direction_option(params, (canheader.flags & BLF_CANMESSAGE_FLAG_TX0x01) == BLF_CANMESSAGE_FLAG_TX0x01 ? BLF_DIR_TX1 : BLF_DIR_RX0);

  return true1;
1837}

1839static bool_Bool
1840blf_read_canfdmessage64(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_canfdmessage64_t canheader;

  bool_Bool     canfd;
  uint32_t canid;
  uint8_t  payload_length;
  uint8_t  payload_length_valid;
  uint8_t  canfd_flags;

  if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: CAN_FD_MESSAGE_64: not enough bytes for canfd header in object")wmem_strdup(((void*)0), "blf: CAN_FD_MESSAGE_64: not enough bytes for canfd header in object"
);
      ws_debug("not enough bytes for canfd header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1852, __func__, "not enough bytes for canfd header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
      ws_debug("not enough bytes for canfd header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1857, __func__, "not enough bytes for canfd header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_canfdmessage64(&canheader);

  canheader.dlc &= 0x0f;

  canfd = (canheader.flags & BLF_CANFDMESSAGE64_FLAG_EDL0x001000) == BLF_CANFDMESSAGE64_FLAG_EDL0x001000;
  if (canfd) {
      payload_length = canfd_dlc_to_length[canheader.dlc];
      canfd_flags = (canheader.flags & BLF_CANFDMESSAGE64_FLAG_EDL0x001000) >> 10 | (canheader.flags & BLF_CANFDMESSAGE64_FLAG_ESI0x004000) >> 13 | (canheader.flags & BLF_CANFDMESSAGE64_FLAG_BRS0x002000) >> 13;
  } else {
      if (canheader.dlc > 8) {
          ws_debug("regular CAN tries more than 8 bytes?")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1870, __func__, "regular CAN tries more than 8 bytes?"); } }
 while (0);
      }
      payload_length = can_dlc_to_length[canheader.dlc];
      canfd_flags = 0;
  }

  if (payload_length > canheader.validDataBytes) {
      ws_debug("shortening canfd payload because valid data bytes shorter!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1877, __func__, "shortening canfd payload because valid data bytes shorter!"
); } } while (0);
      payload_length = canheader.validDataBytes;
  }

  canid = canheader.id;

  if (!canfd && (canheader.flags & BLF_CANFDMESSAGE64_FLAG_REMOTE_FRAME0x000010) == BLF_CANFDMESSAGE64_FLAG_REMOTE_FRAME0x000010) {
      canid |= CAN_RTR_FLAG0x40000000;
      payload_length = 0; /* Should already be zero from validDataBytes */
  }

  payload_length_valid = payload_length;

  if (payload_length_valid > object_length - (data_start - block_start)) {
      ws_debug("shortening can payload because buffer is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1891, __func__, "shortening can payload because buffer is too short!"
); } } while (0);
      payload_length_valid = (uint8_t)(object_length - (data_start - block_start));
  }

  if (!blf_can_fill_buf_and_rec(params, err, err_info, canid, payload_length, payload_length_valid, data_start + sizeof(canheader), flags, object_timestamp, canheader.channel, canfd_flags)) {
      return false0;
  }

  blf_add_direction_option(params, canheader.dir);

  return true1;
1902}

1904static bool_Bool
1905blf_read_canerror(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, bool_Bool overload) {
  blf_canerror_t canheader;
  uint32_t canid;
  uint8_t  payload_length;
  uint8_t  tmpbuf[16] = {0};

  if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: CAN_ERROR: not enough bytes for canerror header in object")wmem_strdup(((void*)0), "blf: CAN_ERROR: not enough bytes for canerror header in object"
);
      ws_debug("not enough bytes for canerror header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1914, __func__, "not enough bytes for canerror header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
      ws_debug("not enough bytes for canerror header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1919, __func__, "not enough bytes for canerror header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_canerror(&canheader);

  // Set CAN_ERR_FLAG in unused bits of Can ID to indicate error in socketcan
  canid = CAN_ERR_FLAG0x20000000;

  // Fixed packet data length for socketcan error messages
  payload_length = CAN_ERR_DLC8;

  if (overload) {
      tmpbuf[10] = CAN_ERR_PROT_OVERLOAD0x20;
      canid |= CAN_ERR_PROT0x00000008U;
  }

  phtonu32(tmpbuf, canid);
  tmpbuf[4] = payload_length;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN125, canheader.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));
  return true1;
1942}

1944static bool_Bool
1945blf_read_canerrorext(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_canerrorext_t canheader;

  bool_Bool     err_ack = false0;
  bool_Bool     err_prot = false0;
  bool_Bool     direction_tx;
  uint32_t canid;
  uint8_t  payload_length;
  uint8_t  tmpbuf[16] = {0};

  if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: CAN_ERROR_EXT: not enough bytes for canerrorext header in object")wmem_strdup(((void*)0), "blf: CAN_ERROR_EXT: not enough bytes for canerrorext header in object"
);
      ws_debug("not enough bytes for canerrorext header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1958, __func__, "not enough bytes for canerrorext header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
      ws_debug("not enough bytes for canerrorext header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 1963, __func__, "not enough bytes for canerrorext header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_canerrorext(&canheader);

  if (canheader.flags & BLF_CANERROREXT_FLAG_CANCORE0x02) {
      // Map Vector Can Core error codes to compareable socketcan errors
      switch ((canheader.errorCodeExt >> 6) & 0x3f) {
      case BLF_CANERROREXT_ECC_MEANING_BIT_ERROR0x0:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_BIT0x01;
          break;
      case BLF_CANERROREXT_ECC_MEANING_FORM_ERROR0x1:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_FORM0x02;
          break;
      case BLF_CANERROREXT_ECC_MEANING_STUFF_ERROR0x2:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_STUFF0x04;
          break;
      case BLF_CANERROREXT_ECC_MEANING_CRC_ERROR0x4:
          err_prot = true1;
          tmpbuf[11] = CAN_ERR_PROT_LOC_CRC_SEQ0x08;
          break;
      case BLF_CANERROREXT_ECC_MEANING_NACK_ERROR0x7:
          err_ack = true1;
          tmpbuf[11] = CAN_ERR_PROT_LOC_ACK0x19;
          break;
      case BLF_CANERROREXT_ECC_MEANING_OVERLOAD0x8:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_OVERLOAD0x20;
          break;
      default:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_UNSPEC0x00;
          break;
      }
      err_ack = err_ack || (canheader.errorCodeExt & BLF_CANERROREXT_EXTECC_NOT_ACK0x2000) == 0x0;
      if (err_ack) {
          // Don't set protocol error on ack errors
          err_prot = false0;
      }
  }

  // CanID contains error class in socketcan
  canid = CAN_ERR_FLAG0x20000000;
  canid |= err_prot ? CAN_ERR_PROT0x00000008U : 0;
  canid |= err_ack ? CAN_ERR_ACK0x00000020U : 0;

  // Fixed packet data length for socketcan error messages
  payload_length = CAN_ERR_DLC8;
  canheader.dlc = payload_length;

  phtonu32(tmpbuf, canid);
  tmpbuf[4] = payload_length;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN125, canheader.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));
  if (canheader.flags & BLF_CANERROREXT_FLAG_CANCORE0x02) {
      direction_tx = (canheader.errorCodeExt & BLF_CANERROREXT_EXTECC_TX0x1000) == BLF_CANERROREXT_EXTECC_TX0x1000;
      blf_add_direction_option(params, direction_tx ? BLF_DIR_TX1: BLF_DIR_RX0);
  }
  return true1;
2027}

2029static bool_Bool
2030blf_read_canfderror64(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_canfderror64_t canheader;

  bool_Bool     err_ack = false0;
  bool_Bool     err_prot = false0;
  bool_Bool     direction_tx;
  uint32_t canid;
  uint8_t  payload_length;
  uint8_t  tmpbuf[16] = {0};

  if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: CAN_FD_ERROR_64: not enough bytes for canfderror header in object")wmem_strdup(((void*)0), "blf: CAN_FD_ERROR_64: not enough bytes for canfderror header in object"
);
      ws_debug("not enough bytes for canfderror header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2043, __func__, "not enough bytes for canfderror header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
      ws_debug("not enough bytes for canfderror header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2048, __func__, "not enough bytes for canfderror header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_canfderror64(&canheader);

  if (canheader.flags & BLF_CANERROREXT_FLAG_CANCORE0x02) {
      // Map Vector Can Core error codes to compareable socketcan errors
      switch ((canheader.errorCodeExt >> 6) & 0x3f) {
      case BLF_CANERROREXT_ECC_MEANING_BIT_ERROR0x0:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_BIT0x01;
          break;
      case BLF_CANERROREXT_ECC_MEANING_FORM_ERROR0x1:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_FORM0x02;
          break;
      case BLF_CANERROREXT_ECC_MEANING_STUFF_ERROR0x2:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_STUFF0x04;
          break;
      case BLF_CANERROREXT_ECC_MEANING_CRC_ERROR0x4:
          err_prot = true1;
          tmpbuf[11] = CAN_ERR_PROT_LOC_CRC_SEQ0x08;
          break;
      case BLF_CANERROREXT_ECC_MEANING_NACK_ERROR0x7:
          err_ack = true1;
          tmpbuf[11] = CAN_ERR_PROT_LOC_ACK0x19;
          break;
      case BLF_CANERROREXT_ECC_MEANING_OVERLOAD0x8:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_OVERLOAD0x20;
          break;
      default:
          err_prot = true1;
          tmpbuf[10] = CAN_ERR_PROT_UNSPEC0x00;
          break;
      }
      err_ack = err_ack || (canheader.errorCodeExt & BLF_CANERROREXT_EXTECC_NOT_ACK0x2000) == 0x0;
      if (err_ack) {
          // Don't set protocol error on ack errors
          err_prot = false0;
      }
  }

  // CanID contains error class in socketcan
  canid = CAN_ERR_FLAG0x20000000;
  canid |= err_prot ? CAN_ERR_PROT0x00000008U : 0;
  canid |= err_ack ? CAN_ERR_ACK0x00000020U : 0;

  // Fixed packet data length for socketcan error messages
  payload_length = CAN_ERR_DLC8;
  canheader.dlc = payload_length;

  phtonu32(tmpbuf, canid);
  tmpbuf[4] = payload_length;
  // Don't set FDF, ESI and BRS flags, since error messages are always encapsulated in Classic CAN frames

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN125, canheader.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));
  if (canheader.flags & BLF_CANERROREXT_FLAG_CANCORE0x02) {
      direction_tx = (canheader.errorCodeExt & BLF_CANERROREXT_EXTECC_TX0x1000) == BLF_CANERROREXT_EXTECC_TX0x1000;
      blf_add_direction_option(params, direction_tx ? BLF_DIR_TX1: BLF_DIR_RX0);
  }
  return true1;
2113}

2115static bool_Bool
2116blf_read_canxlchannelframe(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_canxlchannelframe_t canxlheader;

  if (object_length < (data_start - block_start) + (int)sizeof(canxlheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: CAN_XL_CHANNEL_HEADER: not enough bytes for canxlchannelframe header in object")wmem_strdup(((void*)0), "blf: CAN_XL_CHANNEL_HEADER: not enough bytes for canxlchannelframe header in object"
);
      ws_debug("not enough bytes for canxlchannelframe header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2122, __func__, "not enough bytes for canxlchannelframe header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &canxlheader, sizeof(canxlheader), err, err_info)) {
      ws_debug("not enough bytes for canxlchannelframe header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2127, __func__, "not enough bytes for canxlchannelframe header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_canxlchannelframe(&canxlheader);

  uint16_t payload_length = canxlheader.dataLength;
  bool_Bool is_canxl = canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_XLF0x400000;

  if (is_canxl) {
      uint16_t canid = canxlheader.frameIdentifier & CAN_SFF_MASK0x000007FF;

      uint8_t canxl_flags = 0;
      if ((canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_XLF0x400000) == BLF_CANXLCHANNELFRAME_FLAG_XLF0x400000) {
          canxl_flags |= CANXL_XLF0x80;
      }

      if ((canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_SEC0x1000000) == BLF_CANXLCHANNELFRAME_FLAG_SEC0x1000000) {
          canxl_flags |= CANXL_SEC0x01;
      }

      if ((canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_RRS0x800000) == BLF_CANXLCHANNELFRAME_FLAG_RRS0x800000) {
          canxl_flags |= CANXL_RRS0x02;
      }

      uint8_t  tmpbuf[12] = { 0 };
      tmpbuf[1] = canxlheader.virtualControllerAreaNetChannelID;
      phtonu16(tmpbuf + 2, canid);
      tmpbuf[4] = canxl_flags;
      tmpbuf[5] = canxlheader.serviceDataUnitType;
      phtoleu16(tmpbuf + 6, payload_length);
      phtoleu32(tmpbuf + 8, canxlheader.acceptanceField);

      ws_buffer_assure_space(&params->rec->data, sizeof(tmpbuf) + payload_length);
      ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

      if (payload_length > 0 && !blf_read_bytes(params, data_start + sizeof(blf_canxlchannelframe_t), ws_buffer_end_ptr(&params->rec->data), payload_length, err, err_info)) {
          ws_error("copying canxl payload failed")ws_log_fatal_full("Wiretap", LOG_LEVEL_ERROR, "wiretap/blf.c"
, 2163, __func__, "copying canxl payload failed");
          return false0;
      }
      ws_buffer_increase_length(&params->rec->data, payload_length);

      blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN125, canxlheader.channel, UINT16_MAX(65535), sizeof(tmpbuf) + payload_length, sizeof(tmpbuf) + payload_length);
  } else {
      // Support for CAN or CAN-FD in CAN-XL Channel Frame format is experimental as of 2025!
      // If you have samples traces, please create a ticket and attach them to it: https://gitlab.com/wireshark/wireshark/-/issues

      bool_Bool canfd = canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_FDF0x1000;
      uint8_t canfd_flags = 0;

      if (canfd) {
          if ((canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_BRS0x2000) == BLF_CANXLCHANNELFRAME_FLAG_BRS0x2000) {
              canfd_flags |= CANFD_BRS0x01;
          }
          if ((canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_ESI0x4000) == BLF_CANXLCHANNELFRAME_FLAG_ESI0x4000) {
              canfd_flags |= CANFD_ESI0x02;
          }
          if ((canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_FDF0x1000) == BLF_CANXLCHANNELFRAME_FLAG_FDF0x1000) {
              canfd_flags |= CANFD_FDF0x04;
          }
      } else {
          if (canxlheader.dlc > 8) {
              ws_debug("Regular CAN should not have DLC > 8!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2188, __func__, "Regular CAN should not have DLC > 8!");
 } } while (0);
          }

          canfd_flags = 0;
      }

      uint32_t canid = canxlheader.frameIdentifier;

      /* Unclear how to reconstruct the EFF Flag. Let's make sure, we set it if the ID is more than 11 bits */
      if ((canid & CAN_EFF_MASK0x1FFFFFFF) > CAN_SFF_MASK0x000007FF) {
          canid |= CAN_EFF_FLAG0x80000000;
      }

      if (!canfd && (canxlheader.flags & BLF_CANXLCHANNELFRAME_FLAG_REMOTE_FRAME0x10) == BLF_CANXLCHANNELFRAME_FLAG_REMOTE_FRAME0x10) {
          canid |= CAN_RTR_FLAG0x40000000;
          payload_length = 0;
      }

      if (!blf_can_fill_buf_and_rec(params, err, err_info, canid, (uint8_t)payload_length, (uint8_t)payload_length, data_start + sizeof(canxlheader), flags, object_timestamp, canxlheader.channel, canfd_flags)) {
          return false0;
      }
  }

  blf_add_direction_option(params, canxlheader.dir ? BLF_DIR_TX1 : BLF_DIR_RX0);

  return true1;
2214}

2216static bool_Bool
2217blf_read_flexraydata(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_flexraydata_t frheader;

  uint8_t  payload_length;
  uint8_t  payload_length_valid;
  uint8_t  tmpbuf[7];
  unsigned caplen, len;

  if (object_length < (data_start - block_start) + (int) sizeof(frheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: FLEXRAY_DATA: not enough bytes for flexrayheader in object")wmem_strdup(((void*)0), "blf: FLEXRAY_DATA: not enough bytes for flexrayheader in object"
);
      ws_debug("not enough bytes for flexrayheader in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2228, __func__, "not enough bytes for flexrayheader in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &frheader, sizeof(frheader), err, err_info)) {
      ws_debug("not enough bytes for flexrayheader header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2233, __func__, "not enough bytes for flexrayheader header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_flexraydata(&frheader);

  payload_length = frheader.len;
  payload_length_valid = payload_length;

  if ((frheader.len & 0x01) == 0x01) {
      ws_debug("reading odd length in FlexRay!?")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2242, __func__, "reading odd length in FlexRay!?"); } } while
 (0);
  }

  if (payload_length_valid > object_length - (data_start - block_start) - sizeof(frheader)) {
      ws_debug("shortening FlexRay payload because buffer is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2246, __func__, "shortening FlexRay payload because buffer is too short!"
); } } while (0);
      payload_length_valid = (uint8_t)(object_length - (data_start - block_start) - sizeof(frheader));
  }

  if (frheader.channel != 0 && frheader.channel != 1) {
      ws_debug("FlexRay supports only two channels.")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2251, __func__, "FlexRay supports only two channels."); } }
 while (0);
  }

  /* Measurement Header */
  if (frheader.channel == 0) {
      tmpbuf[0] = BLF_FLEXRAYDATA_FRAME0x01;
  } else {
      tmpbuf[0] = BLF_FLEXRAYDATA_FRAME0x01 | BLF_FLEXRAYDATA_CHANNEL_B0x80;
  }

  /* Error Flags */
  tmpbuf[1] = 0;

  /* Frame Header */
  tmpbuf[2] = 0x20 | ((0x0700 & frheader.messageId) >> 8);
  tmpbuf[3] = 0x00ff & frheader.messageId;
  tmpbuf[4] = (0xfe & frheader.len) | ((frheader.crc & 0x0400) >> 10);
  tmpbuf[5] = (0x03fc & frheader.crc) >> 2;
  tmpbuf[6] = ((0x0003 & frheader.crc) << 6) | (0x3f & frheader.mux);

  ws_buffer_assure_space(&params->rec->data, sizeof(tmpbuf) + payload_length_valid);
  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  caplen = sizeof(tmpbuf) + payload_length_valid;
  len = sizeof(tmpbuf) + payload_length;

  if (payload_length_valid > 0 && !blf_read_bytes(params, data_start + sizeof(frheader), ws_buffer_end_ptr(&params->rec->data), payload_length_valid, err, err_info)) {
      ws_debug("copying flexray payload failed")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2277, __func__, "copying flexray payload failed"); } } while
 (0);
      return false0;
  }
  ws_buffer_increase_length(&params->rec->data, payload_length_valid);

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_FLEXRAY106, frheader.channel, UINT16_MAX(65535), caplen, len);
  blf_add_direction_option(params, frheader.dir);

  return true1;
2286}

2288static bool_Bool
2289blf_read_flexraymessage(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_flexraymessage_t frheader;

  uint8_t  payload_length;
  uint8_t  payload_length_valid;
  uint8_t  tmpbuf[7];
  unsigned caplen, len;

  if (object_length < (data_start - block_start) + (int) sizeof(frheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: FLEXRAY_MESSAGE: not enough bytes for flexrayheader in object")wmem_strdup(((void*)0), "blf: FLEXRAY_MESSAGE: not enough bytes for flexrayheader in object"
);
      ws_debug("not enough bytes for flexrayheader in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2300, __func__, "not enough bytes for flexrayheader in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &frheader, sizeof(frheader), err, err_info)) {
      ws_debug("not enough bytes for flexrayheader header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2305, __func__, "not enough bytes for flexrayheader header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_flexraymessage(&frheader);

  payload_length = frheader.length;
  payload_length_valid = payload_length;

  if ((frheader.length & 0x01) == 0x01) {
      ws_debug("reading odd length in FlexRay!?")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2314, __func__, "reading odd length in FlexRay!?"); } } while
 (0);
  }

  if (payload_length_valid > object_length - (data_start - block_start) - sizeof(frheader)) {
      ws_debug("shortening FlexRay payload because buffer is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2318, __func__, "shortening FlexRay payload because buffer is too short!"
); } } while (0);
      payload_length_valid = (uint8_t)(object_length - (data_start - block_start) - sizeof(frheader));
  }

  if (frheader.channel != 0 && frheader.channel != 1) {
      ws_debug("FlexRay supports only two channels.")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2323, __func__, "FlexRay supports only two channels."); } }
 while (0);
  }

  /* Measurement Header */
  if (frheader.channel == 0) {
      tmpbuf[0] = BLF_FLEXRAYDATA_FRAME0x01;
  } else {
      tmpbuf[0] = BLF_FLEXRAYDATA_FRAME0x01 | BLF_FLEXRAYDATA_CHANNEL_B0x80;
  }

  /* Error Flags */
  tmpbuf[1] = 0;

  /* Frame Header */
  tmpbuf[2] = ((0x0700 & frheader.frameId) >> 8);
  if ((frheader.frameState & BLF_FLEXRAYMESSAGE_STATE_PPI0x01) == BLF_FLEXRAYMESSAGE_STATE_PPI0x01) {
      tmpbuf[2] |= BLF_DLT_FLEXRAY_PPI0x40;
  }

  if ((frheader.frameState & BLF_FLEXRAYMESSAGE_STATE_SFI0x02) == BLF_FLEXRAYMESSAGE_STATE_SFI0x02) {
      tmpbuf[2] |= BLF_DLT_FLEXRAY_SFI0x10;
  }

  if ((frheader.frameState & BLF_FLEXRAYMESSAGE_STATE_NFI0x08) != BLF_FLEXRAYMESSAGE_STATE_NFI0x08) {
      /* NFI needs to be inversed !? */
      tmpbuf[2] |= BLF_DLT_FLEXRAY_NFI0x20;
  }

  if ((frheader.frameState & BLF_FLEXRAYMESSAGE_STATE_STFI0x10) == BLF_FLEXRAYMESSAGE_STATE_STFI0x10) {
      tmpbuf[2] |= BLF_DLT_FLEXRAY_STFI0x08;
  }

  tmpbuf[3] = 0x00ff & frheader.frameId;
  tmpbuf[4] = (0xfe & frheader.length) | ((frheader.headerCrc & 0x0400) >> 10);
  tmpbuf[5] = (0x03fc & frheader.headerCrc) >> 2;
  tmpbuf[6] = ((0x0003 & frheader.headerCrc) << 6) | (0x3f & frheader.cycle);

  ws_buffer_assure_space(&params->rec->data, sizeof(tmpbuf) + payload_length_valid);
  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  caplen = sizeof(tmpbuf) + payload_length_valid;
  len = sizeof(tmpbuf) + payload_length;

  if (payload_length_valid > 0 && !blf_read_bytes(params, data_start + sizeof(frheader), ws_buffer_end_ptr(&params->rec->data), payload_length_valid, err, err_info)) {
      ws_debug("copying flexray payload failed")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2366, __func__, "copying flexray payload failed"); } } while
 (0);
      return false0;
  }
  ws_buffer_increase_length(&params->rec->data, payload_length_valid);

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_FLEXRAY106, frheader.channel, UINT16_MAX(65535), caplen, len);
  blf_add_direction_option(params, frheader.dir);

  return true1;
2375}

2377static bool_Bool
2378blf_read_flexrayrcvmessageex(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, bool_Bool ext) {
  blf_flexrayrcvmessage_t frheader;

  uint16_t payload_length;
  uint16_t payload_length_valid;
  uint8_t  tmpbuf[7];
  int      frheadersize = sizeof(frheader);
  unsigned caplen, len;

  if (ext) {
      frheadersize += 40;
  }

  if ((int64_t)object_length < (data_start - block_start) + frheadersize) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup_printf("blf: %s: not enough bytes for flexrayheader in object",wmem_strdup_printf(((void*)0), "blf: %s: not enough bytes for flexrayheader in object"
, ext ? "FLEXRAY_RCVMESSAGE_EX" : "FLEXRAY_RCVMESSAGE")
                                  ext ? "FLEXRAY_RCVMESSAGE_EX" : "FLEXRAY_RCVMESSAGE")wmem_strdup_printf(((void*)0), "blf: %s: not enough bytes for flexrayheader in object"
, ext ? "FLEXRAY_RCVMESSAGE_EX" : "FLEXRAY_RCVMESSAGE");
      ws_debug("not enough bytes for flexrayheader in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2395, __func__, "not enough bytes for flexrayheader in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &frheader, sizeof(frheader), err, err_info)) {
      ws_debug("not enough bytes for flexrayheader header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2400, __func__, "not enough bytes for flexrayheader header in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_flexrayrcvmessage(&frheader);

  if (!ext) {
      frheader.dir &= 0xff;
      frheader.cycle &= 0xff;
  }

  payload_length = frheader.payloadLength;
  payload_length_valid = frheader.payloadLengthValid;

  if ((frheader.payloadLength & 0x01) == 0x01) {
      ws_debug("reading odd length in FlexRay!?")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2414, __func__, "reading odd length in FlexRay!?"); } } while
 (0);
  }

  if (payload_length_valid > object_length - (data_start - block_start) - frheadersize) {
      ws_debug("shortening FlexRay payload because buffer is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2418, __func__, "shortening FlexRay payload because buffer is too short!"
); } } while (0);
      payload_length_valid = (uint8_t)(object_length - (data_start - block_start) - frheadersize);
  }

  /* Measurement Header */
  /* TODO: It seems that this format support both channels at the same time!? */
  if (frheader.channelMask == BLF_FLEXRAYRCVMSG_CHANNELMASK_A0x01) {
      tmpbuf[0] = BLF_FLEXRAYDATA_FRAME0x01;
  } else {
      tmpbuf[0] = BLF_FLEXRAYDATA_FRAME0x01 | BLF_FLEXRAYDATA_CHANNEL_B0x80;
  }

  /* Error Flags */
  tmpbuf[1] = 0;

  /* Frame Header */
  tmpbuf[2] = ((0x0700 & frheader.frameId) >> 8);
  if ((frheader.frameFlags & BLF_FLEXRAYRCVMSG_FRAME_FLAG_PAYLOAD_PREAM0x00000010) == BLF_FLEXRAYRCVMSG_FRAME_FLAG_PAYLOAD_PREAM0x00000010) {
      tmpbuf[2] |= BLF_DLT_FLEXRAY_PPI0x40;
  }

  if ((frheader.frameFlags & BLF_FLEXRAYRCVMSG_FRAME_FLAG_SYNC0x00000004) == BLF_FLEXRAYRCVMSG_FRAME_FLAG_SYNC0x00000004) {
      tmpbuf[2] |= BLF_DLT_FLEXRAY_SFI0x10;
  }

  if ((frheader.frameFlags & BLF_FLEXRAYRCVMSG_FRAME_FLAG_NULL_FRAME0x00000001) != BLF_FLEXRAYRCVMSG_FRAME_FLAG_NULL_FRAME0x00000001) {
      /* NFI needs to be inversed !? */
      tmpbuf[2] |= BLF_DLT_FLEXRAY_NFI0x20;
  }

  if ((frheader.frameFlags & BLF_FLEXRAYRCVMSG_FRAME_FLAG_STARTUP0x00000008) == BLF_FLEXRAYRCVMSG_FRAME_FLAG_STARTUP0x00000008) {
      tmpbuf[2] |= BLF_DLT_FLEXRAY_STFI0x08;
  }

  tmpbuf[3] = 0x00ff & frheader.frameId;
  tmpbuf[4] = (0xfe & frheader.payloadLength) | ((frheader.headerCrc1 & 0x0400) >> 10);
  tmpbuf[5] = (0x03fc & frheader.headerCrc1) >> 2;
  tmpbuf[6] = ((0x0003 & frheader.headerCrc1) << 6) | (0x3f & frheader.cycle);

  ws_buffer_assure_space(&params->rec->data, sizeof(tmpbuf) + payload_length_valid);
  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  caplen = sizeof(tmpbuf) + payload_length_valid;
  len = sizeof(tmpbuf) + payload_length;

  if (payload_length_valid > 0 && !blf_read_bytes(params, data_start + frheadersize, ws_buffer_end_ptr(&params->rec->data), payload_length_valid, err, err_info)) {
      ws_debug("copying flexray payload failed")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2463, __func__, "copying flexray payload failed"); } } while
 (0);
      return false0;
  }
  ws_buffer_increase_length(&params->rec->data, payload_length_valid);

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_FLEXRAY106, frheader.channelMask, UINT16_MAX(65535), caplen, len);
  blf_add_direction_option(params, frheader.dir);

  return true1;
2472}

2474static bool_Bool
2475blf_read_linmessage(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, bool_Bool crc_error) {
  blf_linmessage_t         linmessage;

  uint8_t  payload_length;
  unsigned len;

  if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup_printf("blf: %s: not enough bytes for %s in object", crc_error ? "LIN_CRC_ERROR" : "LIN_MESSAGE", crc_error ? "lincrcerror" : "linmessage")wmem_strdup_printf(((void*)0), "blf: %s: not enough bytes for %s in object"
, crc_error ? "LIN_CRC_ERROR" : "LIN_MESSAGE", crc_error ? "lincrcerror"
 : "linmessage");
      ws_debug("not enough bytes for %s in object", crc_error ? "lincrcerror" : "linmessage")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2484, __func__, "not enough bytes for %s in object", crc_error
 ? "lincrcerror" : "linmessage"); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
      ws_debug("not enough bytes for %s in file", crc_error ? "lincrcerror" : "linmessage")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2489, __func__, "not enough bytes for %s in file", crc_error
 ? "lincrcerror" : "linmessage"); } } while (0);
      return false0;
  }
  fix_endianness_blf_linmessage(&linmessage);

  linmessage.dlc &= 0x0f;
  linmessage.id &= 0x3f;

  payload_length = MIN(linmessage.dlc, 8)(((linmessage.dlc) < (8)) ? (linmessage.dlc) : (8));

  uint8_t tmpbuf[8];
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = linmessage.dlc << 4; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  tmpbuf[5] = linmessage.id; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = (uint8_t)(linmessage.crc & 0xff); /* checksum */
  tmpbuf[7] = 0; /* errors */

  if (crc_error) {
      tmpbuf[7] |= 0x08;
  }

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  ws_buffer_append(&params->rec->data, linmessage.data, payload_length);
  len = sizeof(tmpbuf) + payload_length;

  /* make sure that the payload is 4 or 8 bytes long */
  const uint8_t padding[4] = { 0, 0, 0, 0 };
  if (payload_length < 4) {
      ws_buffer_append(&params->rec->data, padding, 4 - payload_length);
      len += 4 - payload_length;
  } else if (payload_length > 4 && payload_length < 8) {
      ws_buffer_append(&params->rec->data, padding, 8 - payload_length);
      len += 8 - payload_length;
  }

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linmessage.channel, UINT16_MAX(65535), len, len);
  blf_add_direction_option(params, linmessage.dir);

  return true1;
2531}

2533static bool_Bool
2534blf_read_linrcverror(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_linrcverror_t   linmessage;

  if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_RCV_ERROR: not enough bytes for linrcverror in object")wmem_strdup(((void*)0), "blf: LIN_RCV_ERROR: not enough bytes for linrcverror in object"
);
      ws_debug("not enough bytes for linrcverror in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2540, __func__, "not enough bytes for linrcverror in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
      ws_debug("not enough bytes for linrcverror in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2545, __func__, "not enough bytes for linrcverror in file")
; } } while (0);
      return false0;
  }
  linmessage.channel = GUINT16_FROM_LE(linmessage.channel)(((guint16) (linmessage.channel)));

  linmessage.dlc &= 0x0f;
  linmessage.id &= 0x3f;

  uint8_t tmpbuf[12];
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = linmessage.dlc << 4; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  tmpbuf[5] = linmessage.id; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = 0; /* checksum */
  /* XXX - This object can represent many different error types.
   * For now we always treat it as framing error,
   * but in the future we should expand it. */
  tmpbuf[7] = LIN_ERROR_FRAMING_ERROR0x02; /* errors */
  tmpbuf[8] = 0;
  tmpbuf[9] = 0;
  tmpbuf[10] = 0;
  tmpbuf[11] = 0;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linmessage.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));

  return true1;
2574}

2576static bool_Bool
2577blf_read_linsenderror(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_linsenderror_t         linmessage;

  if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_SND_ERROR: not enough bytes for linsenderror in object")wmem_strdup(((void*)0), "blf: LIN_SND_ERROR: not enough bytes for linsenderror in object"
);
      ws_debug("not enough bytes for linsenderror in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2583, __func__, "not enough bytes for linsenderror in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
      ws_debug("not enough bytes for linsenderror in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2588, __func__, "not enough bytes for linsenderror in file"
); } } while (0);
      return false0;
  }
  linmessage.channel = GUINT16_FROM_LE(linmessage.channel)(((guint16) (linmessage.channel)));

  linmessage.dlc &= 0x0f;
  linmessage.id &= 0x3f;

  uint8_t tmpbuf[12];
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = linmessage.dlc << 4; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  tmpbuf[5] = linmessage.id; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = 0; /* checksum */
  tmpbuf[7] = LIN_ERROR_NO_SLAVE_RESPONSE0x01; /* errors */
  tmpbuf[8] = 0;
  tmpbuf[9] = 0;
  tmpbuf[10] = 0;
  tmpbuf[11] = 0;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linmessage.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));

  return true1;
2614}

2616static bool_Bool
2617blf_read_linwakeupevent(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_linwakeupevent_t    linevent;

  if (object_length < (data_start - block_start) + (int)sizeof(linevent)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_WAKEUP: not enough bytes for linwakeup in object")wmem_strdup(((void*)0), "blf: LIN_WAKEUP: not enough bytes for linwakeup in object"
);
      ws_debug("not enough bytes for linwakeup in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2623, __func__, "not enough bytes for linwakeup in object")
; } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linevent, sizeof(linevent), err, err_info)) {
      ws_debug("not enough bytes for linwakeup in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2628, __func__, "not enough bytes for linwakeup in file"); }
 } while (0);
      return false0;
  }
  linevent.channel = GUINT16_FROM_LE(linevent.channel)(((guint16) (linevent.channel)));

  uint8_t tmpbuf[12]; /* LIN events have a fixed length of 12 bytes */
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = 3 << 2; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  tmpbuf[5] = 0; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = 0; /* checksum */
  tmpbuf[7] = 0; /* errors */

  /* Wake-up event */
  tmpbuf[8] = 0xB0;
  tmpbuf[9] = 0xB0;
  tmpbuf[10] = 0x00;
  tmpbuf[11] = 0x04;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linevent.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));

  return true1;
2654}

2656static bool_Bool
2657blf_read_linmessage2(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, uint16_t object_version) {
  blf_linmessage2_t         linmessage;

  uint8_t  payload_length;
  unsigned len;

  if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_MESSAGE2: not enough bytes for linmessage2 in object")wmem_strdup(((void*)0), "blf: LIN_MESSAGE2: not enough bytes for linmessage2 in object"
);
      ws_debug("not enough bytes for linmessage2 in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2666, __func__, "not enough bytes for linmessage2 in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
      ws_debug("not enough bytes for linmessage2 in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2671, __func__, "not enough bytes for linmessage2 in file")
; } } while (0);
      return false0;
  }
  fix_endianness_blf_linmessage2(&linmessage);

  linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc &= 0x0f;
  linmessage.linDataByteTimestampEvent.linMessageDescriptor.id &= 0x3f;

  payload_length = MIN(linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc, 8)(((linmessage.linDataByteTimestampEvent.linMessageDescriptor.
dlc) < (8)) ? (linmessage.linDataByteTimestampEvent.linMessageDescriptor
.dlc) : (8));

  uint8_t tmpbuf[8];
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc << 4; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  if (object_version >= 1) { /* The 'checksumModel' field is valid only if objectVersion >= 1 */
      switch (linmessage.linDataByteTimestampEvent.linMessageDescriptor.checksumModel) {
      case 0:
          tmpbuf[4] |= 1; /* Classic */
          break;
      case 1:
          tmpbuf[4] |= 2; /* Enhanced */
          break;
      default:
          break;
      }
  }
  tmpbuf[5] = linmessage.linDataByteTimestampEvent.linMessageDescriptor.id; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = (uint8_t)(linmessage.crc & 0xff); /* checksum */
  tmpbuf[7] = 0; /* errors */

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  ws_buffer_append(&params->rec->data, linmessage.data, payload_length);
  len = sizeof(tmpbuf) + payload_length;

  /* make sure that the payload is 4 or 8 bytes long */
  const uint8_t padding[4] = { 0, 0, 0, 0 };
  if (payload_length < 4) {
      ws_buffer_append(&params->rec->data, padding, 4 - payload_length);
      len += 4 - payload_length;
  } else if (payload_length > 4 && payload_length < 8) {
      ws_buffer_append(&params->rec->data, padding, 8 - payload_length);
      len += 8 - payload_length;
  }

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linmessage.linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel, UINT16_MAX(65535), len, len);
  blf_add_direction_option(params, linmessage.dir);

  return true1;
2721}

2723static bool_Bool
2724blf_read_lincrcerror2(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, uint16_t object_version) {
  blf_lincrcerror2_t         linmessage;

  uint8_t  payload_length;
  unsigned len;

  if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_CRC_ERROR2: not enough bytes for lincrcerror2 in object")wmem_strdup(((void*)0), "blf: LIN_CRC_ERROR2: not enough bytes for lincrcerror2 in object"
);
      ws_debug("not enough bytes for lincrcerror2 in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2733, __func__, "not enough bytes for lincrcerror2 in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
      ws_debug("not enough bytes for lincrcerror2 in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2738, __func__, "not enough bytes for lincrcerror2 in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_lincrcerror2(&linmessage);

  linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc &= 0x0f;
  linmessage.linDataByteTimestampEvent.linMessageDescriptor.id &= 0x3f;

  payload_length = MIN(linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc, 8)(((linmessage.linDataByteTimestampEvent.linMessageDescriptor.
dlc) < (8)) ? (linmessage.linDataByteTimestampEvent.linMessageDescriptor
.dlc) : (8));

  uint8_t tmpbuf[12];
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc << 4; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  if (object_version >= 1) { /* The 'checksumModel' field is valid only if objectVersion >= 1 */
      switch (linmessage.linDataByteTimestampEvent.linMessageDescriptor.checksumModel) {
      case 0:
          tmpbuf[4] |= 1; /* Classic */
          break;
      case 1:
          tmpbuf[4] |= 2; /* Enhanced */
          break;
      default:
          break;
      }
  }
  tmpbuf[5] = linmessage.linDataByteTimestampEvent.linMessageDescriptor.id; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = (uint8_t)(linmessage.crc & 0xff); /* checksum */
  tmpbuf[7] = LIN_ERROR_CHECKSUM_ERROR0x08; /* errors */
  tmpbuf[8] = 0;
  tmpbuf[9] = 0;
  tmpbuf[10] = 0;
  tmpbuf[11] = 0;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  ws_buffer_append(&params->rec->data, linmessage.data, payload_length);
  len = sizeof(tmpbuf) + payload_length;

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linmessage.linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel, UINT16_MAX(65535), len, len);
  blf_add_direction_option(params, linmessage.dir);

  return true1;
2782}

2784static bool_Bool
2785blf_read_linrcverror2(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, uint16_t object_version) {
  blf_linrcverror2_t         linmessage;

  uint8_t  payload_length;
  unsigned len;

  if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_RCV_ERROR2: not enough bytes for linrcverror2 in object")wmem_strdup(((void*)0), "blf: LIN_RCV_ERROR2: not enough bytes for linrcverror2 in object"
);
      ws_debug("not enough bytes for linrcverror2 in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2794, __func__, "not enough bytes for linrcverror2 in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
      ws_debug("not enough bytes for linrcverror2 in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2799, __func__, "not enough bytes for linrcverror2 in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_linrcverror2(&linmessage);

  linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc &= 0x0f;
  linmessage.linDataByteTimestampEvent.linMessageDescriptor.id &= 0x3f;

  if (linmessage.hasDataBytes) {
      payload_length = MIN(linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc, 8)(((linmessage.linDataByteTimestampEvent.linMessageDescriptor.
dlc) < (8)) ? (linmessage.linDataByteTimestampEvent.linMessageDescriptor
.dlc) : (8));
  }
  else {
      payload_length = 0;
  }

  uint8_t tmpbuf[12];
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc << 4; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  if (object_version >= 1) { /* The 'checksumModel' field is valid only if objectVersion >= 1 */
      switch (linmessage.linDataByteTimestampEvent.linMessageDescriptor.checksumModel) {
      case 0:
          tmpbuf[4] |= 1; /* Classic */
          break;
      case 1:
          tmpbuf[4] |= 2; /* Enhanced */
          break;
      default:
          break;
      }
  }
  tmpbuf[5] = linmessage.linDataByteTimestampEvent.linMessageDescriptor.id; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = 0; /* checksum */
  /* XXX - This object can represent many different error types.
   * For now we always treat it as framing error,
   * but in the future we should expand it. */
  tmpbuf[7] = LIN_ERROR_FRAMING_ERROR0x02; /* errors */
  tmpbuf[8] = 0;
  tmpbuf[9] = 0;
  tmpbuf[10] = 0;
  tmpbuf[11] = 0;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));
  if (payload_length > 0) {
      ws_buffer_append(&params->rec->data, linmessage.data, payload_length);
  }
  len = sizeof(tmpbuf) + payload_length;

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linmessage.linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel, UINT16_MAX(65535), len, len);

  return true1;
2852}

2854static bool_Bool
2855blf_read_linsenderror2(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, uint16_t object_version) {
  blf_linsenderror2_t         linmessage;

  if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_SND_ERROR2: not enough bytes for linsenderror2 in object")wmem_strdup(((void*)0), "blf: LIN_SND_ERROR2: not enough bytes for linsenderror2 in object"
);
      ws_debug("not enough bytes for linsenderror2 in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2861, __func__, "not enough bytes for linsenderror2 in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
      ws_debug("not enough bytes for linsenderror2 in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2866, __func__, "not enough bytes for linsenderror2 in file"
); } } while (0);
      return false0;
  }
  fix_endianness_blf_linsenderror2(&linmessage);

  linmessage.linMessageDescriptor.dlc &= 0x0f;
  linmessage.linMessageDescriptor.id &= 0x3f;

  uint8_t tmpbuf[12];
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = linmessage.linMessageDescriptor.dlc << 4; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  if (object_version >= 1) { /* The 'checksumModel' field is valid only if objectVersion >= 1 */
      switch (linmessage.linMessageDescriptor.checksumModel) {
      case 0:
          tmpbuf[4] |= 1; /* Classic */
          break;
      case 1:
          tmpbuf[4] |= 2; /* Enhanced */
          break;
      default:
          break;
      }
  }
  tmpbuf[5] = linmessage.linMessageDescriptor.id; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = 0; /* checksum */
  tmpbuf[7] = LIN_ERROR_NO_SLAVE_RESPONSE0x01; /* errors */
  tmpbuf[8] = 0;
  tmpbuf[9] = 0;
  tmpbuf[10] = 0;
  tmpbuf[11] = 0;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linmessage.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));

  return true1;
2905}

2907static bool_Bool
2908blf_read_linwakeupevent2(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_linwakeupevent2_t   linevent;

  if (object_length < (data_start - block_start) + (int)sizeof(linevent)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_WAKEUP2: not enough bytes for linwakeup2 in object")wmem_strdup(((void*)0), "blf: LIN_WAKEUP2: not enough bytes for linwakeup2 in object"
);
      ws_debug("not enough bytes for linwakeup2 in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2914, __func__, "not enough bytes for linwakeup2 in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linevent, sizeof(linevent), err, err_info)) {
      ws_debug("not enough bytes for linwakeup2 in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2919, __func__, "not enough bytes for linwakeup2 in file");
 } } while (0);
      return false0;
  }
  fix_endianness_blf_linwakeupevent2(&linevent);

  uint8_t tmpbuf[12]; /* LIN events have a fixed length of 12 bytes */
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = 3 << 2; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  tmpbuf[5] = 0; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = 0; /* checksum */
  tmpbuf[7] = 0; /* errors */

  /* Wake-up event */
  tmpbuf[8] = 0xB0;
  tmpbuf[9] = 0xB0;
  tmpbuf[10] = 0x00;
  tmpbuf[11] = 0x04;

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linevent.linBusEvent.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));

  return true1;
2945}

2947static bool_Bool
2948blf_read_linsleepmodeevent(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_linsleepmodeevent_t   linevent;

  if (object_length < (data_start - block_start) + (int)sizeof(linevent)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: LIN_SLEEP: not enough bytes for linsleep in object")wmem_strdup(((void*)0), "blf: LIN_SLEEP: not enough bytes for linsleep in object"
);
      ws_debug("not enough bytes for linsleep in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2954, __func__, "not enough bytes for linsleep in object");
 } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &linevent, sizeof(linevent), err, err_info)) {
      ws_debug("not enough bytes for linsleep in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 2959, __func__, "not enough bytes for linsleep in file"); }
 } while (0);
      return false0;
  }
  linevent.channel = GUINT16_FROM_LE(linevent.channel)(((guint16) (linevent.channel)));

  uint8_t tmpbuf[12]; /* LIN events have a fixed length of 12 bytes */
  tmpbuf[0] = 1; /* message format rev = 1 */
  tmpbuf[1] = 0; /* reserved */
  tmpbuf[2] = 0; /* reserved */
  tmpbuf[3] = 0; /* reserved */
  tmpbuf[4] = 3 << 2; /* dlc (4bit) | type (2bit) | checksum type (2bit) */
  tmpbuf[5] = 0; /* parity (2bit) | id (6bit) */
  tmpbuf[6] = 0; /* checksum */
  tmpbuf[7] = 0; /* errors */

  switch (linevent.reason) {
  case BLF_LIN_SLEEP_REASON_GO_TO_SLEEP_FRAME1:
      /* Go-to-Sleep event by Go-to-Sleep frame */
      tmpbuf[8] = 0xB0;
      tmpbuf[9] = 0xB0;
      tmpbuf[10] = 0x00;
      tmpbuf[11] = 0x01;
      break;
  case BLF_LIN_SLEEP_REASON_BUS_IDLE_TIMEOUT2:
  case BLF_LIN_SLEEP_REASON_SILENT_SLEEPMODE_CMD3:
      /* Go-to-Sleep event by Inactivity for more than 4s */
      tmpbuf[8] = 0xB0;
      tmpbuf[9] = 0xB0;
      tmpbuf[10] = 0x00;
      tmpbuf[11] = 0x02;
      break;
  case BLF_LIN_WU_REASON_EXTERNAL_WAKEUP_SIG9:
  case BLF_LIN_WU_REASON_INTERNAL_WAKEUP_SIG10:
  case BLF_LIN_WU_REASON_BUS_TRAFFIC11: /* There's no "wake-up by bus traffic" event in the LIN packet. */
      /* Wake-up event by Wake-up signal */
      tmpbuf[8] = 0xB0;
      tmpbuf[9] = 0xB0;
      tmpbuf[10] = 0x00;
      tmpbuf[11] = 0x04;
      break;
  case BLF_LIN_WU_SLEEP_REASON_START_STATE0:
  case BLF_LIN_NO_SLEEP_REASON_BUS_TRAFFIC18:
      /* If we're just reporting on the initial state,
       * or the interface doesn't want to go to sleep,
       * report the current state as "event". */
      if (linevent.flags & 0x2) {
          /* Wake-up event by Wake-up signal */
          tmpbuf[8] = 0xB0;
          tmpbuf[9] = 0xB0;
          tmpbuf[10] = 0x00;
          tmpbuf[11] = 0x04;
      }
      else {
          /* Go-to-Sleep event by Inactivity for more than 4s */
          tmpbuf[8] = 0xB0;
          tmpbuf[9] = 0xB0;
          tmpbuf[10] = 0x00;
          tmpbuf[11] = 0x02;
      }
      break;
  default:
      tmpbuf[8] = 0x00;
      tmpbuf[9] = 0x00;
      tmpbuf[10] = 0x00;
      tmpbuf[11] = 0x00;
      break;
  }

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN107, linevent.channel, UINT16_MAX(65535), sizeof(tmpbuf), sizeof(tmpbuf));

  return true1;
3032}

3034static bool_Bool
3035blf_parse_xml_port(const xmlChar* str, char** name, uint16_t* hwchannel, bool_Bool* simulated) {
  static const char name_magic[] = "name=";
  static const char hwchannel_magic[] = "hwchannel=";
  static const char simulated_magic[] = "simulated=";

  if (str == NULL((void*)0)) return false0;

  char** tokens = g_strsplit_set((const gchar*)str, ";", -1);
  if (tokens == NULL((void*)0)) {
      ws_debug("cannot split XML port data")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3044, __func__, "cannot split XML port data"); } } while (0
);
      return false0;
  }

  for (int i = 0; tokens[i] != NULL((void*)0); i++) {
      const char* token = tokens[i];
      if (name && strncmp(token, name_magic, strlen(name_magic)) == 0) {
          if (*name == NULL((void*)0)) {    /* Avoid memory leak in case of repeated names */
              *name = ws_strdup(token + strlen(name_magic))wmem_strdup(((void*)0), token + strlen(name_magic));
          }
      }
      else if (hwchannel && strncmp(token, hwchannel_magic, strlen(hwchannel_magic)) == 0) {
          if (!ws_strtou16(token + strlen(hwchannel_magic), NULL((void*)0), hwchannel)) {
              *hwchannel = UINT16_MAX(65535);
          }
      }
      else if (simulated && strncmp(token, simulated_magic, strlen(simulated_magic)) == 0) {
          if (strlen(token) > strlen(simulated_magic) && token[strlen(simulated_magic)] != '0') {
              *simulated = true1;  /* TODO: Find a way to use this information */
          }
      }
  }

  g_strfreev(tokens);

  return true1;
3070}

3072static int
3073blf_get_xml_pkt_encap(const xmlChar* str) {
  if (str == NULL((void*)0)) return 0;

  if (xmlStrcmp(str, "CAN") == 0) {
      return WTAP_ENCAP_SOCKETCAN125;
  }
  if (xmlStrcmp(str, "FlexRay") == 0) {
      return WTAP_ENCAP_FLEXRAY106;
  }
  if (xmlStrcmp(str, "LIN") == 0) {
      return WTAP_ENCAP_LIN107;
  }
  if (xmlStrcmp(str, "Ethernet") == 0) {
      return WTAP_ENCAP_ETHERNET1;
  }
  if (xmlStrcmp(str, "WLAN") == 0) {    /* Not confirmed with a real capture */
      return WTAP_ENCAP_IEEE_802_1120;
  }

  return WTAP_ENCAP_UNKNOWN0;
3093}


3096/** Extracts the channel and port names from a channels XML.
*
* A sample channels XML looks like this:
*
* <?xml version="1.0" encoding="UTF-8"?>
* <channels version="1">
*   <channel number="1" type="CAN" network="CAN01">
*     <databases>
*       <database file="DB.arxml" path="C:\...\" cluster="CAN01" />
*       <database file="DB.dbc" path="C:\...\" cluster="General" />
*     </databases>
*   </channel>
*   <channel number="1" type="LIN" network="LIN01">
*     <databases>
*       <database file="DB.dbc" path="C:\...\" cluster="General" />
*       <database file="DB.ldf" path="C:\...\" cluster="LIN01" />
*     </databases>
*   </channel>
*   <channel number="1" type="Ethernet" network="ETH01">
*     <databases>
*       <database file="DB.dbc" path="C:\...\" cluster="General" />
*     </databases>
*     <channel_properties>
*       <elist name="ports">
*         <eli name="port">name=Port1;hwchannel=11;simulated=1</eli>
*         <eli name="port">name=Port2;hwchannel=12;simulated=0</eli>
*       </elist>
*     </channel_properties>
*   </channel>
* </channels>
*/
3127static bool_Bool
3128blf_set_xml_channels(blf_params_t* params, const char* text, size_t len) {
  xmlDocPtr doc;
  xmlNodePtr root_element = NULL((void*)0);
  xmlNodePtr channels = NULL((void*)0);

  if (text == NULL((void*)0)) return false0;

  /* Now it can be parsed into a proper structure */
  doc = xmlParseMemory(text, (int)len);
  if (doc == NULL((void*)0)) {
      ws_debug("invalid xml found")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3138, __func__, "invalid xml found"); } } while (0);
      return false0;
  }

  root_element = xmlDocGetRootElement(doc);
  if (root_element == NULL((void*)0)) {
      ws_debug("empty xml doc")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3144, __func__, "empty xml doc"); } } while (0);
      xmlFreeDoc(doc);
      return false0;
  }

  if (xmlStrcmp(root_element->name, (const xmlChar*)"channels") == 0) {
      channels = root_element;
  } else {
      for (xmlNodePtr cur = root_element->children; cur != NULL((void*)0); cur = cur->next) {
          if (cur->type == XML_ELEMENT_NODE && xmlStrcmp(cur->name, (const xmlChar*)"channels") == 0) {
              channels = cur;
              break;
          }
      }
  }

  if (channels == NULL((void*)0)) {
      ws_debug("No channels found")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3161, __func__, "No channels found"); } } while (0);
      xmlFreeDoc(doc);
      return false0;
  }

  for (xmlNodePtr current_channel_node = channels->children; current_channel_node != NULL((void*)0); current_channel_node = current_channel_node->next) {
      if ((current_channel_node->type == XML_ELEMENT_NODE) && (xmlStrcmp(current_channel_node->name, (const xmlChar*)"channel") == 0)) {
          /* Reset the found attributes */
          int pkt_encap = WTAP_ENCAP_UNKNOWN0;
          uint16_t channel = UINT16_MAX(65535);
          char* channel_name = NULL((void*)0);

          for (xmlAttrPtr attr = current_channel_node->properties; attr; attr = attr->next) {
              if (xmlStrcmp(attr->name, (const xmlChar*)"number") == 0) {
                  xmlChar* str_channel = xmlNodeListGetString(current_channel_node->doc, attr->children, 1);
                  if (str_channel != NULL((void*)0)) {
                      ws_strtou16(str_channel, NULL((void*)0), &channel);
                      xmlFree(str_channel);
                  }
              }
              else if (xmlStrcmp(attr->name, (const xmlChar*)"type") == 0) {
                  xmlChar* str_type = xmlNodeListGetString(current_channel_node->doc, attr->children, 1);
                  if (str_type != NULL((void*)0)) {
                      pkt_encap = blf_get_xml_pkt_encap(str_type);
                      xmlFree(str_type);
                  }
              }
              else if (xmlStrcmp(attr->name, (const xmlChar*)"network") == 0) {
                  xmlChar* str_network = xmlNodeListGetString(current_channel_node->doc, attr->children, 1);
                  if (str_network != NULL((void*)0)) {
                      channel_name = ws_strdup((const char*)str_network)wmem_strdup(((void*)0), (const char*)str_network);
                      xmlFree(str_network);
                  }
              }
          }

          if (pkt_encap != WTAP_ENCAP_UNKNOWN0 && channel != UINT16_MAX(65535) && channel_name != NULL((void*)0)) {
              ws_debug("Found channel in XML: PKT_ENCAP: %d, ID: %u, name: %s", pkt_encap, channel, channel_name)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3198, __func__, "Found channel in XML: PKT_ENCAP: %d, ID: %u, name: %s"
, pkt_encap, channel, channel_name); } } while (0);
              blf_prepare_interface_name(params, pkt_encap, channel, UINT16_MAX(65535), channel_name, true1);

              /* Look for ports under the channel properties */
              for (xmlNodePtr channel_property = current_channel_node->children; channel_property != NULL((void*)0); channel_property = channel_property->next) {
                  if ((channel_property->type == XML_ELEMENT_NODE) && (xmlStrcmp(channel_property->name, (const xmlChar*)"channel_properties") == 0)) {
                      for (xmlNodePtr prop_child = channel_property->children; prop_child != NULL((void*)0); prop_child = prop_child->next) {
                          if (prop_child->type == XML_ELEMENT_NODE && xmlStrcmp(prop_child->name, (const xmlChar*)"elist") == 0) {
                              xmlNodePtr elist_node = prop_child;
                              xmlChar* str_name = xmlGetProp(elist_node, (const xmlChar*)"name");
                              if (xmlStrcmp(str_name, (const xmlChar*)"ports") == 0) {
                                  for (xmlNodePtr eli_node = elist_node->children; eli_node != NULL((void*)0); eli_node = eli_node->next) {
                                      if (eli_node->type == XML_ELEMENT_NODE && xmlStrcmp(eli_node->name, (const xmlChar*)"eli") == 0) {
                                          xmlChar* eli_name_attr = xmlGetProp(eli_node, (const xmlChar*)"name");
                                          if (xmlStrcmp(eli_name_attr, (const xmlChar*)"port") == 0) {
                                              char* port_name = NULL((void*)0);
                                              uint16_t hwchannel = UINT16_MAX(65535);
                                              bool_Bool simulated = false0;
                                              char* iface_name = NULL((void*)0);
                                              xmlChar* eli_content = xmlNodeGetContent(eli_node);

                                              bool_Bool res = blf_parse_xml_port(eli_content, &port_name, &hwchannel, &simulated);
                                              if (res && port_name != NULL((void*)0) && hwchannel != UINT16_MAX(65535)) {
                                                  iface_name = ws_strdup_printf("%s::%s", channel_name, port_name)wmem_strdup_printf(((void*)0), "%s::%s", channel_name, port_name
);
                                                  ws_debug("Found channel in XML: PKT_ENCAP: %d, ID: %u, HW ID: %u, name: %s", pkt_encap, channel, hwchannel, iface_name)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3222, __func__, "Found channel in XML: PKT_ENCAP: %d, ID: %u, HW ID: %u, name: %s"
, pkt_encap, channel, hwchannel, iface_name); } } while (0);
                                                  blf_prepare_interface_name(params, pkt_encap, channel, hwchannel, iface_name, true1);
                                                  g_free(iface_name);
                                              }
                                              else {
                                                  ws_debug("port with missing or malformed info found in xml")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3227, __func__, "port with missing or malformed info found in xml"
); } } while (0);
                                              }
                                              g_free(port_name);
                                              xmlFree(eli_content);
                                          }
                                          xmlFree(eli_name_attr);
                                      }
                                  }
                              }
                              xmlFree(str_name);
                          }
                      }
                  }
              }
          }
          g_free(channel_name);
      }
  }

  xmlFreeDoc(doc);
  return true1;
3248}

3250static int
3251blf_read_apptextmessage(blf_params_t *params, int *err, char **err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, blf_metadata_info_t* metadata_info) {
  blf_apptext_t            apptextheader;

  if (object_length < (data_start - block_start) + (int)sizeof(apptextheader)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: APP_TEXT: not enough bytes for apptext header in object")wmem_strdup(((void*)0), "blf: APP_TEXT: not enough bytes for apptext header in object"
);
      ws_debug("not enough bytes for apptext header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3257, __func__, "not enough bytes for apptext header in object"
); } } while (0);
      return BLF_APPTEXT_FAILED0x000000FF;
  }

  if (!blf_read_bytes(params, data_start, &apptextheader, sizeof(apptextheader), err, err_info)) {
      ws_debug("not enough bytes for apptext header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3262, __func__, "not enough bytes for apptext header in file"
); } } while (0);
      return BLF_APPTEXT_FAILED0x000000FF;
  }
  fix_endianness_blf_apptext_header(&apptextheader);

  if (metadata_info->valid && apptextheader.source != BLF_APPTEXT_METADATA0x00000002) {
      /* If we're in the middle of a sequence of metadata objects,
       * but we get an AppText object from another source,
       * skip the previously incomplete object and start fresh.
       */
      metadata_info->valid = false0;
  }

  /* Add an extra byte for a terminating '\0' */
  char* text = g_try_malloc((size_t)apptextheader.textLength + 1);
  if (text == NULL((void*)0)) {
      ws_debug("cannot allocate memory")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3278, __func__, "cannot allocate memory"); } } while (0);
      return BLF_APPTEXT_FAILED0x000000FF;
  }

  if (!blf_read_bytes(params, data_start + sizeof(apptextheader), text, apptextheader.textLength, err, err_info)) {
      ws_debug("not enough bytes for apptext text in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3283, __func__, "not enough bytes for apptext text in file"
); } } while (0);
      g_free(text);
      return BLF_APPTEXT_FAILED0x000000FF;
  }
  text[apptextheader.textLength] = '\0'; /* Here's the '\0' */

  switch (apptextheader.source) {
  case BLF_APPTEXT_CHANNEL0x00000001:
  {

      /* returns a NULL terminated array of NULL terminates strings */
      char** tokens = g_strsplit_set(text, ";", -1);

      if (tokens == NULL((void*)0) || tokens[0] == NULL((void*)0) || tokens[1] == NULL((void*)0)) {
          if (tokens != NULL((void*)0)) {
              g_strfreev(tokens);
          }
          g_free(text);
          return BLF_APPTEXT_CHANNEL0x00000001;
      }

      uint16_t channel = (apptextheader.reservedAppText1 >> 8) & 0xff;
      int pkt_encap;

      switch ((apptextheader.reservedAppText1 >> 16) & 0xff) {
      case BLF_BUSTYPE_CAN1:
          pkt_encap = WTAP_ENCAP_SOCKETCAN125;
          break;

      case BLF_BUSTYPE_FLEXRAY7:
          pkt_encap = WTAP_ENCAP_FLEXRAY106;
          break;

      case BLF_BUSTYPE_LIN5:
          pkt_encap = WTAP_ENCAP_LIN107;
          break;

      case BLF_BUSTYPE_ETHERNET11:
          pkt_encap = WTAP_ENCAP_ETHERNET1;
          break;

      case BLF_BUSTYPE_WLAN13:
          pkt_encap = WTAP_ENCAP_IEEE_802_1120;
          break;

      default:
          pkt_encap = WTAP_ENCAP_UNKNOWN0;
          break;
      }

      if (pkt_encap != WTAP_ENCAP_UNKNOWN0) {
          /* we use lookup to create interface, if not existing yet */
          blf_prepare_interface_name(params, pkt_encap, channel, UINT16_MAX(65535), tokens[1], false0);
      }

      g_strfreev(tokens);
      g_free(text);
      return BLF_APPTEXT_CHANNEL0x00000001;
  }
  case BLF_APPTEXT_METADATA0x00000002:
      if (metadata_info->valid) {
          /* Set the buffer pointer to the end of the previous object */
          params->rec->data.first_free = metadata_info->metadata_cont;
      }
      else {
          /* First object of a sequence of one or more */
          wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_DISSECTOR_NAME12, BLF_APPTEXT_TAG_DISS_DEFAULT"data-text-lines");
          wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_COL_PROT_TEXT33, BLF_APPTEXT_COL_PROT_TEXT"BLF App text");
          switch (((apptextheader.reservedAppText1 >> 24) & 0xff)) {
          case BLF_APPTEXT_XML_GENERAL0x01:
              wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_COL_INFO_TEXT36, BLF_APPTEXT_COL_INFO_TEXT_GENERAL"Metadata: General");
              break;

          case BLF_APPTEXT_XML_CHANNELS0x02:
              wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_COL_INFO_TEXT36, BLF_APPTEXT_COL_INFO_TEXT_CHANNELS"Metadata: Channels");
              break;

          case BLF_APPTEXT_XML_IDENTITY0x03:
              wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_COL_INFO_TEXT36, BLF_APPTEXT_COL_INFO_TEXT_IDENTITY"Metadata: Identity");
              break;

          default:
              wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_COL_INFO_TEXT36, BLF_APPTEXT_COL_INFO_TEXT"Metadata");
          }
          wtap_buffer_append_epdu_end(&params->rec->data);
          metadata_info->payload_start = params->rec->data.first_free;
      }

      ws_buffer_append(&params->rec->data, text, apptextheader.textLength);
      g_free(text);

      if ((apptextheader.reservedAppText1 & 0x00ffffff) > apptextheader.textLength) {
          /* Continues in the next object */
          return BLF_APPTEXT_CONT0x000000FE;
      }

      if (((apptextheader.reservedAppText1 >> 24) & 0xff) == BLF_APPTEXT_XML_CHANNELS0x02) {
          blf_set_xml_channels(params, params->rec->data.data + metadata_info->payload_start, params->rec->data.first_free - metadata_info->payload_start);
      }

      /* Override the timestamp with 0 for metadata objects. Thay can only occur at the beginning of the file, and they usually already have a timestamp of 0. */
      blf_init_rec(params, 0, 0, WTAP_ENCAP_WIRESHARK_UPPER_PDU155, 0, UINT16_MAX(65535), (uint32_t)ws_buffer_length(&params->rec->data), (uint32_t)ws_buffer_length(&params->rec->data));
      return BLF_APPTEXT_METADATA0x00000002;
  case BLF_APPTEXT_COMMENT0x00000000:
  case BLF_APPTEXT_ATTACHMENT0x00000003:
  case BLF_APPTEXT_TRACELINE0x00000004:
  {
      wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_DISSECTOR_NAME12, BLF_APPTEXT_TAG_DISS_DEFAULT"data-text-lines");
      wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_COL_PROT_TEXT33, BLF_APPTEXT_COL_PROT_TEXT"BLF App text");

      char* info_line = NULL((void*)0);
      switch (apptextheader.source) {
      case BLF_APPTEXT_COMMENT0x00000000:
          info_line = ws_strdup_printf("Comment: %s", text)wmem_strdup_printf(((void*)0), "Comment: %s", text);
          break;
      case BLF_APPTEXT_ATTACHMENT0x00000003:
          info_line = ws_strdup_printf("Attachment: %s", text)wmem_strdup_printf(((void*)0), "Attachment: %s", text);
          break;
      case BLF_APPTEXT_TRACELINE0x00000004:
          info_line = ws_strdup_printf("Trace line%s: %s", (apptextheader.reservedAppText1 & 0x00000010) ? "" : " (hidden)", text)wmem_strdup_printf(((void*)0), "Trace line%s: %s", (apptextheader
.reservedAppText1 & 0x00000010) ? "" : " (hidden)", text);
          break;
      default:
          break;
      }

      wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_COL_INFO_TEXT36, info_line);
      wtap_buffer_append_epdu_end(&params->rec->data);

      size_t text_length = strlen(text);  /* The string can contain '\0' before textLength bytes */
      ws_buffer_append(&params->rec->data, text, text_length);    /* The dissector doesn't need NULL-terminated strings */

      /* We'll write this as a WS UPPER PDU packet with a text blob */
      blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_WIRESHARK_UPPER_PDU155, 0, UINT16_MAX(65535), (uint32_t)ws_buffer_length(&params->rec->data), (uint32_t)ws_buffer_length(&params->rec->data));
      g_free(text);
      if (info_line) {
          g_free(info_line);
      }
      return apptextheader.source;
  }
  default:
      g_free(text);
      return BLF_APPTEXT_CHANNEL0x00000001; /* Cheat - no block to write */;
  }
  return BLF_APPTEXT_CHANNEL0x00000001; /* Cheat - no block to write */
3427}

3429static bool_Bool
3430blf_read_ethernet_status(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp, uint16_t object_version) {
  blf_ethernet_status_t            ethernet_status_header;
  uint8_t tmpbuf[24];
  uint64_t linkUpDuration;

  if (object_length < (data_start - block_start) + (int)sizeof(ethernet_status_header) + (int)(object_version >= 1 ? 8 : 0)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: ETHERNET_STATUS: not enough bytes for ethernet status header in object")wmem_strdup(((void*)0), "blf: ETHERNET_STATUS: not enough bytes for ethernet status header in object"
);
      ws_debug("not enough bytes for ethernet status header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3438, __func__, "not enough bytes for ethernet status header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &ethernet_status_header, sizeof(ethernet_status_header), err, err_info)) {
      ws_debug("not enough bytes for ethernet_status_header header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3443, __func__, "not enough bytes for ethernet_status_header header in file"
); } } while (0);
      return false0;
  }

  if (object_version >= 1) {
      if (!blf_read_bytes(params, data_start + sizeof(ethernet_status_header), &linkUpDuration, 8, err, err_info)) {
          ws_debug("not enough bytes for ethernet_status_header header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3449, __func__, "not enough bytes for ethernet_status_header header in file"
); } } while (0);
          return false0;
      }
      linkUpDuration = GUINT64_FROM_LE(linkUpDuration)(((guint64) (linkUpDuration)));
  }

  fix_endianness_blf_ethernet_status_header(&ethernet_status_header);

  phtonu16(tmpbuf, ethernet_status_header.channel);
  phtonu16(tmpbuf + 2, ethernet_status_header.flags);
  tmpbuf[4] = (ethernet_status_header.linkStatus);
  tmpbuf[5] = (ethernet_status_header.ethernetPhy);
  tmpbuf[6] = (ethernet_status_header.duplex);
  tmpbuf[7] = (ethernet_status_header.mdi);
  tmpbuf[8] = (ethernet_status_header.connector);
  tmpbuf[9] = (ethernet_status_header.clockMode);
  tmpbuf[10] = (ethernet_status_header.pairs);
  tmpbuf[11] = (ethernet_status_header.hardwareChannel);
  phtonu32(tmpbuf + 12, ethernet_status_header.bitrate);

  if (object_version >= 1) {
      phtonu64(tmpbuf + 16, linkUpDuration);
  }

  wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_DISSECTOR_NAME12, BLF_APPTEXT_TAG_DISS_ETHSTATUS"blf-ethernetstatus-obj");
  wtap_buffer_append_epdu_end(&params->rec->data);

  ws_buffer_append(&params->rec->data, tmpbuf, (size_t)(object_version >= 1 ? 24 : 16));

  /* We'll write this as a WS UPPER PDU packet with a data blob */
  /* This will create an interface with the "name" of the matching
   * WTAP_ENCAP_ETHERNET interface with the same channel and hardware
   * channel prefixed with "STATUS" and with a different interface ID,
   * because IDBs in pcapng can only have one linktype.
   * The other option would be to write everything as UPPER_PDU, including
   * the Ethernet data (with one of the "eth_" dissectors.)
   */
  char* iface_name = ws_strdup_printf("STATUS-ETH-%u-%u", ethernet_status_header.channel, ethernet_status_header.hardwareChannel)wmem_strdup_printf(((void*)0), "STATUS-ETH-%u-%u", ethernet_status_header
.channel, ethernet_status_header.hardwareChannel);
  blf_lookup_interface(params, WTAP_ENCAP_WIRESHARK_UPPER_PDU155, ethernet_status_header.channel, ethernet_status_header.hardwareChannel, iface_name);
  g_free(iface_name);
  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_WIRESHARK_UPPER_PDU155, ethernet_status_header.channel, ethernet_status_header.hardwareChannel, (uint32_t)ws_buffer_length(&params->rec->data), (uint32_t)ws_buffer_length(&params->rec->data));

  if ((ethernet_status_header.flags & BLF_ETH_STATUS_HARDWARECHANNEL0x0100) == BLF_ETH_STATUS_HARDWARECHANNEL0x0100) {
      /* If HW channel valid */
      wtap_block_add_uint32_option(params->rec->block, OPT_PKT_QUEUE6, ethernet_status_header.hardwareChannel);
  }

  return true1;
3497}

3499static bool_Bool
3500blf_read_ethernet_phystate(blf_params_t* params, int* err, char** err_info, int64_t block_start, int64_t data_start, int64_t object_length, uint32_t flags, uint64_t object_timestamp) {
  blf_ethernet_phystate_t ethernet_phystate_header;
  uint8_t tmpbuf[8];

  if (object_length < (data_start - block_start) + (int)sizeof(ethernet_phystate_header)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: ETHERNET_PHY_STATE: not enough bytes for ethernet phystate header in object")wmem_strdup(((void*)0), "blf: ETHERNET_PHY_STATE: not enough bytes for ethernet phystate header in object"
);
      ws_debug("not enough bytes for ethernet phystate header in object")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3507, __func__, "not enough bytes for ethernet phystate header in object"
); } } while (0);
      return false0;
  }

  if (!blf_read_bytes(params, data_start, &ethernet_phystate_header, sizeof(ethernet_phystate_header), err, err_info)) {
      ws_debug("not enough bytes for ethernet phystate header in file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3512, __func__, "not enough bytes for ethernet phystate header in file"
); } } while (0);
      return false0;
  }

  fix_endianness_blf_ethernet_phystate_header(&ethernet_phystate_header);

  phtonu16(tmpbuf, ethernet_phystate_header.channel);
  phtonu16(tmpbuf + 2, ethernet_phystate_header.flags);
  tmpbuf[4] = (ethernet_phystate_header.phyState);
  tmpbuf[5] = (ethernet_phystate_header.phyEvent);
  tmpbuf[6] = (ethernet_phystate_header.hardwareChannel);
  tmpbuf[7] = (ethernet_phystate_header.res1);

  wtap_buffer_append_epdu_string(&params->rec->data, EXP_PDU_TAG_DISSECTOR_NAME12, BLF_APPTEXT_TAG_DISS_ETHPHYSTATUS"blf-ethernetphystate-obj");
  wtap_buffer_append_epdu_end(&params->rec->data);

  ws_buffer_append(&params->rec->data, tmpbuf, sizeof(tmpbuf));

  /* We'll write this as a WS UPPER PDU packet with a data blob */
  /* This will create an interface with the "name" of the matching
   * WTAP_ENCAP_ETHERNET interface with the same channel and hardware
   * channel prefixed with "STATUS" and with a different interface ID,
   * because IDBs in pcapng can only have one linktype.
   * The other option would be to write everything as UPPER_PDU, including
   * the Ethernet data (with one of the "eth_" dissectors.)
   */
  char* iface_name = ws_strdup_printf("STATUS-ETH-%u-%u", ethernet_phystate_header.channel, ethernet_phystate_header.hardwareChannel)wmem_strdup_printf(((void*)0), "STATUS-ETH-%u-%u", ethernet_phystate_header
.channel, ethernet_phystate_header.hardwareChannel);
  blf_lookup_interface(params, WTAP_ENCAP_WIRESHARK_UPPER_PDU155, ethernet_phystate_header.channel, ethernet_phystate_header.hardwareChannel, iface_name);
  g_free(iface_name);
  blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_WIRESHARK_UPPER_PDU155, ethernet_phystate_header.channel, ethernet_phystate_header.hardwareChannel, (uint32_t)ws_buffer_length(&params->rec->data), (uint32_t)ws_buffer_length(&params->rec->data));

  if ((ethernet_phystate_header.flags & BLF_PHY_STATE_HARDWARECHANNEL0x0004) == BLF_PHY_STATE_HARDWARECHANNEL0x0004) {
      /* If HW channel valid */
      wtap_block_add_uint32_option(params->rec->block, OPT_PKT_QUEUE6, ethernet_phystate_header.hardwareChannel);
  }

  return true1;
3549}

3551static bool_Bool
3552blf_read_block(blf_params_t *params, int64_t start_pos, int *err, char **err_info) {
  blf_blockheader_t        header;
  blf_logobjectheader_t    logheader;
  blf_logobjectheader2_t   logheader2;
  blf_logobjectheader3_t   logheader3;
  uint32_t                 flags;
  uint64_t                 object_timestamp;
  uint16_t                 object_version;
  blf_metadata_info_t      metadata_info = { 0, 0, false0 };
  int64_t                  last_metadata_start = 0;

  while (1) {
      /* Find Object */

      /* Resetting buffer */
      params->rec->data.first_free = params->rec->data.start;

      while (1) {
          if (!blf_read_bytes_or_eof(params, start_pos, &header, sizeof header, err, err_info)) {
              ws_debug("not enough bytes for block header or unsupported file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3571, __func__, "not enough bytes for block header or unsupported file"
); } } while (0);
              if (*err == WTAP_ERR_SHORT_READ-12) {
                  /* we have found the end that is not a short read therefore. */
                  *err = 0;
                  g_free(*err_info);
                  *err_info = NULL((void*)0);
              }
              return false0;
          }

          fix_endianness_blf_blockheader(&header);

          if (memcmp(header.magic, blf_obj_magic, sizeof(blf_obj_magic))) {
              ws_debug("object magic is not LOBJ (pos: 0x%" PRIx64 ")", start_pos)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3584, __func__, "object magic is not LOBJ (pos: 0x%" "l" "x"
 ")", start_pos); } } while (0);
          }
          else {
              break;
          }

          /* we are moving back and try again but 1 byte later */
          /* TODO: better understand how this paddings works... */
          start_pos++;
      }
      params->blf_data->start_of_last_obj = start_pos;

      if (!params->random) {
          /* Make sure that we start after this object next time,
           * but only if it's a linear read. We can have random reads
           * during the linear read, so we have to make sure we don't
           * lose track of our position.
           */
          params->blf_data->current_real_seek_pos = start_pos + MAX(MAX(16, header.object_length), header.header_length)((((((16) > (header.object_length)) ? (16) : (header.object_length
))) > (header.header_length)) ? ((((16) > (header.object_length
)) ? (16) : (header.object_length))) : (header.header_length)
);
      }

      switch (header.header_type) {
      case BLF_HEADER_TYPE_DEFAULT1:
          if (!blf_read_log_object_header(params, err, err_info, start_pos + sizeof(blf_blockheader_t), start_pos + header.header_length, &logheader)) {
              return false0;
          }
          flags = logheader.flags;
          object_timestamp = logheader.object_timestamp;
          object_version = logheader.object_version;
          break;

      case BLF_HEADER_TYPE_22:
          if (!blf_read_log_object_header2(params, err, err_info, start_pos + sizeof(blf_blockheader_t), start_pos + header.header_length, &logheader2)) {
              return false0;
          }
          flags = logheader2.flags;
          object_timestamp = logheader2.object_timestamp;
          object_version = logheader2.object_version;
          break;

      case BLF_HEADER_TYPE_33:
          if (!blf_read_log_object_header3(params, err, err_info, start_pos + sizeof(blf_blockheader_t), start_pos + header.header_length, &logheader3)) {
              return false0;
          }
          flags = logheader3.flags;
          object_timestamp = logheader3.object_timestamp;
          object_version = logheader3.object_version;
          break;

      default:
          *err = WTAP_ERR_UNSUPPORTED-4;
          *err_info = ws_strdup_printf("blf: unknown header type %u", header.header_type)wmem_strdup_printf(((void*)0), "blf: unknown header type %u",
 header.header_type);
          ws_debug("unknown header type")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3636, __func__, "unknown header type"); } } while (0);
          return false0;
      }

      if (metadata_info.valid && header.object_type != BLF_OBJTYPE_APP_TEXT65) {
          /* If we're in the middle of a sequence of AppText metadata objects,
           * but we get an AppText object from another source,
           * skip the previous incomplete packet and start fresh.
           */
          metadata_info.valid = false0;
      }

      switch (header.object_type) {
      case BLF_OBJTYPE_LOG_CONTAINER10:
          *err = WTAP_ERR_UNSUPPORTED-4;
          *err_info = ws_strdup("blf: log container in log container not supported")wmem_strdup(((void*)0), "blf: log container in log container not supported"
);
          ws_debug("log container in log container not supported")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3652, __func__, "log container in log container not supported"
); } } while (0);
          return false0;

      case BLF_OBJTYPE_ETHERNET_FRAME71:
          return blf_read_ethernetframe(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_ETHERNET_FRAME_EX120:
          return blf_read_ethernetframe_ext(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, false0);

      case BLF_OBJTYPE_ETHERNET_RX_ERROR102:
          return blf_read_ethernet_rxerror(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_ETHERNET_ERROR_EX122:
          return blf_read_ethernetframe_ext(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, true1);

      case BLF_OBJTYPE_WLAN_FRAME93:
          return blf_read_wlanframe(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_CAN_MESSAGE1:
          return blf_read_canmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, false0);

      case BLF_OBJTYPE_CAN_ERROR2:
          return blf_read_canerror(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, false0);

      case BLF_OBJTYPE_CAN_OVERLOAD3:
          return blf_read_canerror(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, true1);

      case BLF_OBJTYPE_CAN_MESSAGE286:
          return blf_read_canmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, true1);

      case BLF_OBJTYPE_CAN_ERROR_EXT73:
          return blf_read_canerrorext(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_CAN_FD_MESSAGE100:
          return blf_read_canfdmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_CAN_FD_MESSAGE_64101:
          return blf_read_canfdmessage64(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_CAN_FD_ERROR_64104:
          return blf_read_canfderror64(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_CAN_XL_CHANNEL_FRAME139:
          return blf_read_canxlchannelframe(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_FLEXRAY_DATA29:
          return blf_read_flexraydata(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_FLEXRAY_MESSAGE41:
          return blf_read_flexraymessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_FLEXRAY_RCVMESSAGE50:
          return blf_read_flexrayrcvmessageex(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, false0);

      case BLF_OBJTYPE_FLEXRAY_RCVMESSAGE_EX66:
          return blf_read_flexrayrcvmessageex(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, true1);

      case BLF_OBJTYPE_LIN_MESSAGE11:
          return blf_read_linmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, false0);

      case BLF_OBJTYPE_LIN_CRC_ERROR12:
          return blf_read_linmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, true1);

      case BLF_OBJTYPE_LIN_RCV_ERROR14:
          return blf_read_linrcverror(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_LIN_SND_ERROR15:
          return blf_read_linsenderror(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_LIN_WAKEUP21:
          return blf_read_linwakeupevent(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_LIN_MESSAGE257:
          return blf_read_linmessage2(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, object_version);

      case BLF_OBJTYPE_LIN_CRC_ERROR260:
          return blf_read_lincrcerror2(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, object_version);

      case BLF_OBJTYPE_LIN_RCV_ERROR261:
          return blf_read_linrcverror2(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, object_version);

      case BLF_OBJTYPE_LIN_SND_ERROR258:
          return blf_read_linsenderror2(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, object_version);

      case BLF_OBJTYPE_LIN_WAKEUP262:
          return blf_read_linwakeupevent2(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_LIN_SLEEP20:
          return blf_read_linsleepmodeevent(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_APP_TEXT65:
      {
          int result = blf_read_apptextmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, &metadata_info);
          if (result == BLF_APPTEXT_CONT0x000000FE) {
              if (!metadata_info.valid) {
                  /* First object of a sequence, save its start position */
                  last_metadata_start = start_pos;
                  metadata_info.valid = true1;
              }
              /* Save a pointer to the end of the buffer */
              metadata_info.metadata_cont = params->rec->data.first_free;
          }
          else {
              if (result == BLF_APPTEXT_METADATA0x00000002 && metadata_info.valid) {
                  /* Last object of a sequence, restore the start position of the first object */
                  params->blf_data->start_of_last_obj = last_metadata_start;
              }
              /* Reset everything and start fresh */
              metadata_info.valid = false0;
          }
          switch (result) {
              case BLF_APPTEXT_FAILED0x000000FF:
                  return false0;
              case BLF_APPTEXT_COMMENT0x00000000:
              case BLF_APPTEXT_METADATA0x00000002:
              case BLF_APPTEXT_ATTACHMENT0x00000003:
              case BLF_APPTEXT_TRACELINE0x00000004:
                  return true1;
              case BLF_APPTEXT_CHANNEL0x00000001:
              case BLF_APPTEXT_CONT0x000000FE:
              default:
                  /* we do not return since there is no packet to show here */
                  start_pos += MAX(MAX(16, header.object_length), header.header_length)((((((16) > (header.object_length)) ? (16) : (header.object_length
))) > (header.header_length)) ? ((((16) > (header.object_length
)) ? (16) : (header.object_length))) : (header.header_length)
);
                  break;
          }
      }
          break;

      case BLF_OBJTYPE_ETHERNET_STATUS103:
          return blf_read_ethernet_status(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, object_version);

      case BLF_OBJTYPE_ETHERNET_PHY_STATE133:
          return blf_read_ethernet_phystate(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);

      case BLF_OBJTYPE_ENV_INTEGER6:
      case BLF_OBJTYPE_ENV_DOUBLE7:
      case BLF_OBJTYPE_ENV_STRING8:
      case BLF_OBJTYPE_ENV_DATA9:
      case BLF_OBJTYPE_SYS_VARIABLE72:
      case BLF_OBJTYPE_RESERVED5115: /* Despite the name, this is actually used. Maybe it's worth investigating the content. */
      case BLF_OBJTYPE_TEST_STRUCTURE118:
          ws_debug("skipping unsupported object type 0x%04x", header.object_type)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3793, __func__, "skipping unsupported object type 0x%04x", header
.object_type); } } while (0);
          start_pos += MAX(MAX(16, header.object_length), header.header_length)((((((16) > (header.object_length)) ? (16) : (header.object_length
))) > (header.header_length)) ? ((((16) > (header.object_length
)) ? (16) : (header.object_length))) : (header.header_length)
);
          break;
      default:
          ws_info("unknown object type 0x%04x", header.object_type)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_INFO, ((void*)
0), -1, ((void*)0), "unknown object type 0x%04x", header.object_type
); } } while (0);
          start_pos += MAX(MAX(16, header.object_length), header.header_length)((((((16) > (header.object_length)) ? (16) : (header.object_length
))) > (header.header_length)) ? ((((16) > (header.object_length
)) ? (16) : (header.object_length))) : (header.header_length)
);
          break;
      }
  }
  return true1;
3803}

3805static bool_Bool blf_read(wtap *wth, wtap_rec *rec, int *err, char **err_info, int64_t *data_offset) {
  blf_params_t blf_tmp;

  blf_tmp.wth = wth;
  blf_tmp.fh  = wth->fh;
  blf_tmp.random = false0;
  blf_tmp.pipe = wth->ispipe;
  blf_tmp.rec = rec;
  blf_tmp.blf_data = (blf_t *)wth->priv;

  if (!blf_read_block(&blf_tmp, blf_tmp.blf_data->current_real_seek_pos, err, err_info)) {
      return false0;
  }
  *data_offset = blf_tmp.blf_data->start_of_last_obj;

  return true1;
3821}

3823static bool_Bool blf_seek_read(wtap *wth, int64_t seek_off, wtap_rec *rec, int *err, char **err_info) {
  blf_params_t blf_tmp;

  blf_tmp.wth = wth;
  blf_tmp.fh  = wth->random_fh;
  blf_tmp.random = true1;
  blf_tmp.pipe = wth->ispipe;
  blf_tmp.rec = rec;
  blf_tmp.blf_data = (blf_t *)wth->priv;

  if (!blf_read_block(&blf_tmp, seek_off, err, err_info)) {
      ws_debug("couldn't read packet block (err=%d).", *err)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3834, __func__, "couldn't read packet block (err=%d).", *err
); } } while (0);
      return false0;
  }

  return true1;
3839}

3841static void blf_free(blf_t *blf) {
  if (blf != NULL((void*)0)) {
      if (blf->log_containers != NULL((void*)0)) {
          for (unsigned i = 0; i < blf->log_containers->len; i++) {
              blf_log_container_t* log_container = &g_array_index(blf->log_containers, blf_log_container_t, i)(((blf_log_container_t*) (void *) (blf->log_containers)->
data) [(i)]);
              if (log_container->real_data != NULL((void*)0)) {
                  g_free(log_container->real_data);
              }
          }
          g_array_free(blf->log_containers, true1);
          blf->log_containers = NULL((void*)0);
      }
      if (blf->channel_to_iface_ht != NULL((void*)0)) {
          g_hash_table_destroy(blf->channel_to_iface_ht);
          blf->channel_to_iface_ht = NULL((void*)0);
      }
      if (blf->channel_to_name_ht != NULL((void*)0)) {
          g_hash_table_destroy(blf->channel_to_name_ht);
          blf->channel_to_name_ht = NULL((void*)0);
      }
  }
3862}

3864static void blf_close(wtap *wth) {
  blf_free((blf_t *)wth->priv);

  /* TODO: do we need to reverse the wtap_add_idb? how? */
3868}

3870wtap_open_return_val
3871blf_open(wtap *wth, int *err, char **err_info) {
  blf_fileheader_t  header;
  blf_t            *blf;

  ws_debug("opening file")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3875, __func__, "opening file"); } } while (0);

  if (!wtap_read_bytes_or_eof(wth->fh, &header, sizeof(blf_fileheader_t), err, err_info)) {

      ws_debug("wtap_read_bytes_or_eof() failed, err = %d.", *err)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 3879, __func__, "wtap_read_bytes_or_eof() failed, err = %d."
, *err); } } while (0);
      if (*err == 0 || *err == WTAP_ERR_SHORT_READ-12) {
          /*
           * Short read or EOF.
           *
           * We're reading this as part of an open, so
           * the file is too short to be a blf file.
           */
          *err = 0;
          g_free(*err_info);
          *err_info = NULL((void*)0);
          return WTAP_OPEN_NOT_MINE;
      }
      return WTAP_OPEN_ERROR;
  }

  fix_endianness_blf_fileheader(&header);

  if (memcmp(header.magic, blf_magic, sizeof(blf_magic))) {
      return WTAP_OPEN_NOT_MINE;
  }

  /* This seems to be an BLF! */
  /* Check for a valid header length */
  if (header.header_length < sizeof(blf_fileheader_t)) {
      *err = WTAP_ERR_BAD_FILE-13;
      *err_info = ws_strdup("blf: file header length too short")wmem_strdup(((void*)0), "blf: file header length too short");
      return WTAP_OPEN_ERROR;
  }

  /* skip past the header, which may include padding/reserved space */
  if (!wtap_read_bytes(wth->fh, NULL((void*)0), header.header_length - sizeof(blf_fileheader_t), err, err_info)) {
      return WTAP_OPEN_ERROR;
  }

  /* Prepare our private context. */
  blf = g_new(blf_t, 1)((blf_t *) g_malloc_n ((1), sizeof (blf_t)));
  blf->log_containers = g_array_new(false0, false0, sizeof(blf_log_container_t));
  blf->current_real_seek_pos = 0;
  blf->start_offset_ns = blf_get_start_offset_ns(&header.start_date);

  blf->channel_to_iface_ht = g_hash_table_new_full(g_int64_hash, g_int64_equal, &blf_free_key, &blf_free_channel_to_iface_entry);
  blf->channel_to_name_ht = g_hash_table_new_full(g_int64_hash, g_int64_equal, &blf_free_key, &blf_free_channel_to_name_entry);
  blf->next_interface_id = 0;

  wth->priv = (void *)blf;
  wth->file_encap = WTAP_ENCAP_NONE-2;
  wth->snapshot_length = 0;
  wth->file_tsprec = WTAP_TSPREC_UNKNOWN-2;
  wth->subtype_read = blf_read;
  wth->subtype_seek_read = blf_seek_read;
  wth->subtype_close = blf_close;
  wth->file_type_subtype = blf_file_type_subtype;

  return WTAP_OPEN_MINE;
3934}

3936/* Options for interface blocks. */
3937static const struct supported_option_type interface_block_options_supported[] = {
  /* No comments, just an interface name. */
  { OPT_IDB_NAME2, ONE_OPTION_SUPPORTED }
3940};

3942static const struct supported_block_type blf_blocks_supported[] = {
  { WTAP_BLOCK_PACKET, MULTIPLE_BLOCKS_SUPPORTED, NO_OPTIONS_SUPPORTED0, ((void*)0) },
  { WTAP_BLOCK_IF_ID_AND_INFO, MULTIPLE_BLOCKS_SUPPORTED, OPTION_TYPES_SUPPORTED(interface_block_options_supported)(sizeof (interface_block_options_supported) / sizeof (interface_block_options_supported
)[0]), interface_block_options_supported },
3945};


3948/***********************/
3949/* BLF Writing Support */
3950/***********************/

3952/* 10MB = 10485760 */
3953#define LOG_CONTAINER_BUFFER_SIZE10485760 10485760

3955#define LOG_CONTAINER_NONE(18446744073709551615UL) UINT64_MAX(18446744073709551615UL)

3957typedef struct _blf_writer_data {
  GArray *iface_to_channel_array;
  bool_Bool iface_to_channel_names_recovered;

  blf_fileheader_t *fileheader;
  uint32_t object_count;
  uint64_t start_time;
  bool_Bool start_time_set;
  uint64_t end_time;

  uint64_t logcontainer_start;
  blf_blockheader_t logcontainer_block_header;
  blf_logcontainerheader_t logcontainer_header;
3970} blf_writer_data_t;

3972static void
3973blf_dump_init_channel_to_iface_entry(blf_channel_to_iface_entry_t* tmp, unsigned int if_id) {
  tmp->channel = 0;
  tmp->hwchannel = UINT16_MAX(65535);
  tmp->interface_id = if_id;
  tmp->pkt_encap = WTAP_ENCAP_NONE-2;
3978}

3980static void
3981blf_dump_expand_interface_mapping(wtap_dumper *wdh, int new_size) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  int old_size = writer_data->iface_to_channel_array->len;

  if (old_size < new_size) {
6
←
Assuming 'old_size' is < 'new_size'→
7
←
Taking true branch→
      /* we need to expand array */
      unsigned int number_of_new_elements = new_size - old_size;

      blf_channel_to_iface_entry_t *newdata = g_new0(blf_channel_to_iface_entry_t, number_of_new_elements)((blf_channel_to_iface_entry_t *) g_malloc0_n ((number_of_new_elements
), sizeof (blf_channel_to_iface_entry_t)));
8
←
Memory is allocated→
      g_array_append_vals(writer_data->iface_to_channel_array, newdata, number_of_new_elements);

      for (unsigned int i = old_size; i < writer_data->iface_to_channel_array->len; i++) {
9
←
Potential leak of memory pointed to by 'newdata'
          blf_channel_to_iface_entry_t *tmp = &g_array_index(writer_data->iface_to_channel_array, blf_channel_to_iface_entry_t, i)(((blf_channel_to_iface_entry_t*) (void *) (writer_data->iface_to_channel_array
)->data) [(i)]);
          blf_dump_init_channel_to_iface_entry(tmp, i);
      }
  }
3998}

4000static bool_Bool
4001blf_dump_set_interface_mapping(wtap_dumper *wdh, uint32_t interface_id, int pkt_encap, uint16_t channel, uint16_t hw_channel) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  blf_dump_expand_interface_mapping(wdh, interface_id + 1);

  blf_channel_to_iface_entry_t *tmp = &g_array_index(writer_data->iface_to_channel_array, blf_channel_to_iface_entry_t, interface_id)(((blf_channel_to_iface_entry_t*) (void *) (writer_data->iface_to_channel_array
)->data) [(interface_id)]);
  tmp->channel = channel;
  tmp->hwchannel = hw_channel;
  tmp->interface_id = interface_id;
  tmp->pkt_encap = pkt_encap;

  return true1;
4013}

4015static blf_channel_to_iface_entry_t *
4016blf_dump_get_interface_mapping(wtap_dumper *wdh, const wtap_rec *rec, int *err, char **err_info) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  uint32_t interface_id = rec->rec_header.packet_header.interface_id;
  if (interface_id < writer_data->iface_to_channel_array->len) {
      return &g_array_index(writer_data->iface_to_channel_array, blf_channel_to_iface_entry_t, interface_id)(((blf_channel_to_iface_entry_t*) (void *) (writer_data->iface_to_channel_array
)->data) [(interface_id)]);
  }

  *err = WTAP_ERR_INTERNAL-21;
  *err_info = ws_strdup_printf("blf: cannot find interface mapping for %u", interface_id)wmem_strdup_printf(((void*)0), "blf: cannot find interface mapping for %u"
, interface_id);
  ws_critical("BLF Interface Mapping cannot be found!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_CRITICAL, "wiretap/blf.c"
, 4026, __func__, "BLF Interface Mapping cannot be found!"); }
 } while (0);

  return NULL((void*)0);
4029}

4031static bool_Bool
4032blf_init_file_header(wtap_dumper *wdh, int *err) {
  if (wdh == NULL((void*)0) || wdh->priv == NULL((void*)0)) {
      *err = WTAP_ERR_INTERNAL-21;
      ws_debug("internal error: blf private data not found!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 4035, __func__, "internal error: blf private data not found!"
); } } while (0);
      return false0;
  }

  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  writer_data->fileheader = g_new0(blf_fileheader_t, 1)((blf_fileheader_t *) g_malloc0_n ((1), sizeof (blf_fileheader_t
)));

  /* set magic */
  int i;
  for (i = 0; i < 4; i++) {
      writer_data->fileheader->magic[i] = blf_magic[i];
  }

  /* currently only support 144 byte length*/
  writer_data->fileheader->header_length = 144;

  writer_data->fileheader->application_major = WIRESHARK_VERSION_MAJOR4;
  writer_data->fileheader->application_minor = WIRESHARK_VERSION_MINOR7;
  writer_data->fileheader->application_build = WIRESHARK_VERSION_MICRO0;

  return true1;
4057}

4059static bool_Bool
4060blf_write_file_header_zeros(wtap_dumper *wdh, int *err) {
  /* lets add 144 bytes for the header and padding */
  uint8_t padding[144] = { 0 };
  if (!wtap_dump_file_write(wdh, &padding, 144, err)) {
      return false0;
  }

  return true1;
4068}

4070static void
4071blf_write_date_to_blf_header(blf_fileheader_t *fileheader, bool_Bool start, uint64_t ns_timestamp) {
  struct tm tmp;
  const time_t date = (time_t)(ns_timestamp / (1000 * 1000 * 1000));

  if (ws_localtime_r(&date, &tmp) != NULL((void*)0)) {
      blf_date_t *target = start ? &(fileheader->start_date) : &(fileheader->end_date);
      target->year = 1900 + tmp.tm_year;
      target->month = tmp.tm_mon + 1;
      target->day = tmp.tm_mday;
      target->hour = tmp.tm_hour;
      target->mins = tmp.tm_min;
      target->sec = tmp.tm_sec;

      uint64_t tmp_date = blf_get_start_offset_ns((const blf_date_t *)target);

      target->ms = (uint16_t)((ns_timestamp - tmp_date) / (1000 * 1000));
  }

4089}

4091static bool_Bool
4092blf_finalize_file_header(wtap_dumper *wdh, int *err) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;
  blf_fileheader_t *fileheader = writer_data->fileheader;
  int64_t bytes_written = wtap_dump_file_tell(wdh, err);

  /* update the header and convert all to LE */
  fileheader->len_compressed = (uint64_t)bytes_written;
  fileheader->len_uncompressed = (uint64_t)bytes_written;

  fileheader->obj_count = writer_data->object_count;

  if (writer_data->start_time_set) {
      blf_write_date_to_blf_header(fileheader, true1, writer_data->start_time);
  }

  blf_write_date_to_blf_header(fileheader, false0, writer_data->end_time);

  fix_endianness_blf_fileheader(fileheader);

  /* seek to start of file */
  int64_t tmp = wtap_dump_file_seek(wdh, 0, SEEK_SET0, err);
  if (*err != 0 || tmp != 0) {
      return false0;
  }

  if (!wtap_dump_file_write(wdh, fileheader, fileheader->header_length, err)) {
      return false0;
  }

  return true1;
4122}

4124static bool_Bool blf_dump_write_logcontainer(wtap_dumper *wdh, int *err, char **err_info) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  if (!wtap_dump_file_write(wdh, &(writer_data->logcontainer_block_header), sizeof(blf_blockheader_t), err)) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: cannot write Log Container Block Header")wmem_strdup_printf(((void*)0), "blf: cannot write Log Container Block Header"
);
      ws_warning("Cannot write Log Container Block Header")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4130, __func__, "Cannot write Log Container Block Header");
 } } while (0);
      return false0;
  }

  if (!wtap_dump_file_write(wdh, &(writer_data->logcontainer_header), sizeof(blf_logcontainerheader_t), err)) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: cannot write Log Container")wmem_strdup_printf(((void*)0), "blf: cannot write Log Container"
);
      ws_warning("Cannot write Log Container")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4137, __func__, "Cannot write Log Container"); } } while (0
);
      return false0;
  }

  return true1;
4142}

4144static bool_Bool blf_dump_close_logcontainer(wtap_dumper *wdh, int *err, char **err_info) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  int64_t current_position = wtap_dump_file_tell(wdh, err);

  int64_t tmp = wtap_dump_file_seek(wdh, writer_data->logcontainer_start, SEEK_SET0, err);
  if (*err != 0 || tmp != 0) {
      return false0;
  }

  int64_t logcontainer_length = current_position - writer_data->logcontainer_start;
  if (logcontainer_length < 32) {
      *err = WTAP_ERR_INTERNAL-21;
  }
  writer_data->logcontainer_block_header.object_length = GUINT32_TO_LE((uint32_t)logcontainer_length)((guint32) ((uint32_t)logcontainer_length));
  writer_data->logcontainer_header.uncompressed_size = GUINT32_TO_LE((uint32_t)(logcontainer_length - 32))((guint32) ((uint32_t)(logcontainer_length - 32)));

  if (!blf_dump_write_logcontainer(wdh, err, err_info)) {
      return false0;
  }

  tmp = wtap_dump_file_seek(wdh, current_position, SEEK_SET0, err);
  if (*err != 0 || tmp != 0) {
      return false0;
  }

  return true1;
4171}

4173static bool_Bool blf_dump_start_logcontainer(wtap_dumper *wdh, int *err, char **err_info) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  if (writer_data->logcontainer_start != LOG_CONTAINER_NONE(18446744073709551615UL)) {
      if (!blf_dump_close_logcontainer(wdh, err, err_info)) {
          return false0;
      }
  }

  /* start new log container */
  /* set magic */
  int i;
  for (i = 0; i < 4; i++) {
      writer_data->logcontainer_block_header.magic[i] = blf_obj_magic[i];
  }
  writer_data->logcontainer_block_header.header_length = 16;
  writer_data->logcontainer_block_header.header_type = 1;
  writer_data->logcontainer_block_header.object_length = 32;
  writer_data->logcontainer_block_header.object_type = BLF_OBJTYPE_LOG_CONTAINER10;
  fix_endianness_blf_blockheader(&(writer_data->logcontainer_block_header));

  writer_data->logcontainer_header.compression_method = 0;
  writer_data->logcontainer_header.res1 = 0;
  writer_data->logcontainer_header.res2 = 0;
  writer_data->logcontainer_header.uncompressed_size = 0;
  writer_data->logcontainer_header.res4 = 0;
  fix_endianness_blf_logcontainerheader(&(writer_data->logcontainer_header));

  writer_data->logcontainer_start = wtap_dump_file_tell(wdh, err);

  return blf_dump_write_logcontainer(wdh, err, err_info);
4204}

4206static bool_Bool blf_dump_check_logcontainer_full(wtap_dumper *wdh, int *err, char **err_info, uint32_t length) {
  const blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  uint64_t position = (uint64_t)wtap_dump_file_tell(wdh, err);
  if (position - writer_data->logcontainer_start + length <= LOG_CONTAINER_BUFFER_SIZE10485760) {
      return true1;
  }

  return blf_dump_start_logcontainer(wdh, err, err_info);
4215}

4217static bool_Bool blf_dump_objheader(wtap_dumper *wdh, int *err, uint64_t obj_timestamp, uint32_t obj_type, uint32_t obj_length) {
  blf_logobjectheader_t logheader;
  logheader.flags = BLF_TIMESTAMP_RESOLUTION_1NS2;
  logheader.client_index = 0;
  logheader.object_version = 1;
  logheader.object_timestamp = obj_timestamp;
  fix_endianness_blf_logobjectheader(&logheader);

  blf_blockheader_t blockheader;
  /* set magic */
  int i;
  for (i = 0; i < 4; i++) {
      blockheader.magic[i] = blf_obj_magic[i];
  }
  blockheader.header_length = sizeof(blf_blockheader_t) + sizeof(blf_logobjectheader_t);
  blockheader.header_type = 1;
  blockheader.object_length = sizeof(blf_blockheader_t) + sizeof(blf_logobjectheader_t) + obj_length;
  blockheader.object_type = obj_type;
  fix_endianness_blf_blockheader(&blockheader);

  if (!wtap_dump_file_write(wdh, &(blockheader), sizeof(blf_blockheader_t), err)) {
      return false0;
  }

  if (!wtap_dump_file_write(wdh, &(logheader), sizeof(blf_logobjectheader_t), err)) {
      return false0;
  }

  return true1;
4246}

4248/* return standard direction format of BLF, RX on error or unknown */
4249static uint8_t blf_get_direction(const wtap_rec *rec) {
  uint32_t tmp_direction = 0;
  if (WTAP_OPTTYPE_SUCCESS != wtap_block_get_uint32_option_value(rec->block, OPT_PKT_FLAGS2, &tmp_direction)) {
      return BLF_DIR_RX0;
  }

  if (tmp_direction == PACK_FLAGS_DIRECTION_OUTBOUND2) {
      return BLF_DIR_TX1;

  }

  return BLF_DIR_RX0;
4261}

4263static bool_Bool blf_dump_ethernet(wtap_dumper *wdh, const wtap_rec *rec, int *err, char **err_info, uint64_t obj_timestamp) {
  /* LINKTYPE_ETHERNET */
  /* https://www.tcpdump.org/linktypes/LINKTYPE_LINUX_SLL.html */

  //blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;
  const blf_channel_to_iface_entry_t *iface_entry = blf_dump_get_interface_mapping(wdh, rec, err, err_info);

  const uint8_t *pd = ws_buffer_start_ptr(&rec->data);
  size_t length = ws_buffer_length(&rec->data);

  /* 14 bytes is the full Ethernet Header up to EtherType */
  if (length < 14) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: record length %u for Ethernet message is lower than minimum of 14", (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: record length %u for Ethernet message is lower than minimum of 14"
, (uint32_t)length);
      ws_warning("LINKTYPE_ETHERNET Data is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4277, __func__, "LINKTYPE_ETHERNET Data is too short!"); } }
 while (0);
      return false0;
  }

  uint32_t offset = 12;

  blf_ethernetframeheader_t ethheader;
  ethheader.src_addr[0] = pd[6];
  ethheader.src_addr[1] = pd[7];
  ethheader.src_addr[2] = pd[8];
  ethheader.src_addr[3] = pd[9];
  ethheader.src_addr[4] = pd[10];
  ethheader.src_addr[5] = pd[11];

  ethheader.channel = iface_entry->channel;

  ethheader.dst_addr[0] = pd[0];
  ethheader.dst_addr[1] = pd[1];
  ethheader.dst_addr[2] = pd[2];
  ethheader.dst_addr[3] = pd[3];
  ethheader.dst_addr[4] = pd[4];
  ethheader.dst_addr[5] = pd[5];

  ethheader.direction = blf_get_direction(rec);

  uint16_t eth_type = pntohu16(pd + offset);
  offset += 2;

  if (eth_type == 0x8100 || eth_type == 0x9100 || eth_type == 0x88a8) {
      ethheader.tpid = eth_type;
      ethheader.tci = pntohu16(pd + offset);
      offset += 2;

      eth_type = pntohu16(pd + offset);
      offset += 2;
  } else {
      ethheader.tpid = 0;
      ethheader.tci = 0;
  }

  ethheader.ethtype = eth_type;
  ethheader.payloadlength = rec->rec_header.packet_header.caplen - offset;
  ethheader.res = 0;
  fix_endianness_blf_ethernetframeheader(&ethheader);

  if (!blf_dump_objheader(wdh, err, obj_timestamp, BLF_OBJTYPE_ETHERNET_FRAME71, sizeof(blf_ethernetframeheader_t) + ethheader.payloadlength)) {
      return false0;
  }

  if (!wtap_dump_file_write(wdh, &(ethheader), sizeof(blf_ethernetframeheader_t), err)) {
      return false0;
  }

  if (!wtap_dump_file_write(wdh, &(pd[offset]), ethheader.payloadlength, err)) {
      return false0;
  }

  return true1;
4335}

4337static bool_Bool blf_dump_socketcanxl(wtap_dumper *wdh, const wtap_rec *rec, int *err _U___attribute__((unused)), char **err_info _U___attribute__((unused)), uint64_t obj_timestamp,
                               const uint8_t *pd, size_t length, bool_Bool is_rx, bool_Bool is_tx) {
  /* LINKTYPE_CAN_SOCKETCAN */
  /* https://www.tcpdump.org/linktypes/LINKTYPE_CAN_SOCKETCAN.html */

  //blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;
  blf_channel_to_iface_entry_t *iface_entry = blf_dump_get_interface_mapping(wdh, rec, err, err_info);

  uint8_t  socketcan_vcid = pd[1];
  uint16_t socketcan_id = pntohu16(pd + 2) & CAN_SFF_MASK0x000007FF;
  uint8_t  socketcan_flags = pd[4];
  uint8_t  socketcan_sdut = pd[5];
  uint16_t socketcan_payload_length = pletohu16(pd + 6);

  if ((socketcan_flags & CANXL_XLF0x80) != CANXL_XLF0x80) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: Socket CAN XL message does not have XL Flag set!")wmem_strdup_printf(((void*)0), "blf: Socket CAN XL message does not have XL Flag set!"
);
      ws_error("LINKTYPE_CAN_SOCKETCAN CAN XL flag not set for CAN XL?")ws_log_fatal_full("Wiretap", LOG_LEVEL_ERROR, "wiretap/blf.c"
, 4354, __func__, "LINKTYPE_CAN_SOCKETCAN CAN XL flag not set for CAN XL?"
);
      return false0;
  }

  if (length < (size_t)socketcan_payload_length + 12) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: Socket CAN message (length %u) does not contain full payload (%u) (CAN XL)", (uint32_t)length, socketcan_payload_length)wmem_strdup_printf(((void*)0), "blf: Socket CAN message (length %u) does not contain full payload (%u) (CAN XL)"
, (uint32_t)length, socketcan_payload_length);
      ws_error("LINKTYPE_CAN_SOCKETCAN header is too short (CAN XL)!")ws_log_fatal_full("Wiretap", LOG_LEVEL_ERROR, "wiretap/blf.c"
, 4361, __func__, "LINKTYPE_CAN_SOCKETCAN header is too short (CAN XL)!"
);
      return false0;
  }
  uint32_t socketcan_acceptance_field = pletohu32(pd + 8);

  /* LINKTYPE_LINUX_SLL would have set is_tx or is_rx */
  uint8_t frame_dir = is_tx ? BLF_DIR_TX1 : BLF_DIR_RX0;
  if (!is_rx && !is_tx) {
      frame_dir = blf_get_direction(rec);
  }

  blf_canxlchannelframe_t canxl = {0};
  canxl.channel = (uint8_t)iface_entry->channel;
  canxl.dir = frame_dir;
  canxl.frameIdentifier = socketcan_id;
  canxl.serviceDataUnitType = socketcan_sdut;
  canxl.dlc = socketcan_payload_length - 1;
  canxl.dataLength = socketcan_payload_length;
  canxl.virtualControllerAreaNetChannelID = socketcan_vcid;
  canxl.acceptanceField = socketcan_acceptance_field;

  if ((socketcan_flags & CANXL_XLF0x80) == CANXL_XLF0x80) {
      /* should be always true but we might refactor */
      canxl.flags |= BLF_CANXLCHANNELFRAME_FLAG_XLF0x400000;
  }
  if ((socketcan_flags & CANXL_SEC0x01) == CANXL_SEC0x01) {
      canxl.flags |= BLF_CANXLCHANNELFRAME_FLAG_SEC0x1000000;
  }
  if ((socketcan_flags & CANXL_RRS0x02) == CANXL_RRS0x02) {
      canxl.flags |= BLF_CANXLCHANNELFRAME_FLAG_RRS0x800000;
  }

  fix_endianness_blf_canxlchannelframe(&canxl);

  if (!blf_dump_objheader(wdh, err, obj_timestamp, BLF_OBJTYPE_CAN_XL_CHANNEL_FRAME139, sizeof(blf_canxlchannelframe_t) + socketcan_payload_length)) {
      return false0;
  }

  if (!wtap_dump_file_write(wdh, &(canxl), sizeof(blf_canxlchannelframe_t), err)) {
      return false0;
  }

  if (!wtap_dump_file_write(wdh, &(pd[12]), socketcan_payload_length, err)) {
      return false0;
  }

  return true1;
4408}

4410static const uint8_t canfd_length_to_dlc[] = { 0, 1, 2, 3,   4, 5, 6, 7,   8, 0, 0, 0,  9, 0, 0, 0,
                                            10, 0, 0, 0,  11, 0, 0, 0,  12, 0, 0, 0,  0, 0, 0, 0,
                                            13, 0, 0, 0,   0, 0, 0, 0,   0, 0, 0, 0,  0, 0, 0, 0,
                                            14, 0, 0, 0,   0, 0, 0, 0,   0, 0, 0, 0,  0, 0, 0, 0,
                                            15 };

4416static bool_Bool blf_dump_socketcan(wtap_dumper *wdh, const wtap_rec *rec, int *err, char **err_info, uint64_t obj_timestamp,
                             const uint8_t *pd, size_t length, bool_Bool is_can, bool_Bool is_canfd, bool_Bool is_rx, bool_Bool is_tx) {
  /* LINKTYPE_CAN_SOCKETCAN */
  /* https://www.tcpdump.org/linktypes/LINKTYPE_CAN_SOCKETCAN.html */

  if (length < 8) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: record length %u for Socket CAN message header is lower than minimum of 8", (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: record length %u for Socket CAN message header is lower than minimum of 8"
, (uint32_t)length);
      ws_warning("LINKTYPE_CAN_SOCKETCAN header is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4424, __func__, "LINKTYPE_CAN_SOCKETCAN header is too short!"
); } } while (0);
      return false0;
  }

  /* check for CAN-XL */
  if ((pd[4] & CANXL_XLF0x80) == CANXL_XLF0x80) {
      return blf_dump_socketcanxl(wdh, rec, err, err_info, obj_timestamp, pd, length, is_rx, is_tx);
  }

  //blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;
  blf_channel_to_iface_entry_t *iface_entry = blf_dump_get_interface_mapping(wdh, rec, err, err_info);

  uint8_t payload_length = pd[4];

  if (length < (size_t)payload_length + 8) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: Socket CAN message (length %u) does not contain full payload (%u)", (uint32_t)length, payload_length)wmem_strdup_printf(((void*)0), "blf: Socket CAN message (length %u) does not contain full payload (%u)"
, (uint32_t)length, payload_length);
      ws_warning("LINKTYPE_CAN_SOCKETCAN header is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4441, __func__, "LINKTYPE_CAN_SOCKETCAN header is too short!"
); } } while (0);
      return false0;
  }

  /* LINKTYPE_LINUX_SLL would have set is_tx or is_rx */
  uint8_t frame_dir = is_tx ? BLF_DIR_TX1 : BLF_DIR_RX0;
  if (!is_rx && !is_tx) {
      frame_dir = blf_get_direction(rec);
  }

  bool_Bool canfd = is_canfd;

  /* LINKTYPE_LINUX_SLL would have set one */
  if (!is_can && !is_canfd) {
      if ((pd[5] & CANFD_FDF0x04) == CANFD_FDF0x04) {
          canfd = true1;
      } else {
          /* heuristic. if longer than header + 8 bytes data, its CAN-FD*/
          canfd = rec->rec_header.packet_header.caplen > 16;
      }
  }

  /* XXX endianess is not defined. Assuming BE as this seems the common choice*/
  uint32_t can_id = pntohu32(pd);

  /* lets check if can_id makes sense
   * 29bit CAN ID mask 0x1fffffff CAN_EFF_MASK
   * 11bit CAN ID mask 0x000007ff CAN_SFF_MASK
   * 29 only bits      0x1ffff800 CAN_EFF_MASK & !CAN_SFF_MASK
   */
  if (((can_id & CAN_EFF_FLAG0x80000000) == 0) && ((can_id & (CAN_EFF_MASK0x1FFFFFFF & (!CAN_SFF_MASK0x000007FF))) != 0)) {
      ws_message("CAN-ID 0x%08x seems to be in wrong byte order, changing to little-endian", can_id)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_MESSAGE, ((void
*)0), -1, ((void*)0), "CAN-ID 0x%08x seems to be in wrong byte order, changing to little-endian"
, can_id); } } while (0);
      can_id = pletohu32(pd);
  }

  bool_Bool err_flag = (can_id & CAN_ERR_FLAG0x20000000) == CAN_ERR_FLAG0x20000000;
  bool_Bool rtr_flag = (can_id & CAN_RTR_FLAG0x40000000) == CAN_RTR_FLAG0x40000000;
  //bool ext_id_flag = (can_id & CAN_EFF_FLAG) == CAN_EFF_FLAG;
  can_id &= (CAN_EFF_MASK0x1FFFFFFF | CAN_EFF_FLAG0x80000000);

  if (canfd) {
      /* CAN-FD */
      bool_Bool brs_flag = (pd[5] & CANFD_BRS0x01) == CANFD_BRS0x01;
      bool_Bool esi_flag = (pd[5] & CANFD_ESI0x02) == CANFD_ESI0x02;
      bool_Bool fdf_flag = (pd[5] & CANFD_FDF0x04) == CANFD_FDF0x04;

      blf_canfdmessage64_t canfdmsg;
      canfdmsg.channel = (uint8_t)iface_entry->channel;

      canfdmsg.dlc = (payload_length <= 64) ? canfd_length_to_dlc[payload_length] : 0;
      canfdmsg.validDataBytes = payload_length;
      canfdmsg.txCount = 0;
      canfdmsg.id = can_id;
      canfdmsg.frameLength_in_ns = 0;
      canfdmsg.flags = 0;

      /* TODO: fdf_flag is not always set for CAN-FD */
      if (fdf_flag) {
          canfdmsg.flags = BLF_CANFDMESSAGE64_FLAG_EDL0x001000; // CAN-FD
      } else {
          ws_warning("CAN-FD has not CANFD_FDF set. File not correct.")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4501, __func__, "CAN-FD has not CANFD_FDF set. File not correct."
); } } while (0);
      }
      if (brs_flag) {
          canfdmsg.flags |= BLF_CANFDMESSAGE64_FLAG_BRS0x002000;
      }
      if (esi_flag) {
          canfdmsg.flags |= BLF_CANFDMESSAGE64_FLAG_ESI0x004000;
      }

      canfdmsg.btrCfgArb = 0;
      canfdmsg.btrCfgData = 0;
      canfdmsg.timeOffsetBrsNs = 0;
      canfdmsg.timeOffsetCrcDelNs = 0;
      canfdmsg.bitCount = 0;
      canfdmsg.dir = frame_dir;
      canfdmsg.extDataOffset = 0;
      canfdmsg.crc = 0;

      fix_endianness_blf_canfdmessage64(&canfdmsg);

      if (!blf_dump_objheader(wdh, err, obj_timestamp, BLF_OBJTYPE_CAN_FD_MESSAGE_64101, sizeof(blf_canfdmessage64_t) + payload_length)) {
          return false0;
      }

      if (!wtap_dump_file_write(wdh, &(canfdmsg), sizeof(blf_canfdmessage64_t), err)) {
          return false0;
      }
  } else {
      /* CAN */
      blf_canmessage_t canmsg;

      if (payload_length > 8) {
          ws_warning("CAN frames can only have 0 to 8 bytes of payload! We have %d bytes", payload_length)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4533, __func__, "CAN frames can only have 0 to 8 bytes of payload! We have %d bytes"
, payload_length); } } while (0);
          payload_length = 0;
      }

      canmsg.dlc = payload_length;
      canmsg.channel = iface_entry->channel;

      canmsg.flags = 0;
      if (frame_dir == BLF_DIR_TX1) {
          canmsg.flags |= BLF_CANMESSAGE_FLAG_TX0x01;
      }

      if (err_flag) {
          // TODO: we need to implement CAN ERROR, ignore for now
          return true1;
          //canmsg.flags |= BLF_CANMESSAGE_FLAG_NERR; - NERR is not error
      }

      if (rtr_flag) {
          canmsg.flags |= BLF_CANMESSAGE_FLAG_RTR0x80;
      }

      canmsg.id = can_id;

      fix_endianness_blf_canmessage(&canmsg);

      if (!blf_dump_objheader(wdh, err, obj_timestamp, BLF_OBJTYPE_CAN_MESSAGE1, sizeof(blf_canmessage_t) + payload_length)) {
          return false0;
      }

      if (!wtap_dump_file_write(wdh, &(canmsg), sizeof(blf_canmessage_t), err)) {
          return false0;
      }
  }

  if (!wtap_dump_file_write(wdh, &(pd[8]), payload_length, err)) {
      return false0;
  }

  return true1;
4573}

4575static bool_Bool blf_dump_sll(wtap_dumper *wdh, const wtap_rec *rec, int *err, char **err_info, uint64_t obj_timestamp) {
  /* Linux Cooked CAN / CAN-FD */
  /* https://www.tcpdump.org/linktypes/LINKTYPE_LINUX_SLL.html */

  const uint8_t *pd = ws_buffer_start_ptr(&rec->data);
  size_t length = ws_buffer_length(&rec->data);

  if (length < 16) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: record length %u for CAN message header (LINKTYPE_LINUX_SLL) is lower than minimum of 16", (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: record length %u for CAN message header (LINKTYPE_LINUX_SLL) is lower than minimum of 16"
, (uint32_t)length);
      ws_warning("LINKTYPE_LINUX_SLL header is too short!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4585, __func__, "LINKTYPE_LINUX_SLL header is too short!");
 } } while (0);
      return false0;
  }

  bool_Bool frame_tx = false0;
  if (pd[0] == 0 && pd[1] == 4) {
      frame_tx = true1;
  }

  uint16_t protocol_type = pntohu16(pd + 14);

  switch (protocol_type) {
  case 0x000C: /* CAN */
      return blf_dump_socketcan(wdh, rec, err, err_info, obj_timestamp, &(pd[16]), length - 16, true1, false0, !frame_tx, frame_tx);
      break;
  case 0x000D: /* CAN-FD */
      return blf_dump_socketcan(wdh, rec, err, err_info, obj_timestamp, &(pd[16]), length - 16, false0, true1, !frame_tx, frame_tx);
      break;
  case 0x000E: /* CAN-XL */
      return blf_dump_socketcanxl(wdh, rec, err, err_info, obj_timestamp, &(pd[16]), length - 16, !frame_tx, frame_tx);
      break;
  default:
      return false0;
  }

  /* not reachable? */
  return true1;
4612}

4614static bool_Bool blf_dump_flexray(wtap_dumper *wdh, const wtap_rec *rec, int *err, char **err_info, uint64_t obj_timestamp) {
  /* FlexRay */
  /* https://www.tcpdump.org/linktypes/LINKTYPE_FLEXRAY.html */

  //blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;
  blf_channel_to_iface_entry_t *iface_entry = blf_dump_get_interface_mapping(wdh, rec, err, err_info);

  const uint8_t *pd = ws_buffer_start_ptr(&rec->data);
  size_t length = ws_buffer_length(&rec->data);

  if (length < 1) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: record length %u for FlexRay header (LINKTYPE_FLEXRAY) is lower than minimum of 1", (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: record length %u for FlexRay header (LINKTYPE_FLEXRAY) is lower than minimum of 1"
, (uint32_t)length);
      ws_warning("LINKTYPE_FLEXRAY header is too short (< 1 Byte)!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4627, __func__, "LINKTYPE_FLEXRAY header is too short (< 1 Byte)!"
); } } while (0);
      return false0;
  }

  /* Check Measurement Header for Type */
  if ((pd[0] & FLEXRAY_TYPE_MASK0x7f) == FLEXRAY_SYMBOL0x02) {
      /* Symbol */

      if (length < 2) {
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup_printf("blf: record length %u for FlexRay Symbol (LINKTYPE_FLEXRAY) is lower than minimum of 2", (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: record length %u for FlexRay Symbol (LINKTYPE_FLEXRAY) is lower than minimum of 2"
, (uint32_t)length);
          ws_warning("LINKTYPE_FLEXRAY Symbol is too short (< 2 Byte)!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4638, __func__, "LINKTYPE_FLEXRAY Symbol is too short (< 2 Byte)!"
); } } while (0);
          return false0;
      }

      /* TODO: SYMBOL */

      return true1;
  }

  if ((pd[0] & FLEXRAY_TYPE_MASK0x7f) == FLEXRAY_FRAME0x01) {
      /* Frame */

      if (length < 2 + FLEXRAY_HEADER_LENGTH5) {
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup_printf("blf: record length %u for FlexRay Frame header (LINKTYPE_FLEXRAY) is lower than minimum of 7", (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: record length %u for FlexRay Frame header (LINKTYPE_FLEXRAY) is lower than minimum of 7"
, (uint32_t)length);
          ws_warning("LINKTYPE_FLEXRAY Frame Header is too short (< 7 Byte)!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4653, __func__, "LINKTYPE_FLEXRAY Frame Header is too short (< 7 Byte)!"
); } } while (0);
          return false0;
      }

      uint8_t payload_length = pd[4] & FLEXRAY_LENGTH_MASK0xfe;

      /* FLEXRAY FRAME */
      blf_flexrayrcvmessage_t frmsg;

      frmsg.channel = (uint16_t)iface_entry->channel;
      frmsg.version = 1;

      uint32_t header_crc = (pntohu24(pd + 4) & FLEXRAY_HEADER_CRC_MASK0x01ffc0) >> FLEXRAY_HEADER_CRC_SHFT6;

      if ((pd[0] & FLEXRAY_CHANNEL_MASK0x80) == 0) {
          frmsg.channelMask = BLF_FLEXRAYRCVMSG_CHANNELMASK_A0x01;
          frmsg.headerCrc1 = header_crc;
          frmsg.headerCrc2 = 0;
      } else {
          frmsg.channelMask = BLF_FLEXRAYRCVMSG_CHANNELMASK_B0x02;
          frmsg.headerCrc1 = 0;
          frmsg.headerCrc2 = header_crc;
      }

      frmsg.dir = blf_get_direction(rec);
      frmsg.clientIndex = 0;
      frmsg.clusterNo = 0;
      frmsg.frameId = (pntohu16(pd + 2)) & FLEXRAY_ID_MASK0x07ff;
      frmsg.payloadLength = payload_length;
      frmsg.payloadLengthValid = payload_length;
      frmsg.cycle = pd[6] & FLEXRAY_CC_MASK0x3f;
      frmsg.tag = 0;
      frmsg.data = 0;
      frmsg.frameFlags = 0;

      /* The NULL Flag 1 -> False */
      bool_Bool null_frame = (pd[2] & FLEXRAY_NFI_MASK0x20) != FLEXRAY_NFI_MASK0x20;

      if (null_frame) {
          frmsg.frameFlags &= BLF_FLEXRAYRCVMSG_FRAME_FLAG_NULL_FRAME0x00000001;
          /* LINKTYPE_FLEXRAY has no payload for Null Frames present */
          payload_length = 0;
      }

      /* TODO: check truncated data */
      if (payload_length > 0) {
          /* Data Valid*/
          frmsg.frameFlags &= BLF_FLEXRAYRCVMSG_FRAME_FLAG_VALID_DATA0x00000002;
      }

      if ((pd[2] & FLEXRAY_SFI_MASK0x10) == FLEXRAY_SFI_MASK0x10) {
          frmsg.frameFlags &= BLF_FLEXRAYRCVMSG_FRAME_FLAG_SYNC0x00000004;
      }

      if ((pd[2] & FLEXRAY_STFI_MASK0x08) == FLEXRAY_STFI_MASK0x08) {
          frmsg.frameFlags &= BLF_FLEXRAYRCVMSG_FRAME_FLAG_STARTUP0x00000008;
      }

      if ((pd[2] & FLEXRAY_PPI_MASK0x40) == FLEXRAY_PPI_MASK0x40) {
          frmsg.frameFlags &= BLF_FLEXRAYRCVMSG_FRAME_FLAG_PAYLOAD_PREAM0x00000010;
      }

      if ((pd[2] & FLEXRAY_RES_MASK0x80) == FLEXRAY_RES_MASK0x80) {
          frmsg.frameFlags &= BLF_FLEXRAYRCVMSG_FRAME_FLAG_RES_200x00000020;
      }

      /* if any error flag is set */
      if ((pd[1] & FLEXRAY_ERRORS_DEFINED0x1f) != 0x00) {
          frmsg.frameFlags &= BLF_FLEXRAYRCVMSG_FRAME_FLAG_ERROR0x00000040;
      }

      /* Not sure how to determine this as we do not know the low level parameters */
      //if ( ) {
      //    /* DYNAMIC SEG =1 (Bit 20)*/
      //    frmsg.frameFlags &= 0x100000;
      //}

      frmsg.appParameter = 0;

      fix_endianness_blf_flexrayrcvmessage(&frmsg);

      if (!blf_dump_objheader(wdh, err, obj_timestamp, BLF_OBJTYPE_FLEXRAY_RCVMESSAGE50, sizeof(blf_flexrayrcvmessage_t) + 254)) {
          return false0;
      }

      if (!wtap_dump_file_write(wdh, &(frmsg), sizeof(blf_flexrayrcvmessage_t), err)) {
          return false0;
      }

      if (length < (size_t)payload_length + 2 + FLEXRAY_HEADER_LENGTH5) {
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup_printf("blf: record length %u for FlexRay Frame (LINKTYPE_FLEXRAY) is truncated", (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: record length %u for FlexRay Frame (LINKTYPE_FLEXRAY) is truncated"
, (uint32_t)length);
          ws_warning("LINKTYPE_FLEXRAY Frame truncated!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4745, __func__, "LINKTYPE_FLEXRAY Frame truncated!"); } } while
 (0);
          return false0;
      }

      if (payload_length > 0) {
          if (!wtap_dump_file_write(wdh, &(pd[7]), payload_length, err)) {
              return false0;
          }
      }

      const uint8_t zero_bytes[256] = { 0 };

      if (payload_length < 254) {
          if (!wtap_dump_file_write(wdh, &zero_bytes[0], 254 - payload_length, err)) {
              return false0;
          }
      }

      return true1;
  }

  return true1;
4767}

4769static bool_Bool blf_dump_lin(wtap_dumper *wdh, const wtap_rec *rec, int *err, char **err_info, uint64_t obj_timestamp) {
  /* LIN */
  /* https://www.tcpdump.org/linktypes/LINKTYPE_LIN.html */

  //blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;
  blf_channel_to_iface_entry_t *iface_entry = blf_dump_get_interface_mapping(wdh, rec, err, err_info);

  const uint8_t *pd = ws_buffer_start_ptr(&rec->data);
  size_t length = ws_buffer_length(&rec->data);

  if (length < 8) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: record length %u for LIN message/symbol/error is lower than minimum of 8", (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: record length %u for LIN message/symbol/error is lower than minimum of 8"
, (uint32_t)length);
      ws_warning("LIN Data is too short (less than 8 bytes)!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4782, __func__, "LIN Data is too short (less than 8 bytes)!"
); } } while (0);
      return false0;
  }

  uint8_t lin_err = pd[7] & 0x3f;
  if (lin_err != 0) {
      // TODO: handle LIN errors
      return true1;
  }

  int i;
  uint8_t dlc = (pd[4] & LIN_PAYLOAD_LENGTH_MASK0xf0) >> 4;
  uint8_t msg_type = (pd[4] & LIN_MSG_TYPE_MASK0x0c) >> 2;

  if (msg_type != LIN_MSG_TYPE_FRAME0) {
      // TODO: handle LIN events
      return true1;
  }

  /* we need to have at least the data */
  if (length < (size_t)dlc + 8) {
      *err = WTAP_ERR_INTERNAL-21;
      *err_info = ws_strdup_printf("blf: record length %u for LIN message is too low for data. DLC: %u.", (uint32_t)length, dlc)wmem_strdup_printf(((void*)0), "blf: record length %u for LIN message is too low for data. DLC: %u."
, (uint32_t)length, dlc);
      ws_error("LIN Data is too short (less than needed)!")ws_log_fatal_full("Wiretap", LOG_LEVEL_ERROR, "wiretap/blf.c"
, 4805, __func__, "LIN Data is too short (less than needed)!"
);
      return false0;
  }

  /* we ignore padding as we do not need it anyhow */

  blf_linmessage_t linmsg;
  linmsg.channel = (uint16_t)iface_entry->channel;
  linmsg.id = pd[5];
  linmsg.dlc = dlc;
  for (i = 0; i < 8; i++) {
      if (i < dlc) {
          linmsg.data[i] = pd[i + 8];
      } else {
          linmsg.data[i] = 0;
      }
  }
  linmsg.fsmId = 0;
  linmsg.fsmState = 0;
  linmsg.headerTime = 0;
  linmsg.fullTime = 0;
  linmsg.crc = pd[6];
  linmsg.dir = blf_get_direction(rec);
  linmsg.res1 = 0;

  fix_endianness_blf_linmessage(&linmsg);

  if (!blf_dump_objheader(wdh, err, obj_timestamp, BLF_OBJTYPE_LIN_MESSAGE11, sizeof(blf_linmessage_t) + 4)) {
      return false0;
  }

  if (!wtap_dump_file_write(wdh, &(linmsg), sizeof(blf_linmessage_t), err)) {
      return false0;
  }

  uint8_t rest_of_header[4] = { 0, 0, 0, 0};

  if (!wtap_dump_file_write(wdh, &(rest_of_header), 4, err)) {
      return false0;
  }

  return true1;
4847}

4849static bool_Bool blf_dump_upper_pdu(wtap_dumper *wdh, const wtap_rec *rec, int *err, char **err_info, uint64_t obj_timestamp) {
  const blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  const uint8_t *pd = ws_buffer_start_ptr(&rec->data);
  size_t length = ws_buffer_length(&rec->data);

  unsigned tag_diss_pos = 0;
  size_t tag_diss_len = 0;
  unsigned col_proto_pos = 0;
  size_t col_proto_len = 0;
  unsigned col_info_pos = 0;
  size_t col_info_len = 0;

  /* parse the tags */
  size_t pos = 0;
  bool_Bool done = false0;
  while (!done) {
      if (length - pos < 4) {
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup_printf("blf: Upper PDU has no or truncated tags (pos: %u, length: %u)", (uint32_t)pos, (uint32_t)length)wmem_strdup_printf(((void*)0), "blf: Upper PDU has no or truncated tags (pos: %u, length: %u)"
, (uint32_t)pos, (uint32_t)length);
          ws_warning("Upper PDU has truncated tags!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4869, __func__, "Upper PDU has truncated tags!"); } } while
 (0);
          return false0;
      }

      uint16_t tag_type = pntohu16(pd + pos);
      uint16_t tag_len = pntohu16(pd + pos + 2);

      if ((length - pos) < (size_t)tag_len + 4) {
          *err = WTAP_ERR_INTERNAL-21;
          *err_info = ws_strdup_printf("blf: Upper PDU has truncated tags (pos: %u, tag_type: %u, tag_len: %u)", (uint32_t)pos, tag_type, tag_len)wmem_strdup_printf(((void*)0), "blf: Upper PDU has truncated tags (pos: %u, tag_type: %u, tag_len: %u)"
, (uint32_t)pos, tag_type, tag_len);
          ws_warning("Upper PDU has truncated tags!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_WARNING, "wiretap/blf.c"
, 4879, __func__, "Upper PDU has truncated tags!"); } } while
 (0);
          return false0;
      }

      switch (tag_type) {
      case EXP_PDU_TAG_DISSECTOR_NAME12:
          tag_diss_pos = (unsigned)pos + 4;
          tag_diss_len = tag_len;
          break;

      case EXP_PDU_TAG_COL_PROT_TEXT33:
          col_proto_pos = (unsigned)pos + 4;
          col_proto_len = tag_len;
          break;

      case EXP_PDU_TAG_COL_INFO_TEXT36:
          col_info_pos = (unsigned)pos + 4;
          col_info_len = tag_len;
          break;

      case EXP_PDU_TAG_END_OF_OPT0:
          done = true1;
          break;
      }

      pos += 4;
      pos += tag_len;
  }

  /* strip zero termination, if existing */
  while (pd[tag_diss_pos + tag_diss_len - 1] == 0) {
      tag_diss_len -= 1;
  }

  while (pd[col_proto_pos + col_proto_len - 1] == 0) {
      col_proto_len -= 1;
  }

  while (pd[col_info_pos + col_info_len - 1] == 0) {
      col_info_len -= 1;
  }

  if (tag_diss_len == strlen(BLF_APPTEXT_TAG_DISS_DEFAULT"data-text-lines") && 0 == strncmp(BLF_APPTEXT_TAG_DISS_DEFAULT"data-text-lines", &pd[tag_diss_pos], tag_diss_len)) {
      if (col_proto_len == strlen(BLF_APPTEXT_COL_PROT_TEXT"BLF App text") && 0 == strncmp(BLF_APPTEXT_COL_PROT_TEXT"BLF App text", &pd[col_proto_pos], col_proto_len)) {
          blf_apptext_t apptext_header;
          apptext_header.source = BLF_APPTEXT_METADATA0x00000002;
          apptext_header.reservedAppText1 = 0;
          apptext_header.reservedAppText2 = 412; /* not sure what to put in but this is commonly used!? */
          uint32_t payload_len = (uint32_t)(length - pos);
          apptext_header.textLength = payload_len;

          /* Metadata */
          /* tags: BLF_APPTEXT_TAG_DISS_DEFAULT, BLF_APPTEXT_COL_PROT_TEXT, BLF_APPTEXT_COL_INFO_TEXT_... */
          if (col_info_len == strlen(BLF_APPTEXT_COL_INFO_TEXT_GENERAL"Metadata: General") && 0 == strncmp(BLF_APPTEXT_COL_INFO_TEXT_GENERAL"Metadata: General", &pd[col_info_pos], col_info_len)) {
              /* BLF_APPTEXT_METADATA: BLF_APPTEXT_XML_GENERAL */
              apptext_header.reservedAppText1 = (BLF_APPTEXT_XML_GENERAL0x01 << 24) | (0xffffff & payload_len);
          } else if (col_info_len == strlen(BLF_APPTEXT_COL_INFO_TEXT_CHANNELS"Metadata: Channels") && 0 == strncmp(BLF_APPTEXT_COL_INFO_TEXT_CHANNELS"Metadata: Channels", &pd[col_info_pos], col_info_len)) {
              /* BLF_APPTEXT_METADATA: BLF_APPTEXT_XML_CHANNELS */
                  if (writer_data->iface_to_channel_names_recovered) {
                  apptext_header.reservedAppText1 = (BLF_APPTEXT_XML_CHANNELS0x02 << 24) | (0xffffff & payload_len);
              }
          } else if (col_info_len == strlen(BLF_APPTEXT_COL_INFO_TEXT_IDENTITY"Metadata: Identity") && 0 == strncmp(BLF_APPTEXT_COL_INFO_TEXT_IDENTITY"Metadata: Identity", &pd[col_info_pos], col_info_len)) {
              /* BLF_APPTEXT_METADATA: BLF_APPTEXT_XML_IDENTITY */
              apptext_header.reservedAppText1 = (BLF_APPTEXT_XML_IDENTITY0x03 << 24) | (0xffffff & payload_len);
          // else if
              /* BLF_APPTEXT_COMMENT */
              /* tags: BLF_APPTEXT_TAG_DISS_DEFAULT, BLF_APPTEXT_COL_PROT_TEXT, "Comment: %s" */
              // TODO            } else {
          // else if
              /* BLF_APPTEXT_ATTACHMENT */
              /* tags: BLF_APPTEXT_TAG_DISS_DEFAULT, BLF_APPTEXT_COL_PROT_TEXT, "Attachment: %s" */
              // TODO            } else {
          // else if
              /* BLF_APPTEXT_TRACELINE */
              /* tags: BLF_APPTEXT_TAG_DISS_DEFAULT, BLF_APPTEXT_COL_PROT_TEXT, "Trace line%s: %s" */
              // TODO
          } else {
              return true1; /* just leave */
          }

          fix_endianness_blf_apptext_header(&apptext_header);
          if (!blf_dump_objheader(wdh, err, obj_timestamp, BLF_OBJTYPE_APP_TEXT65, sizeof(blf_apptext_t) + payload_len)) {
              return false0;
          }
          if (!wtap_dump_file_write(wdh, &(apptext_header), sizeof(blf_apptext_t), err)) {
              return false0;
          }
          if (!wtap_dump_file_write(wdh, &(pd[pos]), payload_len, err)) {
              return false0;
          }
          return true1;
      }
      // else if
      /* BLF_OBJTYPE_ETHERNET_STATUS */
      /* tags: BLF_APPTEXT_TAG_DISS_ETHSTATUS */
      // TODO

      // else if
      /* BLF_OBJTYPE_ETHERNET_PHY_STATE */
      /* tags: BLF_APPTEXT_TAG_DISS_ETHPHYSTATUS */
      // TODO
  }

  return true1;
4983}

4985static bool_Bool blf_dump_interface_setup_by_idb_desc(wtap_dumper *wdh, int *err _U___attribute__((unused))) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  for (unsigned i = 0; i < wdh->interface_data->len; i++) {
      ws_debug("interface: %d", i)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 4989, __func__, "interface: %d", i); } } while (0);

      /* get interface data */
      wtap_block_t idb = g_array_index(wdh->interface_data, wtap_block_t, i)(((wtap_block_t*) (void *) (wdh->interface_data)->data)
 [(i)]);
      if (idb == NULL((void*)0)) {
          return false0;
      }

      char *iface_descr = NULL((void*)0);
      bool_Bool iface_descr_found = wtap_block_get_string_option_value(idb, OPT_IDB_DESCRIPTION3, &iface_descr) == WTAP_OPTTYPE_SUCCESS;

      if (!iface_descr_found) {
          ws_debug("IDB interface description not found! We need to map the interfaces.")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5001, __func__, "IDB interface description not found! We need to map the interfaces."
); } } while (0);
          return false0;
      }

      if (strncmp(iface_descr, "BLF-", 4) != 0) {
          ws_debug("IDB interface description found but not BLF format! We have to map freely the interfaces.")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5006, __func__, "IDB interface description found but not BLF format! We have to map freely the interfaces."
); } } while (0);
          return false0;
      }

      if (strncmp(iface_descr, "BLF-ETH-", 8) == 0) {
          char *endptr;
          uint16_t channel = (uint16_t)strtol(&iface_descr[8], &endptr, 16);
          uint16_t hwchannel = (uint16_t)strtol(&endptr[1], NULL((void*)0), 16);

          if (!blf_dump_set_interface_mapping(wdh, i, WTAP_ENCAP_ETHERNET1, channel, hwchannel)) {
              return false0;
          }
      } else if (strncmp(iface_descr, "BLF-CAN-", 8) == 0) {
          uint16_t channel = (uint16_t)strtol(&iface_descr[8], NULL((void*)0), 16);

          if (!blf_dump_set_interface_mapping(wdh, i, WTAP_ENCAP_SOCKETCAN125, channel, UINT16_MAX(65535))) {
              return false0;
          }
      } else if (strncmp(iface_descr, "BLF-LIN-", 8) == 0) {
          uint16_t channel = (uint16_t)strtol(&iface_descr[8], NULL((void*)0), 16);

          if (!blf_dump_set_interface_mapping(wdh, i, WTAP_ENCAP_LIN107, channel, UINT16_MAX(65535))) {
              return false0;
          }
      } else if (strncmp(iface_descr, "BLF-FR-", 7) == 0) {
          uint16_t channel = (uint16_t)strtol(&iface_descr[7], NULL((void*)0), 16);

          if (!blf_dump_set_interface_mapping(wdh, i, WTAP_ENCAP_FLEXRAY106, channel, UINT16_MAX(65535))) {
              return false0;
          }
      }
  }

  writer_data->iface_to_channel_names_recovered = true1;
  return true1;
5041}

5043static bool_Bool blf_dump_interface_setup(wtap_dumper *wdh, int *err) {
  //blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;

  /* Try 1: BLF details in Interface Description */
  if (blf_dump_interface_setup_by_idb_desc(wdh, err)) {
      return true1;
  }

  /* Try 2: Generate new IDs by mapping Interface IDs and also add names to BLF */
  for (unsigned i = 0; i < wdh->interface_data->len; i++) {
      ws_debug("i: %d", i)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5053, __func__, "i: %d", i); } } while (0);

      /* get interface data */
      wtap_block_t idb = g_array_index(wdh->interface_data, wtap_block_t, i)(((wtap_block_t*) (void *) (wdh->interface_data)->data)
 [(i)]);
      if (idb == NULL((void*)0)) {
          return false0;
      }

      const wtapng_if_descr_mandatory_t *mand_data = (wtapng_if_descr_mandatory_t *) idb->mandatory_data;

      if (mand_data->wtap_encap == WTAP_ENCAP_ETHERNET1 || mand_data->wtap_encap == WTAP_ENCAP_SLL25 ||
          mand_data->wtap_encap == WTAP_ENCAP_LIN107 || mand_data->wtap_encap == WTAP_ENCAP_SOCKETCAN125) {

          char *iface_name = NULL((void*)0);
          bool_Bool iface_name_found = wtap_block_get_string_option_value(idb, OPT_IDB_NAME2, &iface_name) == WTAP_OPTTYPE_SUCCESS;

          /* BLF can only support 256 channels */
          if (iface_name_found && iface_name != NULL((void*)0) && i < 256) {
              blf_apptext_t apptextheader;
              apptextheader.source = BLF_APPTEXT_CHANNEL0x00000001;

              apptextheader.reservedAppText1 = 0x01 | ((uint8_t)i << 8);

              switch (mand_data->wtap_encap) {
              case WTAP_ENCAP_ETHERNET1:
                  apptextheader.reservedAppText1 |= (BLF_BUSTYPE_ETHERNET11 << 16);
                  break;

              case WTAP_ENCAP_SLL25:
              case WTAP_ENCAP_SOCKETCAN125:
                  apptextheader.reservedAppText1 |= (BLF_BUSTYPE_CAN1 << 16);
                  /* TODO: Do we have to set CAN-FD flag? (bit 24)*/
                  break;

              case WTAP_ENCAP_LIN107:
                  apptextheader.reservedAppText1 |= (BLF_BUSTYPE_LIN5 << 16);
                  break;

              }

              apptextheader.reservedAppText2 = 0;

              /* We do not know the name of the database file.*/
              const char prefix[] = "unknown.db;";
              uint32_t textlength = (uint32_t)(strlen(prefix) + strlen(iface_name));
              apptextheader.textLength = textlength;

              fix_endianness_blf_apptext_header(&apptextheader);

              if (!blf_dump_objheader(wdh, err, 0, BLF_OBJTYPE_APP_TEXT65, sizeof(apptextheader) + textlength)) {
                  return false0;
              }

              if (!wtap_dump_file_write(wdh, &(apptextheader), sizeof(blf_apptext_t), err)) {
                  return false0;
              }

              if (!wtap_dump_file_write(wdh, prefix, strlen(prefix), err)) {
                  return false0;
              }

              /* write channel name !*/
              if (!wtap_dump_file_write(wdh, iface_name, strlen(iface_name), err)) {
                  return false0;
              }

              /* mapping up to 256 interface ids to channels directly */
              if (!blf_dump_set_interface_mapping(wdh, i, mand_data->wtap_encap, (uint16_t)i, UINT16_MAX(65535))) {
                  return false0;
              }
          }
      }
  }

  return true1;
5128}

5130static bool_Bool blf_dump(wtap_dumper *wdh, const wtap_rec *rec, int *err, char **err_info) {
  blf_writer_data_t *writer_data = (blf_writer_data_t *)wdh->priv;
  ws_debug("encap = %d (%s) rec type = %u", rec->rec_header.packet_header.pkt_encap,do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5133, __func__, "encap = %d (%s) rec type = %u", rec->rec_header
.packet_header.pkt_encap, wtap_encap_description(rec->rec_header
.packet_header.pkt_encap), rec->rec_type); } } while (0)
      wtap_encap_description(rec->rec_header.packet_header.pkt_encap), rec->rec_type)do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5133, __func__, "encap = %d (%s) rec type = %u", rec->rec_header
.packet_header.pkt_encap, wtap_encap_description(rec->rec_header
.packet_header.pkt_encap), rec->rec_type); } } while (0);

  /* TODO */
  switch (rec->rec_type) {
  case REC_TYPE_PACKET0:
      break;
  default:
      *err = WTAP_ERR_UNWRITABLE_REC_TYPE-24;
      return false0;
  }

  /* logcontainer full already? we just estimate the headers/overhead to be less than 100 */
  blf_dump_check_logcontainer_full(wdh, err, err_info, rec->rec_header.packet_header.len + 100);

  if (!writer_data->start_time_set) {
      /* TODO: consider to set trace start time to first packet time stamp - is this the lowest timestamp? how to know? */
      writer_data->start_time = 0;
      writer_data->start_time_set = true1;
  }

  uint64_t obj_timestamp = (rec->ts.secs * 1000 * 1000 * 1000 + rec->ts.nsecs);

  if (writer_data->end_time < obj_timestamp) {
      writer_data->end_time = obj_timestamp;
  }

  /* reduce by BLF start offset */
  obj_timestamp = obj_timestamp - writer_data->start_time;
  writer_data->object_count += 1;

  switch (rec->rec_header.packet_header.pkt_encap) {
  case WTAP_ENCAP_ETHERNET1: /* 1 */
      return blf_dump_ethernet(wdh, rec, err, err_info, obj_timestamp);
      break;

  case WTAP_ENCAP_SLL25: /* 25 */
      return blf_dump_sll(wdh, rec, err, err_info, obj_timestamp);
      break;

  case WTAP_ENCAP_FLEXRAY106: /* 106 */
      return blf_dump_flexray(wdh, rec, err, err_info, obj_timestamp);
      break;

  case WTAP_ENCAP_LIN107: /* 107 */
      return blf_dump_lin(wdh, rec, err, err_info, obj_timestamp);
      break;

  case WTAP_ENCAP_SOCKETCAN125: { /* 125 */
      const uint8_t *pd = ws_buffer_start_ptr(&rec->data);
      size_t length = ws_buffer_length(&rec->data);
      return blf_dump_socketcan(wdh, rec, err, err_info, obj_timestamp, pd, length, false0, false0, false0, false0);
  }
      break;

  case WTAP_ENCAP_WIRESHARK_UPPER_PDU155: /* 155 */
      return blf_dump_upper_pdu(wdh, rec, err, err_info, obj_timestamp);
      break;

  default:
      /* we did not write, so correct count */
      writer_data->object_count -= 1;
  }

  return true1;
5197}

5199/* Returns 0 if we could write the specified encapsulation type,
 an error indication otherwise. */
5201static int blf_dump_can_write_encap(int wtap_encap) {
  ws_debug("encap = %d (%s)", wtap_encap, wtap_encap_description(wtap_encap))do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5202, __func__, "encap = %d (%s)", wtap_encap, wtap_encap_description
(wtap_encap)); } } while (0);

  /* Per-packet encapsulation is supported. */
  if (wtap_encap == WTAP_ENCAP_PER_PACKET-1)
      return 0;

  switch (wtap_encap) {
  /* fall through */
  case WTAP_ENCAP_ETHERNET1:
  case WTAP_ENCAP_SLL25:
  case WTAP_ENCAP_FLEXRAY106:
  case WTAP_ENCAP_LIN107:
  case WTAP_ENCAP_SOCKETCAN125:
  case WTAP_ENCAP_WIRESHARK_UPPER_PDU155:
      return 0;
  }

  return WTAP_ERR_UNWRITABLE_ENCAP-8;
5220}

5222static bool_Bool blf_add_idb(wtap_dumper *wdh _U___attribute__((unused)), wtap_block_t idb _U___attribute__((unused)), int *err _U___attribute__((unused)), char **err_info _U___attribute__((unused))) {
  ws_debug("entering function")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5223, __func__, "entering function"); } } while (0);
  /* TODO: is there any reason to keep this? */

  return true1;
5227}

5229/* Finish writing to a dump file.
 Returns true on success, false on failure. */
5231static bool_Bool blf_dump_finish(wtap_dumper *wdh, int *err, char **err_info) {
  if (!blf_dump_close_logcontainer(wdh, err, err_info)) {
      return false0;
  }

  if (!blf_finalize_file_header(wdh, err)) {
      return false0;
  }

  /* File is finished, do not touch anymore ! */

  ws_debug("leaving function")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5242, __func__, "leaving function"); } } while (0);
  return true1;
5244}

5246/* Returns true on success, false on failure; sets "*err" to an error code on
 failure */
5248static bool_Bool
5249blf_dump_open(wtap_dumper *wdh, int *err, char **err_info) {
  ws_debug("entering function")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5250, __func__, "entering function"); } } while (0);
1
Taking true branch→

  if (wdh == NULL((void*)0) || wdh->priv != NULL((void*)0)) {
2
←
Assuming 'wdh' is not equal to NULL→
3
←
Assuming field 'priv' is equal to NULL→
4
←
Taking false branch→
      *err = WTAP_ERR_INTERNAL-21;
      ws_debug("internal error: blf wdh is NULL or private data already set!")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5254, __func__, "internal error: blf wdh is NULL or private data already set!"
); } } while (0);
      return false0;
  }

  wdh->subtype_add_idb = blf_add_idb;
  wdh->subtype_write = blf_dump;
  wdh->subtype_finish = blf_dump_finish;

  /* set up priv data */
  blf_writer_data_t *writer_data = g_new(blf_writer_data_t, 1)((blf_writer_data_t *) g_malloc_n ((1), sizeof (blf_writer_data_t
)));
  wdh->priv = writer_data;

  /* set up and init interface mappings */
  writer_data->iface_to_channel_array = g_array_new(true1, true1, sizeof(blf_channel_to_iface_entry_t));
  blf_dump_expand_interface_mapping(wdh, wdh->interface_data->len);
5
←
Calling 'blf_dump_expand_interface_mapping'→
  writer_data->iface_to_channel_names_recovered = false0;

  writer_data->fileheader = NULL((void*)0);
  writer_data->object_count = 0;
  writer_data->start_time = 0;
  writer_data->start_time_set = false0;
  writer_data->end_time = 0;

  writer_data->logcontainer_start = LOG_CONTAINER_NONE(18446744073709551615UL);

  /* create the blf header structure and attach to wdh */
  if (!blf_init_file_header(wdh, err)) {
      return false0;
  }

  /* write space in output file for header */
  if (!blf_write_file_header_zeros(wdh, err)) {
      return false0;
  }

  ws_debug("wrote blf file header")do { if (1) { ws_log_full("Wiretap", LOG_LEVEL_DEBUG, "wiretap/blf.c"
, 5289, __func__, "wrote blf file header"); } } while (0);

  /* Create first log_container */
  if (!blf_dump_start_logcontainer(wdh, err, err_info)) {
      return false0;
  }

  if (!blf_dump_interface_setup(wdh, err)) {
      return false0;
  }

  return true1;
5301}

5303static const struct file_type_subtype_info blf_info = {
      "Vector Informatik Binary Logging Format (BLF) logfile", "blf", "blf", NULL((void*)0),
      false0, BLOCKS_SUPPORTED(blf_blocks_supported)(sizeof (blf_blocks_supported) / sizeof (blf_blocks_supported
)[0]), blf_blocks_supported,
      blf_dump_can_write_encap, blf_dump_open, NULL((void*)0)
5307};

5309void register_blf(void)
5310{
  blf_file_type_subtype = wtap_register_file_type_subtype(&blf_info);

  /*
   * Register name for backwards compatibility with the
   * wtap_filetypes table in Lua.
   */
  wtap_register_backwards_compatibility_lua_name("BLF", blf_file_type_subtype);
5318}

5320/*
* Editor modelines  -  https://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 4
* tab-width: 8
* indent-tabs-mode: nil
* End:
*
* vi: set shiftwidth=4 tabstop=8 expandtab:
* :indentSize=4:tabSize=8:noTabs=true:
*/