osmocom
/
wireshark
11
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
wireshark/wiretap/blf.c

3526 lines
139 KiB
C
Raw Permalink Blame History

/* blf.c
*
* Wiretap Library
* Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>
*
* File format support for the Binary Log File (BLF) file format from
* Vector Informatik decoder
* Copyright (c) 2021-2022 by Dr. Lars Voelker <lars.voelker@technica-engineering.de>
*
* 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.
*/
#include <config.h>
#define WS_LOG_DOMAIN LOG_DOMAIN_WIRETAP
#include "blf.h"
#include <epan/dissectors/packet-socketcan.h>
#include <string.h>
#include <errno.h>
#include <epan/value_string.h>
#include <wsutil/wslog.h>
#include <wsutil/exported_pdu_tlvs.h>
#include <wsutil/strtoi.h>
#include "file_wrappers.h"
#include "wtap-int.h"
#ifdef HAVE_ZLIB
#define ZLIB_CONST
#include <zlib.h>
#endif /* HAVE_ZLIB */
static const guint8 blf_magic[] = { 'L', 'O', 'G', 'G' };
static const guint8 blf_obj_magic[] = { 'L', 'O', 'B', 'J' };
static int blf_file_type_subtype = -1;
void register_blf(void);
static gboolean blf_read(wtap *wth, wtap_rec *rec, Buffer *buf, int *err, gchar **err_info, gint64 *data_offset);
static gboolean blf_seek_read(wtap *wth, gint64 seek_off, wtap_rec* rec, Buffer *buf, int *err, gchar **err_info);
static void blf_close(wtap *wth);
/*
* 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.
* When no compression is used the file is accessed directly.
*/
typedef struct blf_log_container {
gint64 infile_start_pos; /* start position of log container in file */
guint64 infile_length; /* length of log container in file */
guint64 infile_data_start; /* start position of data in log container in file */
guint64 real_start_pos; /* decompressed (virtual) start position including header */
guint64 real_length; /* decompressed length */
gint64 real_first_object_pos; /* where does the first obj start? */
guint64 real_leftover_bytes; /* how many bytes are left over for the next container? */
guint16 compression_method; /* 0: uncompressed, 2: zlib */
unsigned char *real_data; /* cache for decompressed data */
} blf_log_container_t;
typedef struct blf_data {
gint64 start_of_last_obj;
gint64 current_real_seek_pos;
guint64 start_offset_ns;
GArray *log_containers;
GHashTable *channel_to_iface_ht;
GHashTable *channel_to_name_ht;
guint32 next_interface_id;
} blf_t;
typedef struct blf_params {
wtap *wth;
wtap_rec *rec;
Buffer *buf;
FILE_T fh;
gboolean random;
gboolean pipe;
blf_t *blf_data;
} blf_params_t;
typedef struct blf_channel_to_iface_entry {
int pkt_encap;
guint16 channel;
guint16 hwchannel;
guint32 interface_id;
} blf_channel_to_iface_entry_t;
static void
blf_free_key(gpointer key) {
g_free(key);
}
static void
blf_free_channel_to_iface_entry(gpointer data) {
g_free(data);
}
static void
blf_free_channel_to_name_entry(gpointer data) {
g_free(data);
}
static gint64
blf_calc_key_value(int pkt_encap, guint16 channel, guint16 hwchannel) {
return (gint64)(((guint64)pkt_encap << 32) | ((guint64)hwchannel << 16) | (guint64)channel);
}
static void add_interface_name(wtap_block_t int_data, int pkt_encap, guint16 channel, guint16 hwchannel, gchar *name) {
if (name != NULL) {
wtap_block_add_string_option_format(int_data, OPT_IDB_NAME, "%s", name);
} else {
switch (pkt_encap) {
case WTAP_ENCAP_ETHERNET:
/* we use UINT16_MAX to encode no hwchannel */
if (hwchannel == UINT16_MAX) {
wtap_block_add_string_option_format(int_data, OPT_IDB_NAME, "ETH-%u", channel);
} else {
wtap_block_add_string_option_format(int_data, OPT_IDB_NAME, "ETH-%u-%u", channel, hwchannel);
}
break;
case WTAP_ENCAP_IEEE_802_11:
wtap_block_add_string_option_format(int_data, OPT_IDB_NAME, "WLAN-%u", channel);
break;
case WTAP_ENCAP_FLEXRAY:
wtap_block_add_string_option_format(int_data, OPT_IDB_NAME, "FR-%u", channel);
break;
case WTAP_ENCAP_LIN:
wtap_block_add_string_option_format(int_data, OPT_IDB_NAME, "LIN-%u", channel);
break;
case WTAP_ENCAP_SOCKETCAN:
wtap_block_add_string_option_format(int_data, OPT_IDB_NAME, "CAN-%u", channel);
break;
default:
wtap_block_add_string_option_format(int_data, OPT_IDB_NAME, "ENCAP_%d-%u", pkt_encap, channel);
}
}
}
static guint32
blf_add_interface(blf_params_t *params, int pkt_encap, guint32 channel, guint16 hwchannel, gchar *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;
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_NSEC;
wtap_block_add_uint8_option(int_data, OPT_IDB_TSRESOL, 9);
if_descr_mand->snap_len = WTAP_MAX_PACKET_SIZE_STANDARD;
if_descr_mand->num_stat_entries = 0;
if_descr_mand->interface_statistics = NULL;
wtap_add_idb(params->wth, int_data);
if (params->wth->file_encap == WTAP_ENCAP_NONE) {
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;
}
}
gint64 *key = NULL;
key = g_new(gint64, 1);
*key = blf_calc_key_value(pkt_encap, channel, hwchannel);
item = g_new(blf_channel_to_iface_entry_t, 1);
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;
}
/** 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.
*/
static gboolean
blf_prepare_interface_name(blf_params_t* params, int pkt_encap, guint16 channel, guint16 hwchannel, gchar* name, gboolean force_new_name) {
gint64 key = blf_calc_key_value(pkt_encap, channel, hwchannel);
gchar* old_name;
gchar* new_name;
gchar* iface_name;
gint64* new_key;
gboolean ret;
if (params->blf_data->channel_to_name_ht == NULL) {
return FALSE;
}
old_name = (gchar *)g_hash_table_lookup(params->blf_data->channel_to_name_ht, &key);
if (old_name != NULL && force_new_name) {
if (!g_hash_table_remove(params->blf_data->channel_to_name_ht, &key)) {
return FALSE;
}
old_name = NULL;
}
if (old_name == NULL && name != NULL) {
new_key = g_new(gint64, 1);
*new_key = key;
new_name = ws_strdup(name);
if (!g_hash_table_insert(params->blf_data->channel_to_name_ht, new_key, new_name)) {
return FALSE;
}
}
else {
new_name = old_name;
}
if (pkt_encap == WTAP_ENCAP_ETHERNET) {
/* Just for Ethernet, prepare the equivalent STATUS interface */
iface_name = new_name != NULL ? ws_strdup_printf("STATUS-%s", new_name) : NULL;
ret = blf_prepare_interface_name(params, WTAP_ENCAP_WIRESHARK_UPPER_PDU, channel, hwchannel, iface_name, force_new_name);
if (iface_name) {
g_free(iface_name);
}
if (!ret) {
return FALSE;
}
}
return TRUE;
}
static guint32
blf_lookup_interface(blf_params_t *params, int pkt_encap, guint16 channel, guint16 hwchannel, gchar *name) {
gint64 key = blf_calc_key_value(pkt_encap, channel, hwchannel);
blf_channel_to_iface_entry_t* item;
gchar* saved_name;
guint32 ret;
if (params->blf_data->channel_to_iface_ht == NULL) {
return 0;
}
item = (blf_channel_to_iface_entry_t *)g_hash_table_lookup(params->blf_data->channel_to_iface_ht, &key);
if (item != NULL) {
return item->interface_id;
}
else {
saved_name = (gchar*)g_hash_table_lookup(params->blf_data->channel_to_name_ht, &key);
if (saved_name != NULL) {
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);
}
}
}
static void
fix_endianness_blf_date(blf_date_t *date) {
date->year = GUINT16_FROM_LE(date->year);
date->month = GUINT16_FROM_LE(date->month);
date->dayofweek = GUINT16_FROM_LE(date->dayofweek);
date->day = GUINT16_FROM_LE(date->day);
date->hour = GUINT16_FROM_LE(date->hour);
date->mins = GUINT16_FROM_LE(date->mins);
date->sec = GUINT16_FROM_LE(date->sec);
date->ms = GUINT16_FROM_LE(date->ms);
}
static void
fix_endianness_blf_fileheader(blf_fileheader_t *header) {
header->header_length = GUINT32_FROM_LE(header->header_length);
header->len_compressed = GUINT64_FROM_LE(header->len_compressed);
header->len_uncompressed = GUINT64_FROM_LE(header->len_uncompressed);
header->obj_count = GUINT32_FROM_LE(header->obj_count);
header->obj_read = GUINT32_FROM_LE(header->obj_read);
fix_endianness_blf_date(&(header->start_date));
fix_endianness_blf_date(&(header->end_date));
header->length3 = GUINT32_FROM_LE(header->length3);
}
static void
fix_endianness_blf_blockheader(blf_blockheader_t *header) {
header->header_length = GUINT16_FROM_LE(header->header_length);
header->header_type = GUINT16_FROM_LE(header->header_type);
header->object_length = GUINT32_FROM_LE(header->object_length);
header->object_type = GUINT32_FROM_LE(header->object_type);
}
static void
fix_endianness_blf_logcontainerheader(blf_logcontainerheader_t *header) {
header->compression_method = GUINT16_FROM_LE(header->compression_method);
header->res1 = GUINT16_FROM_LE(header->res1);
header->res2 = GUINT32_FROM_LE(header->res2);
header->uncompressed_size = GUINT32_FROM_LE(header->uncompressed_size);
header->res4 = GUINT32_FROM_LE(header->res4);
}
static void
fix_endianness_blf_logobjectheader(blf_logobjectheader_t *header) {
header->flags = GUINT32_FROM_LE(header->flags);
header->client_index = GUINT16_FROM_LE(header->client_index);
header->object_version = GUINT16_FROM_LE(header->object_version);
header->object_timestamp = GUINT64_FROM_LE(header->object_timestamp);
}
static void
fix_endianness_blf_logobjectheader2(blf_logobjectheader2_t *header) {
header->flags = GUINT32_FROM_LE(header->flags);
header->object_version = GUINT16_FROM_LE(header->object_version);
header->object_timestamp = GUINT64_FROM_LE(header->object_timestamp);
header->original_timestamp = GUINT64_FROM_LE(header->object_timestamp);
}
static void
fix_endianness_blf_logobjectheader3(blf_logobjectheader3_t *header) {
header->flags = GUINT32_FROM_LE(header->flags);
header->static_size = GUINT16_FROM_LE(header->static_size);
header->object_version = GUINT16_FROM_LE(header->object_version);
header->object_timestamp = GUINT64_FROM_LE(header->object_timestamp);
}
static void
fix_endianness_blf_ethernetframeheader(blf_ethernetframeheader_t *header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->direction = GUINT16_FROM_LE(header->direction);
header->ethtype = GUINT16_FROM_LE(header->ethtype);
header->tpid = GUINT16_FROM_LE(header->tpid);
header->tci = GUINT16_FROM_LE(header->tci);
header->payloadlength = GUINT16_FROM_LE(header->payloadlength);
}
static void
fix_endianness_blf_ethernetframeheader_ex(blf_ethernetframeheader_ex_t *header) {
header->struct_length = GUINT16_FROM_LE(header->struct_length);
header->flags = GUINT16_FROM_LE(header->flags);
header->channel = GUINT16_FROM_LE(header->channel);
header->hw_channel = GUINT16_FROM_LE(header->hw_channel);
header->frame_duration = GUINT64_FROM_LE(header->frame_duration);
header->frame_checksum = GUINT32_FROM_LE(header->frame_checksum);
header->direction = GUINT16_FROM_LE(header->direction);
header->frame_length = GUINT16_FROM_LE(header->frame_length);
header->frame_handle = GUINT32_FROM_LE(header->frame_handle);
header->error = GUINT32_FROM_LE(header->error);
}
static void
fix_endianness_blf_wlanframeheader(blf_wlanframeheader_t* header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->flags = GUINT16_FROM_LE(header->flags);
header->signal_strength = GUINT16_FROM_LE(header->signal_strength);
header->signal_quality = GUINT16_FROM_LE(header->signal_quality);
header->frame_length = GUINT16_FROM_LE(header->frame_length);
}
static void
fix_endianness_blf_canmessage(blf_canmessage_t *header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->id = GUINT32_FROM_LE(header->id);
}
static void
fix_endianness_blf_canmessage2_trailer(blf_canmessage2_trailer_t *header) {
header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns);
header->reserved2 = GUINT16_FROM_LE(header->reserved1);
}
static void
fix_endianness_blf_canfdmessage(blf_canfdmessage_t *header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->id = GUINT32_FROM_LE(header->id);
header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns);
header->reservedCanFdMessage2 = GUINT32_FROM_LE(header->reservedCanFdMessage2);
}
static void
fix_endianness_blf_canfdmessage64(blf_canfdmessage64_t *header) {
header->id = GUINT32_FROM_LE(header->id);
header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns);
header->flags = GUINT32_FROM_LE(header->flags);
header->btrCfgArb = GUINT32_FROM_LE(header->btrCfgArb);
header->btrCfgData = GUINT32_FROM_LE(header->btrCfgData);
header->timeOffsetBrsNs = GUINT32_FROM_LE(header->timeOffsetBrsNs);
header->timeOffsetCrcDelNs = GUINT32_FROM_LE(header->timeOffsetCrcDelNs);
header->bitCount = GUINT16_FROM_LE(header->bitCount);
header->crc = GUINT32_FROM_LE(header->crc);
}
static void
fix_endianness_blf_canerror(blf_canerror_t *header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->length = GUINT16_FROM_LE(header->length);
}
static void
fix_endianness_blf_canerrorext(blf_canerrorext_t *header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->length = GUINT16_FROM_LE(header->length);
header->flags = GUINT32_FROM_LE(header->flags);
header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns);
header->id = GUINT32_FROM_LE(header->id);
header->errorCodeExt = GUINT16_FROM_LE(header->errorCodeExt);
}
static void
fix_endianness_blf_canfderror64(blf_canfderror64_t *header) {
header->flags = GUINT16_FROM_LE(header->flags);
header->errorCodeExt = GUINT16_FROM_LE(header->errorCodeExt);
header->extFlags = GUINT16_FROM_LE(header->extFlags);
header->id = GUINT32_FROM_LE(header->id);
header->frameLength_in_ns = GUINT32_FROM_LE(header->frameLength_in_ns);
header->btrCfgArb = GUINT32_FROM_LE(header->btrCfgArb);
header->btrCfgData = GUINT32_FROM_LE(header->btrCfgData);
header->timeOffsetBrsNs = GUINT32_FROM_LE(header->timeOffsetBrsNs);
header->timeOffsetCrcDelNs = GUINT32_FROM_LE(header->timeOffsetCrcDelNs);
header->crc = GUINT32_FROM_LE(header->crc);
header->errorPosition = GUINT16_FROM_LE(header->errorPosition);
}
static void
fix_endianness_blf_flexraydata(blf_flexraydata_t *header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->messageId = GUINT16_FROM_LE(header->messageId);
header->crc = GUINT16_FROM_LE(header->crc);
header->reservedFlexRayData2 = GUINT16_FROM_LE(header->reservedFlexRayData2);
}
static void
fix_endianness_blf_flexraymessage(blf_flexraymessage_t *header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->fpgaTick = GUINT32_FROM_LE(header->fpgaTick);
header->fpgaTickOverflow = GUINT32_FROM_LE(header->fpgaTickOverflow);
header->clientIndexFlexRayV6Message = GUINT32_FROM_LE(header->clientIndexFlexRayV6Message);
header->clusterTime = GUINT32_FROM_LE(header->clusterTime);
header->frameId = GUINT16_FROM_LE(header->frameId);
header->headerCrc = GUINT16_FROM_LE(header->headerCrc);
header->frameState = GUINT16_FROM_LE(header->frameState);
header->reservedFlexRayV6Message2 = GUINT16_FROM_LE(header->reservedFlexRayV6Message2);
}
static void
fix_endianness_blf_flexrayrcvmessage(blf_flexrayrcvmessage_t *header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->version = GUINT16_FROM_LE(header->version);
header->channelMask = GUINT16_FROM_LE(header->channelMask);
header->dir = GUINT16_FROM_LE(header->dir);
header->clientIndex = GUINT32_FROM_LE(header->clientIndex);
header->clusterNo = GUINT32_FROM_LE(header->clusterNo);
header->frameId = GUINT16_FROM_LE(header->frameId);
header->headerCrc1 = GUINT16_FROM_LE(header->headerCrc1);
header->headerCrc2 = GUINT16_FROM_LE(header->headerCrc2);
header->payloadLength = GUINT16_FROM_LE(header->payloadLength);
header->payloadLengthValid = GUINT16_FROM_LE(header->payloadLengthValid);
header->cycle = GUINT16_FROM_LE(header->cycle);
header->tag = GUINT32_FROM_LE(header->tag);
header->data = GUINT32_FROM_LE(header->data);
header->frameFlags = GUINT32_FROM_LE(header->frameFlags);
header->appParameter = GUINT32_FROM_LE(header->appParameter);
/* 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);
*/
}
static void
fix_endianness_blf_linmessage(blf_linmessage_t* message) {
message->channel = GUINT16_FROM_LE(message->channel);
message->crc = GUINT16_FROM_LE(message->crc);
/* skip the optional part
message->res2 = GUINT32_FROM_LE(message->res2);
*/
}
static void
fix_endianness_blf_linmessage2(blf_linmessage2_t* message) {
int i;
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.sof = GUINT64_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.sof);
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.eventBaudrate = GUINT32_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.eventBaudrate);
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel = GUINT16_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel);
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.synchBreakLength = GUINT64_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.synchBreakLength);
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.synchDelLength = GUINT64_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.synchDelLength);
message->linDataByteTimestampEvent.linMessageDescriptor.supplierId = GUINT16_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.supplierId);
message->linDataByteTimestampEvent.linMessageDescriptor.messageId = GUINT16_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.messageId);
for (i = 0; i < 9; i++) {
message->linDataByteTimestampEvent.databyteTimestamps[i] = GUINT64_FROM_LE(message->linDataByteTimestampEvent.databyteTimestamps[i]);
}
message->crc = GUINT16_FROM_LE(message->crc);
/* 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);
*/
}
static void
fix_endianness_blf_lincrcerror2(blf_lincrcerror2_t* message) {
int i;
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.sof = GUINT64_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.sof);
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.eventBaudrate = GUINT32_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.eventBaudrate);
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel = GUINT16_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel);
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.synchBreakLength = GUINT64_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.synchBreakLength);
message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.synchDelLength = GUINT64_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.synchDelLength);
message->linDataByteTimestampEvent.linMessageDescriptor.supplierId = GUINT16_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.supplierId);
message->linDataByteTimestampEvent.linMessageDescriptor.messageId = GUINT16_FROM_LE(message->linDataByteTimestampEvent.linMessageDescriptor.messageId);
for (i = 0; i < 9; i++) {
message->linDataByteTimestampEvent.databyteTimestamps[i] = GUINT64_FROM_LE(message->linDataByteTimestampEvent.databyteTimestamps[i]);
}
message->crc = GUINT16_FROM_LE(message->crc);
/* 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);
*/
}
static void
fix_endianness_blf_linsenderror2(blf_linsenderror2_t* message) {
message->linMessageDescriptor.linSynchFieldEvent.linBusEvent.sof = GUINT64_FROM_LE(message->linMessageDescriptor.linSynchFieldEvent.linBusEvent.sof);
message->linMessageDescriptor.linSynchFieldEvent.linBusEvent.eventBaudrate = GUINT32_FROM_LE(message->linMessageDescriptor.linSynchFieldEvent.linBusEvent.eventBaudrate);
message->linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel = GUINT16_FROM_LE(message->linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel);
message->linMessageDescriptor.linSynchFieldEvent.synchBreakLength = GUINT64_FROM_LE(message->linMessageDescriptor.linSynchFieldEvent.synchBreakLength);
message->linMessageDescriptor.linSynchFieldEvent.synchDelLength = GUINT64_FROM_LE(message->linMessageDescriptor.linSynchFieldEvent.synchDelLength);
message->linMessageDescriptor.supplierId = GUINT16_FROM_LE(message->linMessageDescriptor.supplierId);
message->linMessageDescriptor.messageId = GUINT16_FROM_LE(message->linMessageDescriptor.messageId);
message->eoh = GUINT64_FROM_LE(message->eoh);
/* skip the optional part
message->exactHeaderBaudrate = GUINT64_FROM_LE(message->exactHeaderBaudrate);
message->earlyStopBitOffset = GUINT32_FROM_LE(message->earlyStopBitOffset);
*/
}
static void
fix_endianness_blf_apptext_header(blf_apptext_t *header) {
header->source = GUINT32_FROM_LE(header->source);
header->reservedAppText1 = GUINT32_FROM_LE(header->reservedAppText1);
header->textLength = GUINT32_FROM_LE(header->textLength);
header->reservedAppText2 = GUINT32_FROM_LE(header->reservedAppText2);
}
static void
fix_endianness_blf_ethernet_status_header(blf_ethernet_status_t* header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->flags = GUINT16_FROM_LE(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);
}
static void
fix_endianness_blf_ethernet_phystate_header(blf_ethernet_phystate_t* header) {
header->channel = GUINT16_FROM_LE(header->channel);
header->flags = GUINT16_FROM_LE(header->flags);
}
static void
blf_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_first_object_pos = -1;
tmp->real_leftover_bytes = G_MAXUINT64;
tmp->real_data = NULL;
tmp->compression_method = 0;
}
gint
blf_logcontainers_cmp(gconstpointer a, gconstpointer b) {
blf_log_container_t* container_a = (blf_log_container_t*)a;
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;
}
}
gint
blf_logcontainers_search(gconstpointer a, gconstpointer b) {
blf_log_container_t* container_a = (blf_log_container_t*)a;
guint64 pos = *(guint64*)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;
}
}
/** 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.
*/
static gboolean
blf_pull_logcontainer_into_memory(blf_params_t *params, blf_log_container_t *container, int *err, gchar **err_info) {
if (container == NULL) {
*err = WTAP_ERR_INTERNAL;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory called with NULL container");
return FALSE;
}
if (container->real_data != NULL) {
return TRUE;
}
if (container->real_length == 0) {
ws_info("blf_pull_logcontainer_into_memory: found container with 0 length");
return TRUE;
}
/* 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;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: container.infile_start_pos (%" G_GINT64_FORMAT ") < 0",
container->infile_start_pos);
return FALSE;
}
if (container->infile_data_start < (guint64)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;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: container.infile_data_start (%" G_GUINT64_FORMAT ") < container.infile_start_pos (%" G_GINT64_FORMAT ")",
container->infile_data_start, container->infile_start_pos);
return FALSE;
}
if (container->infile_length < container->infile_data_start - (guint64)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;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: container.infile_length (%" G_GUINT64_FORMAT ") < (container.infile_data_start (%" G_GUINT64_FORMAT ") - container.infile_start_pos (%" G_GINT64_FORMAT ")) = %" G_GUINT64_FORMAT,
container->infile_length,
container->infile_data_start, container->infile_start_pos,
container->infile_data_start - (guint64)container->infile_start_pos);
return FALSE;
}
guint64 data_length = container->infile_length - (container->infile_data_start - (guint64)container->infile_start_pos);
if (data_length > UINT_MAX) {
/*
* XXX - does this represent a bug (WTAP_ERR_INTERNAL) or a
* malformed file (WTAP_ERR_BAD_FILE)?
*/
*err = WTAP_ERR_INTERNAL;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: data_length (%" G_GUINT64_FORMAT ") > UINT_MAX",
data_length);
return FALSE;
}
if (container->compression_method == BLF_COMPRESSION_NONE) {
unsigned char* buf = g_try_malloc0((gsize)container->real_length);
if (buf == NULL) {
/*
* 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;
*err_info = ws_strdup("blf_pull_logcontainer_into_memory: cannot allocate memory");
}
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) {
/*
* 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;
*err_info = ws_strdup("blf_pull_logcontainer_into_memory: short read on uncompressed data");
}
return FALSE;
}
container->real_data = buf;
return TRUE;
}
else if (container->compression_method == BLF_COMPRESSION_ZLIB) {
#ifdef HAVE_ZLIB
unsigned char *compressed_data = g_try_malloc0((gsize)data_length);
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) {
/*
* 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;
*err_info = ws_strdup("blf_pull_logcontainer_into_memory: short read on compressed data");
}
return FALSE;
}
unsigned char *buf = g_try_malloc0((gsize)container->real_length);
if (buf == NULL) {
/*
* 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;
*err_info = ws_strdup("blf_pull_logcontainer_into_memory: cannot allocate memory");
}
z_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_OK != inflateInit(&infstream)) {
/*
* XXX - check the error code and handle this appropriately.
*/
g_free(buf);
g_free(compressed_data);
*err = WTAP_ERR_INTERNAL;
if (infstream.msg != NULL) {
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: inflateInit failed for LogContainer, message\"%s\"",
infstream.msg);
} else {
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: inflateInit failed for LogContainer");
}
ws_debug("inflateInit failed for LogContainer");
if (infstream.msg != NULL) {
ws_debug("inflateInit returned: \"%s\"", infstream.msg);
}
return FALSE;
}
int ret = inflate(&infstream, Z_NO_FLUSH);
/* Z_OK should not happen here since we know how big the buffer should be */
if (Z_STREAM_END != ret) {
switch (ret) {
case Z_NEED_DICT:
*err = WTAP_ERR_DECOMPRESS;
*err_info = ws_strdup("preset dictionary needed");
break;
case Z_STREAM_ERROR:
*err = WTAP_ERR_DECOMPRESS;
*err_info = (infstream.msg != NULL) ? ws_strdup(infstream.msg) : NULL;
break;
case Z_MEM_ERROR:
/* This means "not enough memory". */
*err = ENOMEM;
*err_info = NULL;
break;
case Z_DATA_ERROR:
/* This means "deflate stream invalid" */
*err = WTAP_ERR_DECOMPRESS;
*err_info = (infstream.msg != NULL) ? ws_strdup(infstream.msg) : NULL;
break;
case Z_BUF_ERROR:
/* XXX - this is recoverable; what should we do here? */
*err = WTAP_ERR_INTERNAL;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: Z_BUF_ERROR from inflate(), message \"%s\"",
(infstream.msg != NULL) ? infstream.msg : "(none)");
break;
case Z_VERSION_ERROR:
*err = WTAP_ERR_INTERNAL;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: Z_VERSION_ERROR from inflate(), message \"%s\"",
(infstream.msg != NULL) ? infstream.msg : "(none)");
break;
default:
*err = WTAP_ERR_INTERNAL;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: unexpected error %d from inflate(), message \"%s\"",
ret,
(infstream.msg != NULL) ? infstream.msg : "(none)");
break;
}
g_free(buf);
g_free(compressed_data);
ws_debug("inflate failed (return code %d) for LogContainer", ret);
if (infstream.msg != NULL) {
ws_debug("inflate returned: \"%s\"", infstream.msg);
}
/* Free up any dynamically-allocated memory in infstream */
inflateEnd(&infstream);
return FALSE;
}
if (Z_OK != 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;
*err_info = ws_strdup_printf("blf_pull_logcontainer_into_memory: inflateEnd failed for LogContainer");
g_free(buf);
g_free(compressed_data);
ws_debug("inflateEnd failed for LogContainer");
if (infstream.msg != NULL) {
ws_debug("inflateEnd returned: \"%s\"", infstream.msg);
}
return FALSE;
}
g_free(compressed_data);
container->real_data = buf;
return TRUE;
#else
(void) params;
*err = WTAP_ERR_DECOMPRESSION_NOT_SUPPORTED;
*err_info = ws_strdup("blf_pull_logcontainer_into_memory: reading gzip-compressed containers isn't supported");
return FALSE;
#endif
}
return FALSE;
}
/** Finds the next log container starting at the current file offset
*
* Adds the container to the containers array for later access
*/
static gboolean
blf_find_next_logcontainer(blf_params_t* params, int* err, gchar** err_info) {
blf_blockheader_t header;
blf_logcontainerheader_t logcontainer_header;
blf_log_container_t tmp;
guint64 current_real_start;
if (params->blf_data->log_containers->len == 0) {
current_real_start = 0;
}
else {
blf_log_container_t* container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, params->blf_data->log_containers->len - 1);
current_real_start = container->real_start_pos + container->real_length;
}
unsigned int i = 0;
unsigned char* header_ptr = (unsigned char*)&header;
/** 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");
return FALSE;
}
if (header_ptr[i] != blf_obj_magic[i]) {
if (params->pipe) {
ws_debug("container object magic is not LOBJ");
}
else {
ws_debug("container object magic is not LOBJ (pos: 0x%" PRIx64 ")", file_tell(params->fh));
}
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");
return FALSE;
}
fix_endianness_blf_blockheader(&header);
if (header.header_length < sizeof(blf_blockheader_t)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup("blf: log container header length too short");
return FALSE;
}
if (header.header_type != BLF_HEADER_TYPE_DEFAULT) {
*err = WTAP_ERR_UNSUPPORTED;
*err_info = ws_strdup_printf("blf: unknown header type (%u), I know only BLF_HEADER_TYPE_DEFAULT (1)", header.header_type);
return FALSE;
}
if (header.object_length < header.header_length) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup("blf: log container header object length less than log container header length");
return FALSE;
}
switch (header.object_type) {
case BLF_OBJTYPE_LOG_CONTAINER:
/* 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, header.header_length - sizeof(blf_blockheader_t), err, err_info)) {
ws_debug("cannot seek file for skipping unknown header bytes in log container");
return FALSE;
}
}
/* 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");
return FALSE;
}
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);
g_array_append_val(params->blf_data->log_containers, tmp);
break;
default:
ws_debug("we found a non BLF log container on top level. this is unexpected.");
/* TODO: maybe create "fake Log Container" for this */
if (!wtap_read_bytes(params->fh, NULL, MAX(MAX(sizeof(blf_blockheader_t), header.object_length), header.header_length) - sizeof(blf_blockheader_t), err, err_info)) {
return FALSE;
}
}
return TRUE;
}
static gboolean
blf_pull_next_logcontainer(blf_params_t* params, int* err, gchar** err_info) {
blf_log_container_t* container;
if (!blf_find_next_logcontainer(params, err, err_info)) {
return FALSE;
}
/* Is there a next log container to pull? */
if (params->blf_data->log_containers->len == 0) {
/* No. */
return FALSE;
}
container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, params->blf_data->log_containers->len - 1);
if (!blf_pull_logcontainer_into_memory(params, container, err, err_info)) {
return FALSE;
}
return TRUE;
}
static gboolean
blf_read_bytes_or_eof(blf_params_t *params, guint64 real_pos, void *target_buffer, guint64 count, int *err, gchar **err_info) {
blf_log_container_t* container;
guint container_index;
guint64 end_pos = real_pos + count;
guint64 copied = 0;
guint64 data_left;
guint64 start_in_buf;
unsigned char *buf = (unsigned char *)target_buffer;
if (count == 0) {
ws_debug("called blf_read_bytes_or_eof with 0 count");
return FALSE;
}
if (count > UINT32_MAX) {
ws_debug("trying to read too many bytes");
return FALSE;
}
if (params->random) {
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");
return FALSE;
}
container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, container_index);
}
else {
if (params->blf_data->log_containers->len == 0) { /* First (linear) pass */
if (!blf_pull_next_logcontainer(params, err, err_info)) {
return FALSE;
}
}
container_index = params->blf_data->log_containers->len;
do {
container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, --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 FALSE;
}
}
if (container_index >= params->blf_data->log_containers->len) {
ws_debug("cannot find real_pos in container");
return FALSE;
}
container = &g_array_index(params->blf_data->log_containers, blf_log_container_t, container_index);
if (real_pos < container->real_start_pos) {
ws_debug("cannot find real_pos in container");
return FALSE;
}
}
if (real_pos < container->real_start_pos) {
ws_debug("cannot find real_pos in container");
return FALSE;
}
start_in_buf = real_pos - container->real_start_pos;
if (params->random) {
if (file_seek(params->fh, container->infile_data_start, SEEK_SET, err) == -1) {
return FALSE;
}
if (!blf_pull_logcontainer_into_memory(params, container, err, err_info)) {
return FALSE;
}
}
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 TRUE;
}
}
/*
* XXX - does this represent a bug (WTAP_ERR_INTERNAL) or a
* malformed file (WTAP_ERR_BAD_FILE)?
*/
*err = WTAP_ERR_INTERNAL;
*err_info = ws_strdup_printf("blf_read_bytes_or_eof: ran out of containers");
return FALSE;
}
static gboolean
blf_read_bytes(blf_params_t *params, guint64 real_pos, void *target_buffer, guint64 count, int *err, gchar **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;
}
return FALSE;
}
return TRUE;
}
static void
blf_init_rec(blf_params_t *params, guint32 flags, guint64 object_timestamp, int pkt_encap, guint16 channel, guint16 hwchannel, guint caplen, guint len) {
params->rec->rec_type = REC_TYPE_PACKET;
params->rec->block = wtap_block_create(WTAP_BLOCK_PACKET);
params->rec->presence_flags = WTAP_HAS_TS | WTAP_HAS_CAP_LEN | WTAP_HAS_INTERFACE_ID;
switch (flags) {
case BLF_TIMESTAMP_RESOLUTION_10US:
params->rec->tsprec = WTAP_TSPREC_10_USEC;
object_timestamp *= 10000;
object_timestamp += params->blf_data->start_offset_ns;
break;
case BLF_TIMESTAMP_RESOLUTION_1NS:
params->rec->tsprec = WTAP_TSPREC_NSEC;
object_timestamp += params->blf_data->start_offset_ns;
break;
default:
if (flags == 0 && object_timestamp == 0) {
/* This is not an error, but is used for metadata at the beginning of the file. */
params->rec->tsprec = WTAP_TSPREC_NSEC;
object_timestamp = params->blf_data->start_offset_ns;
}
else {
/*
* 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)?
*
* Set the timestamp to params->blf_data->start_offset_ns also here?
*/
ws_debug("Unknown combination of flags and timestamp (0x%x, %" PRIu64 ")", flags, object_timestamp);
params->rec->tsprec = WTAP_TSPREC_NSEC;
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->ts_rel_cap_valid = true;
params->rec->rec_header.packet_header.pkt_encap = pkt_encap;
params->rec->rec_header.packet_header.interface_id = blf_lookup_interface(params, pkt_encap, channel, hwchannel, NULL);
/* TODO: before we had to remove comments and verdict here to not leak memory but APIs have changed ... */
}
static void
blf_add_direction_option(blf_params_t *params, guint16 direction) {
guint32 tmp = 0; /* dont care */
switch (direction) {
case BLF_DIR_RX:
tmp = 1; /* inbound */
break;
case BLF_DIR_TX:
case BLF_DIR_TX_RQ:
tmp = 2; /* outbound */
break;
}
/* pcapng.c: #define OPT_EPB_FLAGS 0x0002 */
wtap_block_add_uint32_option(params->rec->block, 0x0002, tmp);
}
static gboolean
blf_read_log_object_header(blf_params_t *params, int *err, gchar **err_info, gint64 header2_start, gint64 data_start, blf_logobjectheader_t *logheader) {
if (data_start - header2_start < (gint64)sizeof(blf_logobjectheader_t)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: not enough bytes for log object header");
ws_debug("not enough bytes for timestamp header");
return FALSE;
}
if (!blf_read_bytes_or_eof(params, header2_start, logheader, sizeof(*logheader), err, err_info)) {
ws_debug("not enough bytes for logheader");
return FALSE;
}
fix_endianness_blf_logobjectheader(logheader);
return TRUE;
}
static gboolean
blf_read_log_object_header2(blf_params_t *params, int *err, gchar **err_info, gint64 header2_start, gint64 data_start, blf_logobjectheader2_t *logheader) {
if (data_start - header2_start < (gint64)sizeof(blf_logobjectheader2_t)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: not enough bytes for log object header");
ws_debug("not enough bytes for timestamp header");
return FALSE;
}
if (!blf_read_bytes_or_eof(params, header2_start, logheader, sizeof(*logheader), err, err_info)) {
ws_debug("not enough bytes for logheader");
return FALSE;
}
fix_endianness_blf_logobjectheader2(logheader);
return TRUE;
}
static gboolean
blf_read_log_object_header3(blf_params_t *params, int *err, gchar **err_info, gint64 header2_start, gint64 data_start, blf_logobjectheader3_t *logheader) {
if (data_start - header2_start < (gint64)sizeof(blf_logobjectheader3_t)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: not enough bytes for log object header");
ws_debug("not enough bytes for timestamp header");
return FALSE;
}
if (!blf_read_bytes_or_eof(params, header2_start, logheader, sizeof(*logheader), err, err_info)) {
ws_debug("not enough bytes for logheader");
return FALSE;
}
fix_endianness_blf_logobjectheader3(logheader);
return TRUE;
}
static gboolean
blf_read_ethernetframe(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_ethernetframeheader_t ethheader;
guint8 tmpbuf[18];
guint caplen, len;
if (object_length < (data_start - block_start) + (int) sizeof(blf_ethernetframeheader_t)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: ETHERNET_FRAME: not enough bytes for ethernet frame header in object");
ws_debug("not enough bytes for ethernet frame header in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &ethheader, sizeof(ethheader), err, err_info)) {
ws_debug("not enough bytes for ethernet frame header in file");
return FALSE;
}
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) {
tmpbuf[12] = (ethheader.tpid & 0xff00) >> 8;
tmpbuf[13] = (ethheader.tpid & 0x00ff);
tmpbuf[14] = (ethheader.tci & 0xff00) >> 8;
tmpbuf[15] = (ethheader.tci & 0x00ff);
tmpbuf[16] = (ethheader.ethtype & 0xff00) >> 8;
tmpbuf[17] = (ethheader.ethtype & 0x00ff);
ws_buffer_assure_space(params->buf, (gsize)18 + ethheader.payloadlength);
ws_buffer_append(params->buf, tmpbuf, (gsize)18);
caplen = ((guint32)18 + ethheader.payloadlength);
len = ((guint32)18 + ethheader.payloadlength);
} else {
tmpbuf[12] = (ethheader.ethtype & 0xff00) >> 8;
tmpbuf[13] = (ethheader.ethtype & 0x00ff);
ws_buffer_assure_space(params->buf, (gsize)14 + ethheader.payloadlength);
ws_buffer_append(params->buf, tmpbuf, (gsize)14);
caplen = ((guint32)14 + ethheader.payloadlength);
len = ((guint32)14 + ethheader.payloadlength);
}
if (!blf_read_bytes(params, data_start + sizeof(blf_ethernetframeheader_t), ws_buffer_end_ptr(params->buf), ethheader.payloadlength, err, err_info)) {
ws_debug("copying ethernet frame failed");
return FALSE;
}
params->buf->first_free += ethheader.payloadlength;
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_ETHERNET, ethheader.channel, UINT16_MAX, caplen, len);
blf_add_direction_option(params, ethheader.direction);
return TRUE;
}
static gboolean
blf_read_ethernetframe_ext(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_ethernetframeheader_ex_t ethheader;
if (object_length < (data_start - block_start) + (int) sizeof(blf_ethernetframeheader_ex_t)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: ETHERNET_FRAME_EX: not enough bytes for ethernet frame header in object");
ws_debug("not enough bytes for ethernet frame header in object");
return FALSE;
}
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");
return FALSE;
}
fix_endianness_blf_ethernetframeheader_ex(&ethheader);
ws_buffer_assure_space(params->buf, ethheader.frame_length);
if (object_length - (data_start - block_start) - sizeof(blf_ethernetframeheader_ex_t) < ethheader.frame_length) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: ETHERNET_FRAME_EX: frame too short");
ws_debug("frame too short");
return FALSE;
}
if (!blf_read_bytes(params, data_start + sizeof(blf_ethernetframeheader_ex_t), ws_buffer_start_ptr(params->buf), ethheader.frame_length, err, err_info)) {
ws_debug("copying ethernet frame failed");
return FALSE;
}
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_ETHERNET, ethheader.channel, ethheader.hw_channel, ethheader.frame_length, ethheader.frame_length);
wtap_block_add_uint32_option(params->rec->block, OPT_PKT_QUEUE, ethheader.hw_channel);
blf_add_direction_option(params, ethheader.direction);
return TRUE;
}
/*
* XXX - provide radio information to our caller in the pseudo-header.
*/
static gboolean
blf_read_wlanframe(blf_params_t* params, int* err, gchar** err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_wlanframeheader_t wlanheader;
if (object_length < (data_start - block_start) + (int)sizeof(blf_wlanframeheader_t)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: WLAN_FRAME: not enough bytes for wlan frame header in object");
ws_debug("not enough bytes for wlan frame header in object");
return FALSE;
}
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");
return FALSE;
}
fix_endianness_blf_wlanframeheader(&wlanheader);
ws_buffer_assure_space(params->buf, wlanheader.frame_length);
if (object_length - (data_start - block_start) - sizeof(blf_wlanframeheader_t) < wlanheader.frame_length) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: WLAN_FRAME: frame too short");
ws_debug("frame too short");
return FALSE;
}
if (!blf_read_bytes(params, data_start + sizeof(blf_wlanframeheader_t), ws_buffer_start_ptr(params->buf), wlanheader.frame_length, err, err_info)) {
ws_debug("copying wlan frame failed");
return FALSE;
}
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_IEEE_802_11, wlanheader.channel, UINT16_MAX, wlanheader.frame_length, wlanheader.frame_length);
blf_add_direction_option(params, wlanheader.direction);
return TRUE;
}
static guint8 can_dlc_to_length[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8 };
static guint8 canfd_dlc_to_length[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64 };
static gboolean
blf_can_fill_buf_and_rec(blf_params_t *params, int *err, gchar **err_info, guint32 canid, guint8 payload_length, guint8 payload_length_valid, guint64 start_position,
guint32 flags, guint64 object_timestamp, guint16 channel, guint8 canfd_flags) {
guint8 tmpbuf[8];
guint caplen, len;
tmpbuf[0] = (canid & 0xff000000) >> 24;
tmpbuf[1] = (canid & 0x00ff0000) >> 16;
tmpbuf[2] = (canid & 0x0000ff00) >> 8;
tmpbuf[3] = (canid & 0x000000ff);
tmpbuf[4] = payload_length;
tmpbuf[5] = canfd_flags;
tmpbuf[6] = 0;
tmpbuf[7] = 0;
ws_buffer_assure_space(params->buf, sizeof(tmpbuf) + payload_length_valid);
ws_buffer_append(params->buf, 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->buf), payload_length_valid, err, err_info)) {
ws_debug("copying can payload failed");
return FALSE;
}
params->buf->first_free += payload_length_valid;
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN, channel, UINT16_MAX, caplen, len);
return TRUE;
}
static gboolean
blf_read_canmessage(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, gboolean can_message2) {
blf_canmessage_t canheader;
blf_canmessage2_trailer_t can2trailer;
guint32 canid;
guint8 payload_length;
if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("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");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
ws_debug("not enough bytes for can header in file");
return FALSE;
}
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!");
payload_length = 8;
}
canid = canheader.id;
if ((canheader.flags & BLF_CANMESSAGE_FLAG_RTR) == BLF_CANMESSAGE_FLAG_RTR) {
canid |= CAN_RTR_FLAG;
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 FALSE;
}
/* 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;
*err_info = ws_strdup_printf("blf: CAN_MESSAGE2: not enough bytes for can message 2 trailer");
ws_debug("not enough bytes for can message 2 trailer");
return FALSE;
}
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");
return FALSE;
}
fix_endianness_blf_canmessage2_trailer(&can2trailer);
}
blf_add_direction_option(params, (canheader.flags & BLF_CANMESSAGE_FLAG_TX) == BLF_CANMESSAGE_FLAG_TX ? BLF_DIR_TX: BLF_DIR_RX);
return TRUE;
}
static gboolean
blf_read_canfdmessage(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_canfdmessage_t canheader;
gboolean canfd;
guint32 canid;
guint8 payload_length;
guint8 payload_length_valid;
guint8 canfd_flags;
if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: CAN_FD_MESSAGE: not enough bytes for canfd header in object");
ws_debug("not enough bytes for canfd header in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
ws_debug("not enough bytes for canfd header in file");
return FALSE;
}
fix_endianness_blf_canfdmessage(&canheader);
canheader.dlc &= 0x0f;
canfd = (canheader.canfdflags & BLF_CANFDMESSAGE_CANFDFLAG_EDL) == BLF_CANFDMESSAGE_CANFDFLAG_EDL;
if (canfd) {
payload_length = canfd_dlc_to_length[canheader.dlc];
canfd_flags = (canheader.canfdflags & BLF_CANFDMESSAGE_CANFDFLAG_EDL) << 2 | (canheader.canfdflags & BLF_CANFDMESSAGE_CANFDFLAG_ESI) >> 1 | (canheader.canfdflags & BLF_CANFDMESSAGE_CANFDFLAG_BRS) >> 1;
} else {
if (canheader.dlc > 8) {
ws_debug("regular CAN tries more than 8 bytes?");
}
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!");
payload_length = canheader.validDataBytes;
}
canid = canheader.id;
if (!canfd && (canheader.flags & BLF_CANMESSAGE_FLAG_RTR) == BLF_CANMESSAGE_FLAG_RTR) {
canid |= CAN_RTR_FLAG;
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!");
payload_length_valid = (guint8)(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 FALSE;
}
blf_add_direction_option(params, (canheader.flags & BLF_CANMESSAGE_FLAG_TX) == BLF_CANMESSAGE_FLAG_TX ? BLF_DIR_TX : BLF_DIR_RX);
return TRUE;
}
static gboolean
blf_read_canfdmessage64(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_canfdmessage64_t canheader;
gboolean canfd;
guint32 canid;
guint8 payload_length;
guint8 payload_length_valid;
guint8 canfd_flags;
if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: CAN_FD_MESSAGE_64: not enough bytes for canfd header in object");
ws_debug("not enough bytes for canfd header in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
ws_debug("not enough bytes for canfd header in file");
return FALSE;
}
fix_endianness_blf_canfdmessage64(&canheader);
canheader.dlc &= 0x0f;
canfd = (canheader.flags & BLF_CANFDMESSAGE64_FLAG_EDL) == BLF_CANFDMESSAGE64_FLAG_EDL;
if (canfd) {
payload_length = canfd_dlc_to_length[canheader.dlc];
canfd_flags = (canheader.flags & BLF_CANFDMESSAGE64_FLAG_EDL) >> 10 | (canheader.flags & BLF_CANFDMESSAGE64_FLAG_ESI) >> 13 | (canheader.flags & BLF_CANFDMESSAGE64_FLAG_BRS) >> 13;
} else {
if (canheader.dlc > 8) {
ws_debug("regular CAN tries more than 8 bytes?");
}
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!");
payload_length = canheader.validDataBytes;
}
canid = canheader.id;
if (!canfd && (canheader.flags & BLF_CANFDMESSAGE64_FLAG_REMOTE_FRAME) == BLF_CANFDMESSAGE64_FLAG_REMOTE_FRAME) {
canid |= CAN_RTR_FLAG;
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!");
payload_length_valid = (guint8)(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 FALSE;
}
blf_add_direction_option(params, canheader.dir);
return TRUE;
}
static gboolean
blf_read_canerror(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, gboolean overload) {
blf_canerror_t canheader;
guint32 canid;
guint8 payload_length;
guint8 tmpbuf[16] = {0};
if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: CAN_ERROR: not enough bytes for canerror header in object");
ws_debug("not enough bytes for canerror header in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
ws_debug("not enough bytes for canerror header in file");
return FALSE;
}
fix_endianness_blf_canerror(&canheader);
// Set CAN_ERR_FLAG in unused bits of Can ID to indicate error in socketcan
canid = CAN_ERR_FLAG;
// Fixed packet data length for socketcan error messages
payload_length = CAN_ERR_DLC;
if (overload) {
tmpbuf[10] = CAN_ERR_PROT_OVERLOAD;
canid |= CAN_ERR_PROT;
}
tmpbuf[0] = (canid & 0xff000000) >> 24;
tmpbuf[1] = (canid & 0x00ff0000) >> 16;
tmpbuf[2] = (canid & 0x0000ff00) >> 8;
tmpbuf[3] = (canid & 0x000000ff);
tmpbuf[4] = payload_length;
ws_buffer_assure_space(params->buf, sizeof(tmpbuf));
ws_buffer_append(params->buf, tmpbuf, sizeof(tmpbuf));
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN, canheader.channel, UINT16_MAX, sizeof(tmpbuf), sizeof(tmpbuf));
return TRUE;
}
static gboolean
blf_read_canerrorext(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_canerrorext_t canheader;
gboolean err_ack = false;
gboolean err_prot = false;
gboolean direction_tx;
guint32 canid;
guint8 payload_length;
guint8 tmpbuf[16] = {0};
if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: CAN_ERROR_EXT: not enough bytes for canerrorext header in object");
ws_debug("not enough bytes for canerrorext header in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
ws_debug("not enough bytes for canerrorext header in file");
return FALSE;
}
fix_endianness_blf_canerrorext(&canheader);
if (canheader.flags & BLF_CANERROREXT_FLAG_CANCORE) {
// Map Vector Can Core error codes to compareable socketcan errors
switch ((canheader.errorCodeExt >> 6) & 0x3f) {
case BLF_CANERROREXT_ECC_MEANING_BIT_ERROR:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_BIT;
break;
case BLF_CANERROREXT_ECC_MEANING_FORM_ERROR:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_FORM;
break;
case BLF_CANERROREXT_ECC_MEANING_STUFF_ERROR:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_STUFF;
break;
case BLF_CANERROREXT_ECC_MEANING_CRC_ERROR:
err_prot = true;
tmpbuf[11] = CAN_ERR_PROT_LOC_CRC_SEQ;
break;
case BLF_CANERROREXT_ECC_MEANING_NACK_ERROR:
err_ack = true;
tmpbuf[11] = CAN_ERR_PROT_LOC_ACK;
break;
case BLF_CANERROREXT_ECC_MEANING_OVERLOAD:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_OVERLOAD;
break;
default:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_UNSPEC;
break;
}
err_ack = err_ack || (canheader.errorCodeExt & BLF_CANERROREXT_EXTECC_NOT_ACK) == 0x0;
if (err_ack) {
// Don't set protocol error on ack errors
err_prot = false;
}
}
// CanID contains error class in socketcan
canid = CAN_ERR_FLAG;
canid |= err_prot ? CAN_ERR_PROT : 0;
canid |= err_ack ? CAN_ERR_ACK : 0;
// Fixed packet data length for socketcan error messages
payload_length = CAN_ERR_DLC;
canheader.dlc = payload_length;
tmpbuf[0] = (canid & 0xff000000) >> 24;
tmpbuf[1] = (canid & 0x00ff0000) >> 16;
tmpbuf[2] = (canid & 0x0000ff00) >> 8;
tmpbuf[3] = (canid & 0x000000ff);
tmpbuf[4] = payload_length;
ws_buffer_assure_space(params->buf, sizeof(tmpbuf));
ws_buffer_append(params->buf, tmpbuf, sizeof(tmpbuf));
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN, canheader.channel, UINT16_MAX, sizeof(tmpbuf), sizeof(tmpbuf));
if (canheader.flags & BLF_CANERROREXT_FLAG_CANCORE) {
direction_tx = (canheader.errorCodeExt & BLF_CANERROREXT_EXTECC_TX) == BLF_CANERROREXT_EXTECC_TX;
blf_add_direction_option(params, direction_tx ? BLF_DIR_TX: BLF_DIR_RX);
}
return TRUE;
}
static gboolean
blf_read_canfderror64(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_canfderror64_t canheader;
gboolean err_ack = false;
gboolean err_prot = false;
gboolean direction_tx;
guint32 canid;
guint8 payload_length;
guint8 tmpbuf[16] = {0};
if (object_length < (data_start - block_start) + (int) sizeof(canheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: CAN_FD_ERROR_64: not enough bytes for canfderror header in object");
ws_debug("not enough bytes for canfderror header in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &canheader, sizeof(canheader), err, err_info)) {
ws_debug("not enough bytes for canfderror header in file");
return FALSE;
}
fix_endianness_blf_canfderror64(&canheader);
if (canheader.flags & BLF_CANERROREXT_FLAG_CANCORE) {
// Map Vector Can Core error codes to compareable socketcan errors
switch ((canheader.errorCodeExt >> 6) & 0x3f) {
case BLF_CANERROREXT_ECC_MEANING_BIT_ERROR:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_BIT;
break;
case BLF_CANERROREXT_ECC_MEANING_FORM_ERROR:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_FORM;
break;
case BLF_CANERROREXT_ECC_MEANING_STUFF_ERROR:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_STUFF;
break;
case BLF_CANERROREXT_ECC_MEANING_CRC_ERROR:
err_prot = true;
tmpbuf[11] = CAN_ERR_PROT_LOC_CRC_SEQ;
break;
case BLF_CANERROREXT_ECC_MEANING_NACK_ERROR:
err_ack = true;
tmpbuf[11] = CAN_ERR_PROT_LOC_ACK;
break;
case BLF_CANERROREXT_ECC_MEANING_OVERLOAD:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_OVERLOAD;
break;
default:
err_prot = true;
tmpbuf[10] = CAN_ERR_PROT_UNSPEC;
break;
}
err_ack = err_ack || (canheader.errorCodeExt & BLF_CANERROREXT_EXTECC_NOT_ACK) == 0x0;
if (err_ack) {
// Don't set protocol error on ack errors
err_prot = false;
}
}
// CanID contains error class in socketcan
canid = CAN_ERR_FLAG;
canid |= err_prot ? CAN_ERR_PROT : 0;
canid |= err_ack ? CAN_ERR_ACK : 0;
// Fixed packet data length for socketcan error messages
payload_length = CAN_ERR_DLC;
canheader.dlc = payload_length;
tmpbuf[0] = (canid & 0xff000000) >> 24;
tmpbuf[1] = (canid & 0x00ff0000) >> 16;
tmpbuf[2] = (canid & 0x0000ff00) >> 8;
tmpbuf[3] = (canid & 0x000000ff);
tmpbuf[4] = payload_length;
// Don't set FDF, ESI and BRS flags, since error messages are always encapsulated in Classic CAN frames
ws_buffer_assure_space(params->buf, sizeof(tmpbuf));
ws_buffer_append(params->buf, tmpbuf, sizeof(tmpbuf));
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_SOCKETCAN, canheader.channel, UINT16_MAX, sizeof(tmpbuf), sizeof(tmpbuf));
if (canheader.flags & BLF_CANERROREXT_FLAG_CANCORE) {
direction_tx = (canheader.errorCodeExt & BLF_CANERROREXT_EXTECC_TX) == BLF_CANERROREXT_EXTECC_TX;
blf_add_direction_option(params, direction_tx ? BLF_DIR_TX: BLF_DIR_RX);
}
return TRUE;
}
static gboolean
blf_read_flexraydata(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_flexraydata_t frheader;
guint8 payload_length;
guint8 payload_length_valid;
guint8 tmpbuf[7];
guint caplen, len;
if (object_length < (data_start - block_start) + (int) sizeof(frheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: FLEXRAY_DATA: not enough bytes for flexrayheader in object");
ws_debug("not enough bytes for flexrayheader in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &frheader, sizeof(frheader), err, err_info)) {
ws_debug("not enough bytes for flexrayheader header in file");
return FALSE;
}
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!?");
}
if (payload_length_valid > object_length - (data_start - block_start) - sizeof(frheader)) {
ws_debug("shortening FlexRay payload because buffer is too short!");
payload_length_valid = (guint8)(object_length - (data_start - block_start) - sizeof(frheader));
}
if (frheader.channel != 0 && frheader.channel != 1) {
ws_debug("FlexRay supports only two channels.");
}
/* Measurement Header */
if (frheader.channel == 0) {
tmpbuf[0] = BLF_FLEXRAYDATA_FRAME;
} else {
tmpbuf[0] = BLF_FLEXRAYDATA_FRAME | BLF_FLEXRAYDATA_CHANNEL_B;
}
/* 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->buf, sizeof(tmpbuf) + payload_length_valid);
ws_buffer_append(params->buf, 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->buf), payload_length_valid, err, err_info)) {
ws_debug("copying flexray payload failed");
return FALSE;
}
params->buf->first_free += payload_length_valid;
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_FLEXRAY, frheader.channel, UINT16_MAX, caplen, len);
blf_add_direction_option(params, frheader.dir);
return TRUE;
}
static gboolean
blf_read_flexraymessage(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_flexraymessage_t frheader;
guint8 payload_length;
guint8 payload_length_valid;
guint8 tmpbuf[7];
guint caplen, len;
if (object_length < (data_start - block_start) + (int) sizeof(frheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: FLEXRAY_MESSAGE: not enough bytes for flexrayheader in object");
ws_debug("not enough bytes for flexrayheader in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &frheader, sizeof(frheader), err, err_info)) {
ws_debug("not enough bytes for flexrayheader header in file");
return FALSE;
}
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!?");
}
if (payload_length_valid > object_length - (data_start - block_start) - sizeof(frheader)) {
ws_debug("shortening FlexRay payload because buffer is too short!");
payload_length_valid = (guint8)(object_length - (data_start - block_start) - sizeof(frheader));
}
if (frheader.channel != 0 && frheader.channel != 1) {
ws_debug("FlexRay supports only two channels.");
}
/* Measurement Header */
if (frheader.channel == 0) {
tmpbuf[0] = BLF_FLEXRAYDATA_FRAME;
} else {
tmpbuf[0] = BLF_FLEXRAYDATA_FRAME | BLF_FLEXRAYDATA_CHANNEL_B;
}
/* Error Flags */
tmpbuf[1] = 0;
/* Frame Header */
tmpbuf[2] = ((0x0700 & frheader.frameId) >> 8);
if ((frheader.frameState & BLF_FLEXRAYMESSAGE_STATE_PPI) == BLF_FLEXRAYMESSAGE_STATE_PPI) {
tmpbuf[2] |= BLF_DLT_FLEXRAY_PPI;
}
if ((frheader.frameState & BLF_FLEXRAYMESSAGE_STATE_SFI) == BLF_FLEXRAYMESSAGE_STATE_SFI) {
tmpbuf[2] |= BLF_DLT_FLEXRAY_SFI;
}
if ((frheader.frameState & BLF_FLEXRAYMESSAGE_STATE_NFI) != BLF_FLEXRAYMESSAGE_STATE_NFI) {
/* NFI needs to be inversed !? */
tmpbuf[2] |= BLF_DLT_FLEXRAY_NFI;
}
if ((frheader.frameState & BLF_FLEXRAYMESSAGE_STATE_STFI) == BLF_FLEXRAYMESSAGE_STATE_STFI) {
tmpbuf[2] |= BLF_DLT_FLEXRAY_STFI;
}
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->buf, sizeof(tmpbuf) + payload_length_valid);
ws_buffer_append(params->buf, 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->buf), payload_length_valid, err, err_info)) {
ws_debug("copying flexray payload failed");
return FALSE;
}
params->buf->first_free += payload_length_valid;
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_FLEXRAY, frheader.channel, UINT16_MAX, caplen, len);
blf_add_direction_option(params, frheader.dir);
return TRUE;
}
static gboolean
blf_read_flexrayrcvmessageex(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, gboolean ext) {
blf_flexrayrcvmessage_t frheader;
guint16 payload_length;
guint16 payload_length_valid;
guint8 tmpbuf[7];
gint frheadersize = sizeof(frheader);
guint caplen, len;
if (ext) {
frheadersize += 40;
}
if ((gint64)object_length < (data_start - block_start) + frheadersize) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: %s: not enough bytes for flexrayheader in object",
ext ? "FLEXRAY_RCVMESSAGE_EX" : "FLEXRAY_RCVMESSAGE");
ws_debug("not enough bytes for flexrayheader in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &frheader, sizeof(frheader), err, err_info)) {
ws_debug("not enough bytes for flexrayheader header in file");
return FALSE;
}
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!?");
}
if (payload_length_valid > object_length - (data_start - block_start) - frheadersize) {
ws_debug("shortening FlexRay payload because buffer is too short!");
payload_length_valid = (guint8)(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_A) {
tmpbuf[0] = BLF_FLEXRAYDATA_FRAME;
} else {
tmpbuf[0] = BLF_FLEXRAYDATA_FRAME | BLF_FLEXRAYDATA_CHANNEL_B;
}
/* Error Flags */
tmpbuf[1] = 0;
/* Frame Header */
tmpbuf[2] = ((0x0700 & frheader.frameId) >> 8);
if ((frheader.data & BLF_FLEXRAYRCVMSG_DATA_FLAG_PAYLOAD_PREAM) == BLF_FLEXRAYRCVMSG_DATA_FLAG_PAYLOAD_PREAM) {
tmpbuf[2] |= BLF_DLT_FLEXRAY_PPI;
}
if ((frheader.data & BLF_FLEXRAYRCVMSG_DATA_FLAG_SYNC) == BLF_FLEXRAYRCVMSG_DATA_FLAG_SYNC) {
tmpbuf[2] |= BLF_DLT_FLEXRAY_SFI;
}
if ((frheader.data & BLF_FLEXRAYRCVMSG_DATA_FLAG_NULL_FRAME) != BLF_FLEXRAYRCVMSG_DATA_FLAG_NULL_FRAME) {
/* NFI needs to be inversed !? */
tmpbuf[2] |= BLF_DLT_FLEXRAY_NFI;
}
if ((frheader.data & BLF_FLEXRAYRCVMSG_DATA_FLAG_STARTUP) == BLF_FLEXRAYRCVMSG_DATA_FLAG_STARTUP) {
tmpbuf[2] |= BLF_DLT_FLEXRAY_STFI;
}
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->buf, sizeof(tmpbuf) + payload_length_valid);
ws_buffer_append(params->buf, 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->buf), payload_length_valid, err, err_info)) {
ws_debug("copying flexray payload failed");
return FALSE;
}
params->buf->first_free += payload_length_valid;
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_FLEXRAY, frheader.channelMask, UINT16_MAX, caplen, len);
blf_add_direction_option(params, frheader.dir);
return TRUE;
}
static gboolean
blf_read_linmessage(blf_params_t* params, int* err, gchar** err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, gboolean crc_error) {
blf_linmessage_t linmessage;
guint8 payload_length;
guint len;
if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
*err = WTAP_ERR_BAD_FILE;
*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");
ws_debug("not enough bytes for %s in object", crc_error ? "lincrcerror" : "linmessage");
return FALSE;
}
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");
return FALSE;
}
fix_endianness_blf_linmessage(&linmessage);
linmessage.dlc &= 0x0f;
linmessage.id &= 0x3f;
payload_length = MIN(linmessage.dlc, 8);
guint8 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] = (guint8)(linmessage.crc & 0xff); /* checksum */
tmpbuf[7] = 0; /* errors */
if (crc_error) {
tmpbuf[7] |= 0x08;
}
ws_buffer_assure_space(params->buf, sizeof(tmpbuf) + payload_length);
ws_buffer_append(params->buf, tmpbuf, sizeof(tmpbuf));
ws_buffer_append(params->buf, linmessage.data, payload_length);
len = sizeof(tmpbuf) + payload_length;
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN, linmessage.channel, UINT16_MAX, len, len);
blf_add_direction_option(params, linmessage.dir);
return TRUE;
}
static gboolean
blf_read_linsenderror(blf_params_t* params, int* err, gchar** err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_linsenderror_t linmessage;
if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: LIN_SND_ERROR: not enough bytes for linsenderror in object");
ws_debug("not enough bytes for linsenderror in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
ws_debug("not enough bytes for linsenderror in file");
return FALSE;
}
linmessage.channel = GUINT16_FROM_LE(linmessage.channel);
linmessage.dlc &= 0x0f;
linmessage.id &= 0x3f;
guint8 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] = 0; /* checksum */
tmpbuf[7] = 0x01; /* errors */
ws_buffer_assure_space(params->buf, sizeof(tmpbuf));
ws_buffer_append(params->buf, tmpbuf, sizeof(tmpbuf));
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN, linmessage.channel, UINT16_MAX, sizeof(tmpbuf), sizeof(tmpbuf));
return TRUE;
}
static gboolean
blf_read_linmessage2(blf_params_t* params, int* err, gchar** err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, guint16 object_version) {
blf_linmessage2_t linmessage;
guint8 payload_length;
guint len;
if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: LIN_MESSAGE2: not enough bytes for linmessage2 in object");
ws_debug("not enough bytes for linmessage2 in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
ws_debug("not enough bytes for linmessage2 in file");
return FALSE;
}
fix_endianness_blf_linmessage2(&linmessage);
linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc &= 0x0f;
linmessage.linDataByteTimestampEvent.linMessageDescriptor.id &= 0x3f;
payload_length = MIN(linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc, 8);
guint8 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] = (guint8)(linmessage.crc & 0xff); /* checksum */
tmpbuf[7] = 0; /* errors */
ws_buffer_assure_space(params->buf, sizeof(tmpbuf) + payload_length);
ws_buffer_append(params->buf, tmpbuf, sizeof(tmpbuf));
ws_buffer_append(params->buf, linmessage.data, payload_length);
len = sizeof(tmpbuf) + payload_length;
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN, linmessage.linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel, UINT16_MAX, len, len);
blf_add_direction_option(params, linmessage.dir);
return TRUE;
}
static gboolean
blf_read_lincrcerror2(blf_params_t* params, int* err, gchar** err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, guint16 object_version) {
blf_lincrcerror2_t linmessage;
guint8 payload_length;
guint len;
if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: LIN_CRC_ERROR2: not enough bytes for lincrcerror2 in object");
ws_debug("not enough bytes for lincrcerror2 in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
ws_debug("not enough bytes for lincrcerror2 in file");
return FALSE;
}
fix_endianness_blf_lincrcerror2(&linmessage);
linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc &= 0x0f;
linmessage.linDataByteTimestampEvent.linMessageDescriptor.id &= 0x3f;
payload_length = MIN(linmessage.linDataByteTimestampEvent.linMessageDescriptor.dlc, 8);
guint8 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] = (guint8)(linmessage.crc & 0xff); /* checksum */
tmpbuf[7] = 0x08; /* errors */
ws_buffer_assure_space(params->buf, sizeof(tmpbuf) + payload_length);
ws_buffer_append(params->buf, tmpbuf, sizeof(tmpbuf));
ws_buffer_append(params->buf, linmessage.data, payload_length);
len = sizeof(tmpbuf) + payload_length;
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN, linmessage.linDataByteTimestampEvent.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel, UINT16_MAX, len, len);
blf_add_direction_option(params, linmessage.dir);
return TRUE;
}
static gboolean
blf_read_linsenderror2(blf_params_t* params, int* err, gchar** err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, guint16 object_version) {
blf_linsenderror2_t linmessage;
if (object_length < (data_start - block_start) + (int)sizeof(linmessage)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: LIN_SND_ERROR2: not enough bytes for linsenderror2 in object");
ws_debug("not enough bytes for linsenderror2 in object");
return FALSE;
}
if (!blf_read_bytes(params, data_start, &linmessage, sizeof(linmessage), err, err_info)) {
ws_debug("not enough bytes for linsenderror2 in file");
return FALSE;
}
fix_endianness_blf_linsenderror2(&linmessage);
linmessage.linMessageDescriptor.dlc &= 0x0f;
linmessage.linMessageDescriptor.id &= 0x3f;
guint8 tmpbuf[8];
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] = 0x01; /* errors */
ws_buffer_assure_space(params->buf, sizeof(tmpbuf));
ws_buffer_append(params->buf, tmpbuf, sizeof(tmpbuf));
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_LIN, linmessage.linMessageDescriptor.linSynchFieldEvent.linBusEvent.channel, UINT16_MAX, sizeof(tmpbuf), sizeof(tmpbuf));
return TRUE;
}
guint16 blf_get_xml_channel_number(const char* start, const char* end) {
gchar* text;
gsize len;
guint16 res;
if (start == NULL || end == NULL || end <= start) {
return UINT16_MAX;
}
len = (gsize)(end - start);
text = g_try_malloc(len + 1); /* Accommodate '\0' */
if (text == NULL) {
ws_debug("cannot allocate memory");
return UINT16_MAX;
}
memcpy(text, start, len);
text[len] = '\0';
if (!ws_strtou16(text, NULL, &res)) {
res = UINT16_MAX;
}
g_free(text);
return res;
}
char* blf_get_xml_channel_name(const char* start, const char* end) {
char* text;
gsize len;
if (start == NULL || end == NULL || end <= start) {
return NULL;
}
len = (gsize)(end - start);
text = g_try_malloc(len + 1); /* Accommodate '\0' */
if (text == NULL) {
ws_debug("cannot allocate memory");
return NULL;
}
memcpy(text, start, len);
text[len] = '\0';
return text;
}
gboolean blf_parse_xml_port(const char* start, const char* end, char** name, guint16* hwchannel, gboolean* simulated) {
static const char name_magic[] = "name=";
static const char hwchannel_magic[] = "hwchannel=";
static const char simulated_magic[] = "simulated=";
gchar* text;
gsize len;
gchar** tokens;
gchar* token;
if (start == NULL || end == NULL || name == NULL || end <= start) {
return FALSE;
}
len = (gsize)(end - start);
text = g_try_malloc(len + 1); /* Accommodate '\0' */
if (text == NULL) {
ws_debug("cannot allocate memory");
return FALSE;
}
memcpy(text, start, len);
text[len] = '\0';
tokens = g_strsplit_set(text, ";", -1);
g_free(text);
if (tokens == NULL) {
ws_debug("cannot split XML port data");
return FALSE;
}
*name = NULL;
*hwchannel = UINT16_MAX;
*simulated = FALSE;
for (int i = 0; tokens[i] != NULL; i++) {
token = tokens[i];
if (strncmp(token, name_magic, strlen(name_magic)) == 0) {
if (*name == NULL) { /* Avoid memory leak in case of malformed string */
*name = ws_strdup(token + strlen(name_magic));
}
}
else if (strncmp(token, hwchannel_magic, strlen(hwchannel_magic)) == 0) {
if (!ws_strtou16(token + strlen(hwchannel_magic), NULL, hwchannel)) {
*hwchannel = UINT16_MAX;
}
}
else if (strncmp(token, simulated_magic, strlen(simulated_magic)) == 0) {
if (strlen(token) > strlen(simulated_magic) && token[strlen(simulated_magic)] != '0') {
*simulated = TRUE; /* TODO: Find a way to use this information */
}
}
}
g_strfreev(tokens);
return TRUE;
}
int blf_get_xml_pkt_encap(const char* start, const char* end) {
gsize len;
if (start == NULL || end == NULL || end <= start) {
return 0;
}
len = (gsize)(end - start);
if (strncmp(start, "CAN", len) == 0) {
return WTAP_ENCAP_SOCKETCAN;
}
if (strncmp(start, "FlexRay", len) == 0) {
return WTAP_ENCAP_FLEXRAY;
}
if (strncmp(start, "LIN", len) == 0) {
return WTAP_ENCAP_LIN;
}
if (strncmp(start, "Ethernet", len) == 0) {
return WTAP_ENCAP_ETHERNET;
}
if (strncmp(start, "WLAN", len) == 0) { /* Not confirmed with a real capture */
return WTAP_ENCAP_IEEE_802_11;
}
return 0xffffffff;
}
/** Finds a NULL-terminated string in a block of memory.
*
* 'start' points to the first byte of the block of memory.
* 'end' points to the first byte after the end of the block of memory,
* so that the size of the block is end-start.
* 'str' is a NULL-terminated string.
*/
const char* blf_strmem(const char* start, const char* end, const char* str) {
if (start == NULL || end == NULL || str == NULL || end <= start) {
return NULL;
}
return ws_memmem(start, end - start, str, strlen(str));
}
/** 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>
*/
static gboolean
blf_set_xml_channels(blf_params_t* params, const char* text, gsize len) {
static const char xml_magic[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
static const char channels_start_magic[] = "<channels ";
static const char channels_end_magic[] = "</channels>";
static const char channel_start_magic[] = "<channel ";
static const char channel_end_magic[] = "</channel>";
static const char number_start_magic[] = "number=\"";
static const char number_end_magic[] = "\"";
static const char type_start_magic[] = "type=\"";
static const char type_end_magic[] = "\"";
static const char network_start_magic[] = "network=\"";
static const char network_end_magic[] = "\"";
static const char ports_start_magic[] = "<elist name=\"ports\">";
static const char ports_end_magic[] = "</elist>";
static const char port_start_magic[] = "<eli name=\"port\">";
static const char port_end_magic[] = "</eli>";
const char* xml_start;
const char* channels_start;
const char* channels_end;
const char* channel_start;
const char* channel_end;
const char* number_start;
const char* number_end;
const char* type_start;
const char* type_end;
const char* network_start;
const char* network_end;
const char* ports_start;
const char* ports_end;
const char* port_start;
const char* port_end;
const char* search_start;
gboolean res;
int pkt_encap;
guint16 channel;
guint16 hwchannel = UINT16_MAX;
char* channel_name = NULL;
char* port_name = NULL;
gboolean simulated = FALSE;
gchar* iface_name = NULL;
if (text == NULL || len < strlen(xml_magic)) {
return FALSE;
}
xml_start = blf_strmem(text, text + len, xml_magic);
if (xml_start == NULL) {
ws_debug("no valid xml magic found");
return FALSE;
}
search_start = xml_start + strlen(xml_magic);
channels_start = blf_strmem(search_start, text + len, channels_start_magic);
channels_end = blf_strmem(search_start, text + len, channels_end_magic);
if (channels_start == NULL || channels_end == NULL || channels_end <= channels_start + strlen(channels_start_magic)) {
ws_debug("no channels tag found in xml");
return FALSE;
}
search_start = channels_start + strlen(channels_start_magic);
while (search_start < channels_end) {
channel_start = blf_strmem(search_start, channels_end, channel_start_magic);
search_start = search_start + strlen(channel_start_magic);
channel_end = blf_strmem(search_start, channels_end, channel_end_magic);
if (channel_start == NULL || channel_end == NULL || channel_end <= channel_start + strlen(channel_start_magic)) {
ws_debug("found end of channel list");
return TRUE;
}
number_start = blf_strmem(channel_start, channel_end, number_start_magic);
if (number_start == NULL) {
ws_debug("channel without number found in xml");
search_start = channel_end + strlen(channel_end_magic);
continue;
}
number_end = blf_strmem(number_start + strlen(number_start_magic), channel_end, number_end_magic);
if (number_end == NULL) {
ws_debug("channel with malformed number attribute found in xml");
search_start = channel_end + strlen(channel_end_magic);
continue;
}
channel = blf_get_xml_channel_number(number_start + strlen(number_start_magic), number_end);
if (channel == UINT16_MAX) {
ws_debug("invalid channel number found in xml");
search_start = channel_end + strlen(channel_end_magic);
continue;
}
type_start = blf_strmem(channel_start, channel_end, type_start_magic);
if (type_start == NULL) {
ws_debug("channel without type found in xml");
search_start = channel_end + strlen(channel_end_magic);
continue;
}
type_end = blf_strmem(type_start + strlen(type_start_magic), channel_end, type_end_magic);
if (type_end == NULL) {
ws_debug("channel with malformed type attribute found in xml");
search_start = channel_end + strlen(channel_end_magic);
continue;
}
pkt_encap = blf_get_xml_pkt_encap(type_start + strlen(type_start_magic), type_end);
network_start = blf_strmem(channel_start, channel_end, network_start_magic);
if (network_start == NULL) {
ws_debug("channel without name found in xml");
search_start = channel_end + strlen(channel_end_magic);
continue;
}
network_end = blf_strmem(network_start + strlen(network_start_magic), channel_end, network_end_magic);
if (network_end == NULL) {
ws_debug("channel with malformed network attribute found in xml");
search_start = channel_end + strlen(channel_end_magic);
continue;
}
channel_name = blf_get_xml_channel_name(network_start + strlen(network_start_magic), network_end);
if (channel_name == NULL || strlen(channel_name) == 0) {
ws_debug("channel with empty name found in xml");
if (channel_name) {
g_free(channel_name);
channel_name = NULL;
}
search_start = channel_end + strlen(channel_end_magic);
continue;
}
ws_debug("Found channel in XML: PKT_ENCAP: %d, ID: %u, name: %s", pkt_encap, channel, channel_name);
blf_prepare_interface_name(params, pkt_encap, channel, UINT16_MAX, channel_name, TRUE);
search_start = MAX(MAX(number_end + strlen(number_end_magic), type_end + strlen(type_end_magic)), network_end + strlen(network_end_magic));
ports_start = blf_strmem(search_start, channel_end, ports_start_magic);
if (ports_start == NULL) {
/* Not an error, channel has no ports */
if (channel_name) {
g_free(channel_name);
channel_name = NULL;
}
search_start = channel_end + strlen(channel_end_magic);
continue;
}
search_start = ports_start + strlen(ports_start_magic);
ports_end = blf_strmem(search_start, channel_end, ports_end_magic);
if (ports_end == NULL) {
ws_debug("channel with malformed ports tag found in xml");
if (channel_name) {
g_free(channel_name);
channel_name = NULL;
}
search_start = channel_end + strlen(channel_end_magic);
continue;
}
while (search_start < ports_end) {
port_start = blf_strmem(search_start, ports_end, port_start_magic);
port_end = blf_strmem(search_start + strlen(port_start_magic), ports_end, port_end_magic);
if (port_start == NULL || port_end == NULL || port_end <= port_start + strlen(port_start_magic)) {
ws_debug("found end of ports list");
search_start = ports_end + strlen(ports_end_magic);
continue;
}
res = blf_parse_xml_port(port_start + strlen(port_start_magic), port_end, &port_name, &hwchannel, &simulated);
if (!res || port_name == NULL || hwchannel == UINT16_MAX) {
if (port_name) {
g_free(port_name);
port_name = NULL;
}
ws_debug("port with missing or malformed info found in xml");
search_start = port_end + strlen(port_end_magic);
continue;
}
iface_name = ws_strdup_printf("%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);
blf_prepare_interface_name(params, pkt_encap, channel, hwchannel, iface_name, TRUE);
g_free(iface_name);
if (port_name) {
g_free(port_name);
port_name = NULL;
}
search_start = port_end + strlen(port_end_magic);
}
if (channel_name) {
g_free(channel_name);
channel_name = NULL;
}
search_start = channel_end + strlen(channel_end_magic);
}
return TRUE;
}
static int
blf_read_apptextmessage(blf_params_t *params, int *err, gchar **err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, gsize metadata_cont) {
blf_apptext_t apptextheader;
if (object_length < (data_start - block_start) + (int)sizeof(apptextheader)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: APP_TEXT: not enough bytes for apptext header in object");
ws_debug("not enough bytes for apptext header in object");
return BLF_APPTEXT_FAILED;
}
if (!blf_read_bytes(params, data_start, &apptextheader, sizeof(apptextheader), err, err_info)) {
ws_debug("not enough bytes for apptext header in file");
return BLF_APPTEXT_FAILED;
}
fix_endianness_blf_apptext_header(&apptextheader);
if (metadata_cont && apptextheader.source != BLF_APPTEXT_METADATA) {
/* 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_cont = 0;
}
/* Add an extra byte for a terminating '\0' */
gchar* text = g_try_malloc((gsize)apptextheader.textLength + 1);
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");
g_free(text);
return BLF_APPTEXT_FAILED;
}
text[apptextheader.textLength] = '\0'; /* Here's the '\0' */
switch (apptextheader.source) {
case BLF_APPTEXT_CHANNEL:
{
/* returns a NULL terminated array of NULL terminates strings */
gchar** tokens = g_strsplit_set(text, ";", -1);
if (tokens == NULL || tokens[0] == NULL || tokens[1] == NULL) {
if (tokens != NULL) {
g_strfreev(tokens);
}
g_free(text);
return BLF_APPTEXT_CHANNEL;
}
guint16 channel = (apptextheader.reservedAppText1 >> 8) & 0xff;
int pkt_encap;
switch ((apptextheader.reservedAppText1 >> 16) & 0xff) {
case BLF_BUSTYPE_CAN:
pkt_encap = WTAP_ENCAP_SOCKETCAN;
break;
case BLF_BUSTYPE_FLEXRAY:
pkt_encap = WTAP_ENCAP_FLEXRAY;
break;
case BLF_BUSTYPE_LIN:
pkt_encap = WTAP_ENCAP_LIN;
break;
case BLF_BUSTYPE_ETHERNET:
pkt_encap = WTAP_ENCAP_ETHERNET;
break;
case BLF_BUSTYPE_WLAN:
pkt_encap = WTAP_ENCAP_IEEE_802_11;
break;
default:
pkt_encap = 0xffffffff;
}
/* we use lookup to create interface, if not existing yet */
blf_prepare_interface_name(params, pkt_encap, channel, UINT16_MAX, tokens[1], FALSE);
g_strfreev(tokens);
g_free(text);
return BLF_APPTEXT_CHANNEL;
break;
}
case BLF_APPTEXT_METADATA:
if (metadata_cont) {
/* Set the buffer pointer to the end of the previous object */
params->buf->first_free = metadata_cont;
}
else {
/* First object of a sequence of one or more */
wtap_buffer_append_epdu_string(params->buf, EXP_PDU_TAG_DISSECTOR_NAME, "data-text-lines");
wtap_buffer_append_epdu_string(params->buf, EXP_PDU_TAG_COL_PROT_TEXT, "BLF App text");
wtap_buffer_append_epdu_string(params->buf, EXP_PDU_TAG_COL_INFO_TEXT, "Metadata");
wtap_buffer_append_epdu_end(params->buf);
}
ws_buffer_assure_space(params->buf, apptextheader.textLength);
ws_buffer_append(params->buf, text, apptextheader.textLength);
g_free(text);
if ((apptextheader.reservedAppText1 & 0x00ffffff) > apptextheader.textLength) {
/* Continues in the next object */
return BLF_APPTEXT_CONT;
}
if (((apptextheader.reservedAppText1 >> 24) & 0xff) == BLF_APPTEXT_XML_CHANNELS) {
blf_set_xml_channels(params, params->buf->data, ws_buffer_length(params->buf));
}
blf_init_rec(params, flags, object_timestamp, WTAP_ENCAP_WIRESHARK_UPPER_PDU, 0, UINT16_MAX, (guint32)ws_buffer_length(params->buf), (guint32)ws_buffer_length(params->buf));
return BLF_APPTEXT_METADATA;
break;
case BLF_APPTEXT_COMMENT:
case BLF_APPTEXT_ATTACHMENT:
case BLF_APPTEXT_TRACELINE:
{
wtap_buffer_append_epdu_string(params->buf, EXP_PDU_TAG_DISSECTOR_NAME, "data-text-lines");
wtap_buffer_append_epdu_string(params->buf, EXP_PDU_TAG_COL_PROT_TEXT, "BLF App text");
gchar* info_line = NULL;
switch (apptextheader.source) {
case BLF_APPTEXT_COMMENT:
info_line = ws_strdup_printf("Comment: %s", text);
break;
case BLF_APPTEXT_ATTACHMENT:
info_line = ws_strdup_printf("Attachment: %s", text);
break;
case BLF_APPTEXT_TRACELINE:
info_line = ws_strdup_printf("Trace line%s: %s", (apptextheader.reservedAppText1 & 0x00000010) ? "" : " (hidden)", text);
break;
default:
break;
}
wtap_buffer_append_epdu_string(params->buf, EXP_PDU_TAG_COL_INFO_TEXT, info_line);
wtap_buffer_append_epdu_end(params->buf);
gsize text_length = strlen(text); /* The string can contain '\0' before textLength bytes */
ws_buffer_assure_space(params->buf, text_length); /* The dissector doesn't need NULL-terminated strings */
ws_buffer_append(params->buf, text, text_length);
/* 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_PDU, 0, UINT16_MAX, (guint32)ws_buffer_length(params->buf), (guint32)ws_buffer_length(params->buf));
g_free(text);
if (info_line) {
g_free(info_line);
}
return apptextheader.source;
break;
}
default:
g_free(text);
return BLF_APPTEXT_CHANNEL; /* Cheat - no block to write */;
break;
}
return BLF_APPTEXT_CHANNEL; /* Cheat - no block to write */
}
static gboolean
blf_read_ethernet_status(blf_params_t* params, int* err, gchar** err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp, guint16 object_version) {
blf_ethernet_status_t ethernet_status_header;
guint8 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;
*err_info = ws_strdup_printf("blf: ETHERNET_STATUS: not enough bytes for ethernet status header in object");
ws_debug("not enough bytes for ethernet status header in object");
return FALSE;
}
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");
return FALSE;
}
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");
return FALSE;
}
GUINT64_FROM_LE(linkUpDuration);
}
fix_endianness_blf_ethernet_status_header(&ethernet_status_header);
tmpbuf[0] = (ethernet_status_header.channel & 0xff00) >> 8;
tmpbuf[1] = (ethernet_status_header.channel & 0x00ff);
tmpbuf[2] = (ethernet_status_header.flags & 0xff00) >> 8;
tmpbuf[3] = (ethernet_status_header.flags & 0x00ff);
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);
tmpbuf[12] = (ethernet_status_header.bitrate & 0xff000000) >> 24;
tmpbuf[13] = (ethernet_status_header.bitrate & 0x00ff0000) >> 16;
tmpbuf[14] = (ethernet_status_header.bitrate & 0x0000ff00) >> 8;
tmpbuf[15] = (ethernet_status_header.bitrate & 0x000000ff);
if (object_version >= 1) {
tmpbuf[16] = (linkUpDuration & UINT64_C(0xff00000000000000)) >> 56;
tmpbuf[17] = (linkUpDuration & UINT64_C(0x00ff000000000000)) >> 48;
tmpbuf[18] = (linkUpDuration & UINT64_C(0x0000ff0000000000)) >> 40;
tmpbuf[19] = (linkUpDuration & UINT64_C(0x000000ff00000000)) >> 32;
tmpbuf[20] = (linkUpDuration & UINT64_C(0x00000000ff000000)) >> 24;
tmpbuf[21] = (linkUpDuration & UINT64_C(0x0000000000ff0000)) >> 16;
tmpbuf[22] = (linkUpDuration & UINT64_C(0x000000000000ff00)) >> 8;
tmpbuf[23] = (linkUpDuration & UINT64_C(0x00000000000000ff));
}
wtap_buffer_append_epdu_string(params->buf, EXP_PDU_TAG_DISSECTOR_NAME, "blf-ethernetstatus-obj");
wtap_buffer_append_epdu_end(params->buf);
ws_buffer_assure_space(params->buf, sizeof(ethernet_status_header));
ws_buffer_append(params->buf, tmpbuf, (gsize)(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);
blf_lookup_interface(params, WTAP_ENCAP_WIRESHARK_UPPER_PDU, 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_PDU, ethernet_status_header.channel, ethernet_status_header.hardwareChannel, (guint32)ws_buffer_length(params->buf), (guint32)ws_buffer_length(params->buf));
if ((ethernet_status_header.flags & BLF_ETH_STATUS_HARDWARECHANNEL) == BLF_ETH_STATUS_HARDWARECHANNEL) {
/* If HW channel valid */
wtap_block_add_uint32_option(params->rec->block, OPT_PKT_QUEUE, ethernet_status_header.hardwareChannel);
}
return TRUE;
}
static gboolean
blf_read_ethernet_phystate(blf_params_t* params, int* err, gchar** err_info, gint64 block_start, gint64 data_start, gint64 object_length, guint32 flags, guint64 object_timestamp) {
blf_ethernet_phystate_t ethernet_phystate_header;
guint8 tmpbuf[8];
if (object_length < (data_start - block_start) + (int)sizeof(ethernet_phystate_header)) {
*err = WTAP_ERR_BAD_FILE;
*err_info = ws_strdup_printf("blf: ETHERNET_PHY_STATE: not enough bytes for ethernet phystate header in object");
ws_debug("not enough bytes for ethernet phystate header in object");
return FALSE;
}
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");
return FALSE;
}
fix_endianness_blf_ethernet_phystate_header(&ethernet_phystate_header);
tmpbuf[0] = (ethernet_phystate_header.channel & 0xff00) >> 8;
tmpbuf[1] = (ethernet_phystate_header.channel & 0x00ff);
tmpbuf[2] = (ethernet_phystate_header.flags & 0xff00) >> 8;
tmpbuf[3] = (ethernet_phystate_header.flags & 0x00ff);
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->buf, EXP_PDU_TAG_DISSECTOR_NAME, "blf-ethernetphystate-obj");
wtap_buffer_append_epdu_end(params->buf);
ws_buffer_assure_space(params->buf, sizeof(ethernet_phystate_header));
ws_buffer_append(params->buf, tmpbuf, sizeof(ethernet_phystate_header));
/* 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);
blf_lookup_interface(params, WTAP_ENCAP_WIRESHARK_UPPER_PDU, 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_PDU, ethernet_phystate_header.channel, ethernet_phystate_header.hardwareChannel, (guint32)ws_buffer_length(params->buf), (guint32)ws_buffer_length(params->buf));
if ((ethernet_phystate_header.flags & BLF_PHY_STATE_HARDWARECHANNEL) == BLF_PHY_STATE_HARDWARECHANNEL) {
/* If HW channel valid */
wtap_block_add_uint32_option(params->rec->block, OPT_PKT_QUEUE, ethernet_phystate_header.hardwareChannel);
}
return TRUE;
}
static gboolean
blf_read_block(blf_params_t *params, gint64 start_pos, int *err, gchar **err_info) {
blf_blockheader_t header;
blf_logobjectheader_t logheader;
blf_logobjectheader2_t logheader2;
blf_logobjectheader3_t logheader3;
guint32 flags;
guint64 object_timestamp;
guint16 object_version;
gint64 last_metadata_start = 0;
gsize metadata_cont = 0;
while (1) {
/* Find Object */
/* Resetting buffer */
params->buf->first_free = params->buf->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");
if (*err == WTAP_ERR_SHORT_READ) {
/* we have found the end that is not a short read therefore. */
*err = 0;
g_free(*err_info);
}
return FALSE;
}
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);
}
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;
switch (header.header_type) {
case BLF_HEADER_TYPE_DEFAULT:
if (!blf_read_log_object_header(params, err, err_info, start_pos + sizeof(blf_blockheader_t), start_pos + header.header_length, &logheader)) {
return FALSE;
}
flags = logheader.flags;
object_timestamp = logheader.object_timestamp;
object_version = logheader.object_version;
break;
case BLF_HEADER_TYPE_2:
if (!blf_read_log_object_header2(params, err, err_info, start_pos + sizeof(blf_blockheader_t), start_pos + header.header_length, &logheader2)) {
return FALSE;
}
flags = logheader2.flags;
object_timestamp = logheader2.object_timestamp;
object_version = logheader2.object_version;
break;
case BLF_HEADER_TYPE_3:
if (!blf_read_log_object_header3(params, err, err_info, start_pos + sizeof(blf_blockheader_t), start_pos + header.header_length, &logheader3)) {
return FALSE;
}
flags = logheader3.flags;
object_timestamp = logheader3.object_timestamp;
object_version = logheader3.object_version;
break;
default:
*err = WTAP_ERR_UNSUPPORTED;
*err_info = ws_strdup_printf("blf: unknown header type %u", header.header_type);
ws_debug("unknown header type");
return FALSE;
}
/* already making sure that we start after this object next time. */
params->blf_data->current_real_seek_pos = start_pos + MAX(MAX(16, header.object_length), header.header_length);
if (metadata_cont && header.object_type != BLF_OBJTYPE_APP_TEXT) {
/* 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_cont = 0;
last_metadata_start = 0;
}
switch (header.object_type) {
case BLF_OBJTYPE_LOG_CONTAINER:
*err = WTAP_ERR_UNSUPPORTED;
*err_info = ws_strdup_printf("blf: log container in log container not supported");
ws_debug("log container in log container not supported");
return FALSE;
break;
case BLF_OBJTYPE_ETHERNET_FRAME:
return blf_read_ethernetframe(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_ETHERNET_FRAME_EX:
return blf_read_ethernetframe_ext(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_WLAN_FRAME:
return blf_read_wlanframe(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_CAN_MESSAGE:
return blf_read_canmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, FALSE);
break;
case BLF_OBJTYPE_CAN_ERROR:
return blf_read_canerror(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, FALSE);
break;
case BLF_OBJTYPE_CAN_OVERLOAD:
return blf_read_canerror(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, TRUE);
break;
case BLF_OBJTYPE_CAN_MESSAGE2:
return blf_read_canmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, TRUE);
break;
case BLF_OBJTYPE_CAN_ERROR_EXT:
return blf_read_canerrorext(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_CAN_FD_MESSAGE:
return blf_read_canfdmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_CAN_FD_MESSAGE_64:
return blf_read_canfdmessage64(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_CAN_FD_ERROR_64:
return blf_read_canfderror64(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_FLEXRAY_DATA:
return blf_read_flexraydata(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_FLEXRAY_MESSAGE:
return blf_read_flexraymessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_FLEXRAY_RCVMESSAGE:
return blf_read_flexrayrcvmessageex(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, FALSE);
break;
case BLF_OBJTYPE_FLEXRAY_RCVMESSAGE_EX:
return blf_read_flexrayrcvmessageex(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, TRUE);
break;
case BLF_OBJTYPE_LIN_MESSAGE:
return blf_read_linmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, FALSE);
break;
case BLF_OBJTYPE_LIN_CRC_ERROR:
return blf_read_linmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, TRUE);
break;
case BLF_OBJTYPE_LIN_SND_ERROR:
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_MESSAGE2:
return blf_read_linmessage2(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, object_version);
break;
case BLF_OBJTYPE_LIN_CRC_ERROR2:
return blf_read_lincrcerror2(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, object_version);
break;
case BLF_OBJTYPE_LIN_SND_ERROR2:
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_APP_TEXT:
{
int result = blf_read_apptextmessage(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, metadata_cont);
if (result == BLF_APPTEXT_CONT) {
if (!metadata_cont) {
/* First object of a sequence, save its start position */
last_metadata_start = start_pos;
}
/* Save a pointer to the end of the buffer */
metadata_cont = params->buf->first_free;
}
else {
if (result == BLF_APPTEXT_METADATA && metadata_cont) {
/* 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 */
last_metadata_start = 0;
metadata_cont = 0;
}
switch (result) {
case BLF_APPTEXT_FAILED:
return FALSE;
case BLF_APPTEXT_COMMENT:
case BLF_APPTEXT_METADATA:
case BLF_APPTEXT_ATTACHMENT:
case BLF_APPTEXT_TRACELINE:
return TRUE;
case BLF_APPTEXT_CHANNEL:
case BLF_APPTEXT_CONT:
default:
/* we do not return since there is no packet to show here */
start_pos += MAX(MAX(16, header.object_length), header.header_length);
}
}
break;
case BLF_OBJTYPE_ETHERNET_STATUS:
return blf_read_ethernet_status(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp, object_version);
break;
case BLF_OBJTYPE_ETHERNET_PHY_STATE:
return blf_read_ethernet_phystate(params, err, err_info, start_pos, start_pos + header.header_length, header.object_length, flags, object_timestamp);
break;
case BLF_OBJTYPE_ENV_INTEGER:
case BLF_OBJTYPE_ENV_DOUBLE:
case BLF_OBJTYPE_ENV_STRING:
case BLF_OBJTYPE_ENV_DATA:
case BLF_OBJTYPE_SYS_VARIABLE:
case BLF_OBJTYPE_RESERVED5: /* Despite the name, this is actually used. Maybe it's worth investigating the content. */
case BLF_OBJTYPE_TEST_STRUCTURE:
ws_debug("skipping unsupported object type 0x%04x", header.object_type);
start_pos += MAX(MAX(16, header.object_length), header.header_length);
break;
default:
ws_info("unknown object type 0x%04x", header.object_type);
start_pos += MAX(MAX(16, header.object_length), header.header_length);
break;
}
}
return TRUE;
}
static gboolean blf_read(wtap *wth, wtap_rec *rec, Buffer *buf, int *err, gchar **err_info, gint64 *data_offset) {
blf_params_t blf_tmp;
blf_tmp.wth = wth;
blf_tmp.fh = wth->fh;
blf_tmp.random = FALSE;
blf_tmp.pipe = wth->ispipe;
blf_tmp.rec = rec;
blf_tmp.buf = buf;
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 FALSE;
}
*data_offset = blf_tmp.blf_data->start_of_last_obj;
return TRUE;
}
static gboolean blf_seek_read(wtap *wth, gint64 seek_off, wtap_rec *rec, Buffer *buf, int *err, gchar **err_info) {
blf_params_t blf_tmp;
blf_tmp.wth = wth;
blf_tmp.fh = wth->random_fh;
blf_tmp.random = TRUE;
blf_tmp.pipe = wth->ispipe;
blf_tmp.rec = rec;
blf_tmp.buf = buf;
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);
return FALSE;
}
return TRUE;
}
static void blf_free(blf_t *blf) {
if (blf != NULL) {
if (blf->log_containers != NULL) {
for (guint 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);
if (log_container->real_data != NULL) {
g_free(log_container->real_data);
}
}
g_array_free(blf->log_containers, TRUE);
blf->log_containers = NULL;
}
if (blf->channel_to_iface_ht != NULL) {
g_hash_table_destroy(blf->channel_to_iface_ht);
blf->channel_to_iface_ht = NULL;
}
if (blf->channel_to_name_ht != NULL) {
g_hash_table_destroy(blf->channel_to_name_ht);
blf->channel_to_name_ht = NULL;
}
}
}
static void blf_close(wtap *wth) {
blf_free((blf_t *)wth->priv);
/* TODO: do we need to reverse the wtap_add_idb? how? */
}
wtap_open_return_val
blf_open(wtap *wth, int *err, gchar **err_info) {
blf_fileheader_t header;
blf_t *blf;
blf_params_t params;
ws_debug("opening file");
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);
if (*err == 0 || *err == WTAP_ERR_SHORT_READ) {
/*
* 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;
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;
*err_info = ws_strdup("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, header.header_length - sizeof(blf_fileheader_t), err, err_info)) {
return WTAP_OPEN_ERROR;
}
struct tm timestamp;
timestamp.tm_year = (header.start_date.year > 1970) ? header.start_date.year - 1900 : 70;
timestamp.tm_mon = header.start_date.month -1;
timestamp.tm_mday = header.start_date.day;
timestamp.tm_hour = header.start_date.hour;
timestamp.tm_min = header.start_date.mins;
timestamp.tm_sec = header.start_date.sec;
timestamp.tm_isdst = -1;
/* Prepare our private context. */
blf = g_new(blf_t, 1);
blf->log_containers = g_array_new(FALSE, FALSE, sizeof(blf_log_container_t));
blf->current_real_seek_pos = 0;
blf->start_offset_ns = 1000 * 1000 * 1000 * (guint64)mktime(&timestamp);
blf->start_offset_ns += 1000 * 1000 * header.start_date.ms;
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;
/* embed in params */
params.blf_data = blf;
params.buf = NULL;
params.fh = wth->fh;
params.random = FALSE;
params.pipe = wth->ispipe;
params.rec = NULL;
params.wth = wth;
params.blf_data->current_real_seek_pos = 0;
wth->priv = (void *)blf;
wth->file_encap = WTAP_ENCAP_NONE;
wth->snapshot_length = 0;
wth->file_tsprec = WTAP_TSPREC_UNKNOWN;
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;
}
/* Options for interface blocks. */
static const struct supported_option_type interface_block_options_supported[] = {
/* No comments, just an interface name. */
{ OPT_IDB_NAME, ONE_OPTION_SUPPORTED }
};
static const struct supported_block_type blf_blocks_supported[] = {
{ WTAP_BLOCK_PACKET, MULTIPLE_BLOCKS_SUPPORTED, NO_OPTIONS_SUPPORTED },
{ WTAP_BLOCK_IF_ID_AND_INFO, MULTIPLE_BLOCKS_SUPPORTED, OPTION_TYPES_SUPPORTED(interface_block_options_supported) },
};
static const struct file_type_subtype_info blf_info = {
"Vector Informatik Binary Logging Format (BLF) logfile", "blf", "blf", NULL,
FALSE, BLOCKS_SUPPORTED(blf_blocks_supported),
NULL, NULL, NULL
};
void register_blf(void)
{
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);
}
/*
* 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:
*/
Reference in New Issue View Git Blame Copy Permalink