summaryrefslogtreecommitdiffstats
path: root/epan/dissectors/packet-iso15765.c
diff options
context:
space:
mode:
Diffstat (limited to 'epan/dissectors/packet-iso15765.c')
-rw-r--r--epan/dissectors/packet-iso15765.c1068
1 files changed, 519 insertions, 549 deletions
diff --git a/epan/dissectors/packet-iso15765.c b/epan/dissectors/packet-iso15765.c
index b27dc7ca..0db53ffb 100644
--- a/epan/dissectors/packet-iso15765.c
+++ b/epan/dissectors/packet-iso15765.c
@@ -9,9 +9,36 @@
*/
/*
- * Support for FlexRay variant, see: https://www.autosar.org/fileadmin/user_upload/standards/classic/20-11/AUTOSAR_SWS_FlexRayARTransportLayer.pdf
+ * CAN ID Mapping
+ *
+ * When using ISO15765 to transport UDS and others, the diagnostic addresses might be
+ * determined by mapping the underlaying CAN ID (29bit or 11bit).
+ *
+ * Option 1: Two Addresses can be determined (Source and Target Address.
+ * Option 2: One Address can be determined (ECU Address).
+ * Option 3: No Address can be determined.
+ *
+ * For Option 1 and 2 the ISO15765_can_id_mappings table can be used to determine the addresses:
+ * - Ext Addr determines, if the CAN ID is 29bit (true) or 11bit (false)
+ * - CAN ID and CAN ID Mask determined how to know if a CAN ID should be mapped
+ * - Source Addr Mask and Target Addr Mask show the bits used to determine the addresses of Option 1
+ * - ECU Addr Mask defines the bits for the address of Option 2
+ *
+ * Example:
+ * - ISO15765 is applicable to all 29bit CAN IDs 0x9988TTSS, with TT the target address and SS the source address.
+ * - Ext Addr: true
+ * - CAN ID: 0x99880000
+ * - CAN ID Mask: 0xffff0000
+ * - Target Addr Mask: 0x0000ff00
+ * - Source Addr Mask: 0x000000ff
+ *
+ * The addresses are passed via iso15765data_t to the next dissector (e.g., UDS).
*/
+/*
+ * Support for FlexRay variant, see: https://www.autosar.org/fileadmin/standards/R20-11/CP/AUTOSAR_SWS_FlexRayARTransportLayer.pdf
+*/
+
#include "config.h"
#include <epan/packet.h>
@@ -22,6 +49,8 @@
#include <epan/proto_data.h>
#include <epan/uat.h>
#include <wsutil/bits_ctz.h>
+#include <wsutil/bits_count_ones.h>
+#include <wiretap/wtap.h>
#include "packet-socketcan.h"
#include "packet-lin.h"
@@ -33,10 +62,6 @@
void proto_register_iso15765(void);
void proto_reg_handoff_iso15765(void);
-#define ISO15765_PCI_LEN 1
-#define ISO15765_PCI_FD_SF_LEN 2
-#define ISO15765_PCI_FD_FF_LEN 6
-
#define ISO15765_MESSAGE_TYPE_MASK 0xF0
#define ISO15765_MESSAGE_TYPES_SINGLE_FRAME 0
#define ISO15765_MESSAGE_TYPES_FIRST_FRAME 1
@@ -48,64 +73,76 @@ void proto_reg_handoff_iso15765(void);
#define ISO15765_MESSAGE_TYPES_FR_ACK_FRAME 7
#define ISO15765_MESSAGE_DATA_LENGTH_MASK 0x0F
-#define ISO15765_FD_MESSAGE_DATA_LENGTH_MASK 0x00FF
-#define ISO15765_MESSAGE_EXTENDED_FRAME_LENGTH_MASK 0x0F
-#define ISO15765_MESSAGE_FRAME_LENGTH_OFFSET (ISO15765_PCI_LEN)
-#define ISO15765_MESSAGE_FRAME_LENGTH_LEN 1
#define ISO15765_MESSAGE_SEQUENCE_NUMBER_MASK 0x0F
#define ISO15765_MESSAGE_FLOW_STATUS_MASK 0x0F
-#define ISO15765_FC_BS_OFFSET (ISO15765_PCI_LEN)
-#define ISO15765_FC_BS_LEN 1
-#define ISO15765_FC_STMIN_OFFSET (ISO15765_FC_BS_OFFSET + ISO15765_FC_BS_LEN)
-#define ISO15765_FC_STMIN_LEN 1
+#define ISO15765_MESSAGE_FIRST_FRAME_DATA_LENGTH_MASK 0x0FFF
#define ISO15765_MESSAGE_AUTOSAR_ACK_MASK 0xF0
#define ISO15765_AUTOSAR_ACK_OFFSET 3
#define ISO15765_ADDR_INVALID 0xffffffff
-struct iso15765_identifier
+typedef struct iso15765_identifier {
+ uint32_t id;
+ uint32_t seq;
+ uint16_t frag_id;
+ bool last;
+ uint32_t bytes_used;
+} iso15765_identifier_t;
+
+typedef struct iso15765_frame {
+ uint32_t seq;
+ uint32_t last_byte_seen;
+ uint32_t len;
+ uint32_t bytes_in_cf;
+ bool error;
+ bool ff_seen;
+ uint16_t last_frag_id;
+ uint8_t frag_id_high[16];
+} iso15765_frame_t;
+
+typedef struct iso15765_seq_key {
+ uint32_t bus_type;
+ uint32_t frame_id;
+ uint32_t iface_id;
+} iso15765_seq_key_t;
+
+static unsigned
+iso15765_seq_hash_func(const void *v)
{
- guint32 id;
- guint32 seq;
- guint16 frag_id;
- gboolean last;
-};
-
-typedef struct iso15765_identifier iso15765_identifier_t;
-
+ const iso15765_seq_key_t* key = (const iso15765_seq_key_t*)v;
+ return (key->frame_id ^ key->bus_type);
+}
-struct iso15765_frame
+static int
+iso15765_seq_equal_func(const void *v1, const void *v2)
{
- guint32 seq;
- guint32 offset;
- guint32 len;
- gboolean error;
- gboolean complete;
- guint16 last_frag_id;
- guint8 frag_id_high[16];
-};
+ const iso15765_seq_key_t* key1 = (const iso15765_seq_key_t*)v1;
+ const iso15765_seq_key_t* key2 = (const iso15765_seq_key_t*)v2;
-typedef struct iso15765_frame iso15765_frame_t;
+ return (key1->bus_type == key2->bus_type &&
+ key1->frame_id == key2->frame_id &&
+ key1->iface_id == key2->iface_id);
+}
static const value_string iso15765_message_types[] = {
- {ISO15765_MESSAGE_TYPES_SINGLE_FRAME, "Single Frame"},
- {ISO15765_MESSAGE_TYPES_FIRST_FRAME, "First Frame"},
- {ISO15765_MESSAGE_TYPES_CONSECUTIVE_FRAME, "Consecutive Frame"},
- {ISO15765_MESSAGE_TYPES_FLOW_CONTROL, "Flow control"},
- {ISO15765_MESSAGE_TYPES_FR_SINGLE_FRAME_EXT, "Single Frame Ext"},
- {ISO15765_MESSAGE_TYPES_FR_FIRST_FRAME_EXT, "First Frame Ext"},
- {ISO15765_MESSAGE_TYPES_FR_CONSECUTIVE_FRAME_2, "Consecutive Frame 2"},
- {ISO15765_MESSAGE_TYPES_FR_ACK_FRAME, "Ack Frame"},
- {0, NULL}
+ {ISO15765_MESSAGE_TYPES_SINGLE_FRAME, "Single Frame"},
+ {ISO15765_MESSAGE_TYPES_FIRST_FRAME, "First Frame"},
+ {ISO15765_MESSAGE_TYPES_CONSECUTIVE_FRAME, "Consecutive Frame"},
+ {ISO15765_MESSAGE_TYPES_FLOW_CONTROL, "Flow control"},
+ {ISO15765_MESSAGE_TYPES_FR_SINGLE_FRAME_EXT, "Single Frame Ext"},
+ {ISO15765_MESSAGE_TYPES_FR_FIRST_FRAME_EXT, "First Frame Ext"},
+ {ISO15765_MESSAGE_TYPES_FR_CONSECUTIVE_FRAME_2, "Consecutive Frame 2"},
+ {ISO15765_MESSAGE_TYPES_FR_ACK_FRAME, "Ack Frame"},
+ {0, NULL}
};
static const value_string iso15765_flow_status_types[] = {
- {0, "Continue to Send"},
- {1, "Wait"},
- {2, "Overflow"},
- {0, NULL}
+ {0, "Continue to Send"},
+ {1, "Wait"},
+ {2, "Overflow"},
+ {0, NULL}
};
#define NORMAL_ADDRESSING 1
@@ -115,116 +152,121 @@ static const value_string iso15765_flow_status_types[] = {
#define ONE_BYTE_ADDRESSING 1
#define TWO_BYTE_ADDRESSING 2
-static gint addressing = NORMAL_ADDRESSING;
-static gint flexray_addressing = ONE_BYTE_ADDRESSING;
-static guint flexray_segment_size_limit = 0;
-static guint window = 8;
-static range_t *configured_can_ids= NULL;
-static range_t *configured_ext_can_ids = NULL;
-static gboolean register_lin_diag_frames = TRUE;
-static range_t *configured_ipdum_pdu_ids = NULL;
-static gint ipdum_addressing = ZERO_BYTE_ADDRESSING;
+static int addressing = NORMAL_ADDRESSING;
+static int flexray_addressing = ONE_BYTE_ADDRESSING;
+static unsigned flexray_segment_size_limit;
+static unsigned window = 8;
+static range_t *configured_can_ids;
+static range_t *configured_ext_can_ids;
+static bool register_lin_diag_frames = true;
+static range_t *configured_ipdum_pdu_ids;
+static int ipdum_addressing = ZERO_BYTE_ADDRESSING;
/* Encoding */
static const enum_val_t enum_addressing[] = {
- {"normal", "Normal addressing", NORMAL_ADDRESSING},
- {"extended", "Extended addressing", EXTENDED_ADDRESSING},
- {NULL, NULL, 0}
+ {"normal", "Normal addressing", NORMAL_ADDRESSING},
+ {"extended", "Extended addressing", EXTENDED_ADDRESSING},
+ {NULL, NULL, 0}
};
/* Encoding */
static const enum_val_t enum_flexray_addressing[] = {
- {"1 Byte", "1 byte addressing", ONE_BYTE_ADDRESSING},
- {"2 Byte", "2 byte addressing", TWO_BYTE_ADDRESSING},
- {NULL, NULL, 0}
+ {"1 Byte", "1 byte addressing", ONE_BYTE_ADDRESSING},
+ {"2 Byte", "2 byte addressing", TWO_BYTE_ADDRESSING},
+ {NULL, NULL, 0}
};
static const enum_val_t enum_ipdum_addressing[] = {
- {"0 Byte", "0 byte addressing", ZERO_BYTE_ADDRESSING},
- {"1 Byte", "1 byte addressing", ONE_BYTE_ADDRESSING},
- {"2 Byte", "2 byte addressing", TWO_BYTE_ADDRESSING},
- {NULL, NULL, 0}
+ {"0 Byte", "0 byte addressing", ZERO_BYTE_ADDRESSING},
+ {"1 Byte", "1 byte addressing", ONE_BYTE_ADDRESSING},
+ {"2 Byte", "2 byte addressing", TWO_BYTE_ADDRESSING},
+ {NULL, NULL, 0}
};
-static int hf_iso15765_address = -1;
-static int hf_iso15765_target_address = -1;
-static int hf_iso15765_source_address = -1;
-static int hf_iso15765_message_type = -1;
-static int hf_iso15765_data_length = -1;
-static int hf_iso15765_frame_length = -1;
-static int hf_iso15765_sequence_number = -1;
-static int hf_iso15765_flow_status = -1;
+static int hf_iso15765_address;
+static int hf_iso15765_target_address;
+static int hf_iso15765_source_address;
+static int hf_iso15765_message_type;
+static int hf_iso15765_data_length_8bit;
+static int hf_iso15765_data_length_4bit;
+static int hf_iso15765_frame_length_32bit;
+static int hf_iso15765_frame_length_12bit;
+static int hf_iso15765_sequence_number;
+static int hf_iso15765_flow_status;
+static int hf_iso15765_segment_data;
+static int hf_iso15765_padding;
-static int hf_iso15765_fc_bs = -1;
-static int hf_iso15765_fc_stmin = -1;
-static int hf_iso15765_fc_stmin_in_us = -1;
+static int hf_iso15765_fc_bs;
+static int hf_iso15765_fc_stmin;
+static int hf_iso15765_fc_stmin_in_us;
-static int hf_iso15765_autosar_ack = -1;
+static int hf_iso15765_autosar_ack;
-static gint ett_iso15765 = -1;
+static int ett_iso15765;
-static expert_field ei_iso15765_message_type_bad = EI_INIT;
+static expert_field ei_iso15765_message_type_bad;
-static int proto_iso15765 = -1;
-static dissector_handle_t iso15765_handle_can = NULL;
-static dissector_handle_t iso15765_handle_lin = NULL;
-static dissector_handle_t iso15765_handle_flexray = NULL;
-static dissector_handle_t iso15765_handle_ipdum = NULL;
-static dissector_handle_t iso15765_handle_pdu_transport = NULL;
+static int proto_iso15765;
+static dissector_handle_t iso15765_handle_can;
+static dissector_handle_t iso15765_handle_lin;
+static dissector_handle_t iso15765_handle_flexray;
+static dissector_handle_t iso15765_handle_ipdum;
+static dissector_handle_t iso15765_handle_pdu_transport;
static dissector_table_t subdissector_table;
static reassembly_table iso15765_reassembly_table;
-static wmem_map_t *iso15765_frame_table = NULL;
-
-static int hf_iso15765_fragments = -1;
-static int hf_iso15765_fragment = -1;
-static int hf_iso15765_fragment_overlap = -1;
-static int hf_iso15765_fragment_overlap_conflicts = -1;
-static int hf_iso15765_fragment_multiple_tails = -1;
-static int hf_iso15765_fragment_too_long_fragment = -1;
-static int hf_iso15765_fragment_error = -1;
-static int hf_iso15765_fragment_count = -1;
-static int hf_iso15765_reassembled_in = -1;
-static int hf_iso15765_reassembled_length = -1;
-
-static gint ett_iso15765_fragment = -1;
-static gint ett_iso15765_fragments = -1;
+static wmem_map_t* iso15765_seq_table;
+static wmem_map_t *iso15765_frame_table;
+
+static int hf_iso15765_fragments;
+static int hf_iso15765_fragment;
+static int hf_iso15765_fragment_overlap;
+static int hf_iso15765_fragment_overlap_conflicts;
+static int hf_iso15765_fragment_multiple_tails;
+static int hf_iso15765_fragment_too_long_fragment;
+static int hf_iso15765_fragment_error;
+static int hf_iso15765_fragment_count;
+static int hf_iso15765_reassembled_in;
+static int hf_iso15765_reassembled_length;
+
+static int ett_iso15765_fragment;
+static int ett_iso15765_fragments;
static const fragment_items iso15765_frag_items = {
- /* Fragment subtrees */
- &ett_iso15765_fragment,
- &ett_iso15765_fragments,
- /* Fragment fields */
- &hf_iso15765_fragments,
- &hf_iso15765_fragment,
- &hf_iso15765_fragment_overlap,
- &hf_iso15765_fragment_overlap_conflicts,
- &hf_iso15765_fragment_multiple_tails,
- &hf_iso15765_fragment_too_long_fragment,
- &hf_iso15765_fragment_error,
- &hf_iso15765_fragment_count,
- /* Reassembled in field */
- &hf_iso15765_reassembled_in,
- /* Reassembled length field */
- &hf_iso15765_reassembled_length,
- /* Reassembled data field */
- NULL,
- "ISO15765 fragments"
+ /* Fragment subtrees */
+ &ett_iso15765_fragment,
+ &ett_iso15765_fragments,
+ /* Fragment fields */
+ &hf_iso15765_fragments,
+ &hf_iso15765_fragment,
+ &hf_iso15765_fragment_overlap,
+ &hf_iso15765_fragment_overlap_conflicts,
+ &hf_iso15765_fragment_multiple_tails,
+ &hf_iso15765_fragment_too_long_fragment,
+ &hf_iso15765_fragment_error,
+ &hf_iso15765_fragment_count,
+ /* Reassembled in field */
+ &hf_iso15765_reassembled_in,
+ /* Reassembled length field */
+ &hf_iso15765_reassembled_length,
+ /* Reassembled data field */
+ NULL,
+ "ISO15765 fragments"
};
/* UAT for address encoded into CAN IDs */
typedef struct config_can_addr_mapping {
- gboolean extended_address;
- guint32 can_id;
- guint32 can_id_mask;
- guint32 source_addr_mask;
- guint32 target_addr_mask;
- guint32 ecu_addr_mask;
+ bool extended_address;
+ uint32_t can_id;
+ uint32_t can_id_mask;
+ uint32_t source_addr_mask;
+ uint32_t target_addr_mask;
+ uint32_t ecu_addr_mask;
} config_can_addr_mapping_t;
-static config_can_addr_mapping_t *config_can_addr_mappings = NULL;
-static guint config_can_addr_mappings_num = 0;
+static config_can_addr_mapping_t *config_can_addr_mappings;
+static unsigned config_can_addr_mappings_num;
#define DATAFILE_CAN_ADDR_MAPPING "ISO15765_can_id_mappings"
UAT_BOOL_CB_DEF(config_can_addr_mappings, extended_address, config_can_addr_mapping_t)
@@ -255,48 +297,48 @@ update_config_can_addr_mappings(void *r, char **err) {
if (rec->source_addr_mask == 0 && rec->target_addr_mask == 0 && rec->ecu_addr_mask == 0) {
*err = ws_strdup_printf("You need to define the ECU Mask OR Source Mask/Target Mask!");
- return FALSE;
+ return false;
}
if ((rec->source_addr_mask != 0 || rec->target_addr_mask != 0) && rec->ecu_addr_mask != 0) {
*err = ws_strdup_printf("You can only use Source Address Mask/Target Address Mask OR ECU Address Mask! Not both at the same time!");
- return FALSE;
+ return false;
}
if ((rec->source_addr_mask == 0 || rec->target_addr_mask == 0) && rec->ecu_addr_mask == 0) {
*err = ws_strdup_printf("You can only use Source Address Mask and Target Address Mask in combination!");
- return FALSE;
+ return false;
}
if (rec->extended_address) {
if ((rec->source_addr_mask & ~CAN_EFF_MASK) != 0) {
*err = ws_strdup_printf("Source Address Mask covering bits not allowed for extended IDs (29bit)!");
- return FALSE;
+ return false;
}
if ((rec->target_addr_mask & ~CAN_EFF_MASK) != 0) {
*err = ws_strdup_printf("Target Address Mask covering bits not allowed for extended IDs (29bit)!");
- return FALSE;
+ return false;
}
if ((rec->ecu_addr_mask & ~CAN_EFF_MASK) != 0) {
*err = ws_strdup_printf("ECU Address Mask covering bits not allowed for extended IDs (29bit)!");
- return FALSE;
+ return false;
}
} else {
if ((rec->source_addr_mask & ~CAN_SFF_MASK) != 0) {
*err = ws_strdup_printf("Source Address Mask covering bits not allowed for standard IDs (11bit)!");
- return FALSE;
+ return false;
}
if ((rec->target_addr_mask & ~CAN_SFF_MASK) != 0) {
*err = ws_strdup_printf("Target Address Mask covering bits not allowed for standard IDs (11bit)!");
- return FALSE;
+ return false;
}
if ((rec->ecu_addr_mask & ~CAN_SFF_MASK) != 0) {
*err = ws_strdup_printf("ECU Address Mask covering bits not allowed for standard IDs (11bit)!");
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
static void
@@ -309,26 +351,23 @@ post_update_config_can_addr_mappings_cb(void) {
/* do nothing right now */
}
-static guint16
-masked_guint16_value(const guint16 value, const guint16 mask)
-{
+static uint16_t
+masked_uint16_value(const uint16_t value, const uint16_t mask) {
return (value & mask) >> ws_ctz(mask);
}
-static guint32
-masked_guint32_value(const guint32 value, const guint32 mask)
-{
+static uint32_t
+masked_uint32_value(const uint32_t value, const uint32_t mask) {
return (value & mask) >> ws_ctz(mask);
}
/*
- * setting addresses to 0xffffffff, if not found or configured
- * returning number of addresses (0: none, 1:ecu (both addr same), 2:source+target)
+ * returning number of addresses (0:none, 1:ecu (both addr same), 2:source+target)
*/
-static guint8
-find_config_can_addr_mapping(gboolean ext_id, guint32 can_id, guint32 *source_addr, guint32 *target_addr) {
+static uint8_t
+find_config_can_addr_mapping(bool ext_id, uint32_t can_id, uint16_t *source_addr, uint16_t *target_addr, uint8_t *addr_len) {
config_can_addr_mapping_t *tmp = NULL;
- guint32 i;
+ uint32_t i;
if (source_addr == NULL || target_addr == NULL || config_can_addr_mappings == NULL) {
return 0;
@@ -343,15 +382,23 @@ find_config_can_addr_mapping(gboolean ext_id, guint32 can_id, guint32 *source_ad
}
}
+ *addr_len = 0;
+
if (tmp != NULL) {
if (tmp->ecu_addr_mask != 0) {
- *source_addr = masked_guint32_value(can_id, tmp->ecu_addr_mask);
+ *source_addr = masked_uint32_value(can_id, tmp->ecu_addr_mask);
*target_addr = *source_addr;
+ *addr_len = (7 + ws_count_ones(tmp->ecu_addr_mask)) / 8;
return 1;
}
if (tmp->source_addr_mask != 0 && tmp->target_addr_mask != 0) {
- *source_addr = masked_guint32_value(can_id, tmp->source_addr_mask);
- *target_addr = masked_guint32_value(can_id, tmp->target_addr_mask);
+ *source_addr = masked_uint32_value(can_id, tmp->source_addr_mask);
+ *target_addr = masked_uint32_value(can_id, tmp->target_addr_mask);
+ uint8_t tmp_len = ws_count_ones(tmp->source_addr_mask);
+ if (ws_count_ones(tmp->target_addr_mask) > tmp_len) {
+ tmp_len = ws_count_ones(tmp->target_addr_mask);
+ }
+ *addr_len = (7 + tmp_len) / 8;
return 2;
}
}
@@ -362,17 +409,17 @@ find_config_can_addr_mapping(gboolean ext_id, guint32 can_id, guint32 *source_ad
/* UAT for PDU Transport config */
typedef struct config_pdu_tranport_config {
- guint32 pdu_id;
- guint32 source_address_size;
- guint32 source_address_fixed;
- guint32 target_address_size;
- guint32 target_address_fixed;
- guint32 ecu_address_size;
- guint32 ecu_address_fixed;
+ uint32_t pdu_id;
+ uint32_t source_address_size;
+ uint32_t source_address_fixed;
+ uint32_t target_address_size;
+ uint32_t target_address_fixed;
+ uint32_t ecu_address_size;
+ uint32_t ecu_address_fixed;
} config_pdu_transport_config_t;
-static config_pdu_transport_config_t *config_pdu_transport_config_items = NULL;
-static guint config_pdu_transport_config_items_num = 0;
+static config_pdu_transport_config_t *config_pdu_transport_config_items;
+static unsigned config_pdu_transport_config_items_num;
#define DATAFILE_PDU_TRANSPORT_CONFIG "ISO15765_pdu_transport_config"
UAT_HEX_CB_DEF(config_pdu_transport_config_items, pdu_id, config_pdu_transport_config_t)
@@ -404,36 +451,36 @@ static bool
update_config_pdu_transport_config_item(void *r, char **err) {
config_pdu_transport_config_t *rec = (config_pdu_transport_config_t *)r;
- gboolean source_address_configured = rec->source_address_size != 0 || rec->source_address_fixed != ISO15765_ADDR_INVALID;
- gboolean target_address_configured = rec->target_address_size != 0 || rec->target_address_fixed != ISO15765_ADDR_INVALID;
- gboolean ecu_address_configured = rec->ecu_address_size != 0 || rec->ecu_address_fixed != ISO15765_ADDR_INVALID;
+ bool source_address_configured = rec->source_address_size != 0 || rec->source_address_fixed != ISO15765_ADDR_INVALID;
+ bool target_address_configured = rec->target_address_size != 0 || rec->target_address_fixed != ISO15765_ADDR_INVALID;
+ bool ecu_address_configured = rec->ecu_address_size != 0 || rec->ecu_address_fixed != ISO15765_ADDR_INVALID;
if (rec->source_address_size != 0 && rec->source_address_fixed != ISO15765_ADDR_INVALID) {
*err = ws_strdup_printf("You can either set the size of the source address or configure a fixed value!");
- return FALSE;
+ return false;
}
if (rec->target_address_size != 0 && rec->target_address_fixed != ISO15765_ADDR_INVALID) {
*err = ws_strdup_printf("You can either set the size of the target address or configure a fixed value!");
- return FALSE;
+ return false;
}
if (rec->ecu_address_size != 0 && rec->ecu_address_fixed != ISO15765_ADDR_INVALID) {
*err = ws_strdup_printf("You can either set the size of the ecu address or configure a fixed value!");
- return FALSE;
+ return false;
}
if (ecu_address_configured && (source_address_configured || target_address_configured)) {
*err = ws_strdup_printf("You cannot configure an ecu address and a source or target address at the same time!");
- return FALSE;
+ return false;
}
if ((source_address_configured && !target_address_configured) || (!source_address_configured && target_address_configured)) {
*err = ws_strdup_printf("You can only configure source and target address at the same time but not only one of them!");
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
static void
@@ -451,7 +498,7 @@ post_update_config_pdu_transport_config_cb(void) {
dissector_delete_all("pdu_transport.id", iso15765_handle_pdu_transport);
config_pdu_transport_config_t *tmp;
- guint i;
+ unsigned i;
for (i = 0; i < config_pdu_transport_config_items_num; i++) {
tmp = &(config_pdu_transport_config_items[i]);
dissector_add_uint("pdu_transport.id", tmp->pdu_id, iso15765_handle_pdu_transport);
@@ -459,8 +506,8 @@ post_update_config_pdu_transport_config_cb(void) {
}
static config_pdu_transport_config_t *
-find_pdu_transport_config(guint32 pdu_id) {
- guint i;
+find_pdu_transport_config(uint32_t pdu_id) {
+ unsigned i;
for (i = 0; i < config_pdu_transport_config_items_num; i++) {
if (config_pdu_transport_config_items[i].pdu_id == pdu_id) {
return &(config_pdu_transport_config_items[i]);
@@ -471,41 +518,51 @@ find_pdu_transport_config(guint32 pdu_id) {
}
static int
-handle_pdu_transport_addresses(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, gint offset_orig, guint32 pdu_id, iso15765_info_t *iso15765data) {
- gint offset = offset_orig;
+handle_pdu_transport_addresses(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset_orig, uint32_t pdu_id, iso15765_info_t *iso15765data) {
+ int offset = offset_orig;
config_pdu_transport_config_t *config = find_pdu_transport_config(pdu_id);
iso15765data->number_of_addresses_valid = 0;
- iso15765data->source_address = 0xffffffff;
- iso15765data->target_address = 0xffffffff;
+ iso15765data->source_address = 0xffff;
+ iso15765data->target_address = 0xffff;
if (config == NULL) {
return offset - offset_orig;
}
- guint32 tmp;
+ uint32_t tmp;
+ /* single address, in payload */
if (config->ecu_address_size != 0) {
proto_tree_add_item_ret_uint(tree, hf_iso15765_address, tvb, offset, config->ecu_address_size, ENC_BIG_ENDIAN, &tmp);
offset += config->ecu_address_size;
iso15765data->number_of_addresses_valid = 1;
- iso15765data->source_address = tmp;
- iso15765data->target_address = tmp;
+ iso15765data->source_address = (uint16_t)tmp;
+ iso15765data->target_address = (uint16_t)tmp;
+ iso15765data->address_length = config->ecu_address_size;
return offset - offset_orig;
}
+ /* single address, fixed */
if (config->ecu_address_fixed != ISO15765_ADDR_INVALID) {
iso15765data->number_of_addresses_valid = 1;
iso15765data->source_address = config->ecu_address_fixed;
iso15765data->target_address = config->ecu_address_fixed;
+ iso15765data->address_length = 2; /* could be also 1 Byte but we cannot know for sure */
return offset - offset_orig;
}
+ /* no address possible */
if (config->source_address_size == 0 && config->source_address_fixed == ISO15765_ADDR_INVALID && config->target_address_size == 0 && config->target_address_fixed == ISO15765_ADDR_INVALID) {
+ iso15765data->address_length = 0;
return offset - offset_orig;
}
/* now we can only have two addresses! */
iso15765data->number_of_addresses_valid = 2;
+ iso15765data->address_length = config->source_address_size;
+ if (config->target_address_size > iso15765data->address_length) {
+ iso15765data->address_length = config->target_address_size;
+ }
if (config->source_address_size != 0) {
proto_tree_add_item_ret_uint(tree, hf_iso15765_source_address, tvb, offset, config->source_address_size, ENC_BIG_ENDIAN, &tmp);
@@ -513,6 +570,7 @@ handle_pdu_transport_addresses(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree
iso15765data->source_address = tmp;
} else if (config->source_address_fixed != ISO15765_ADDR_INVALID) {
iso15765data->source_address = config->source_address_fixed;
+ iso15765data->address_length = 2; /* could be also 1 Byte but we cannot know for sure */
}
if (config->target_address_size != 0) {
@@ -521,30 +579,32 @@ handle_pdu_transport_addresses(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree
iso15765data->target_address = tmp;
} else if (config->target_address_fixed != ISO15765_ADDR_INVALID) {
iso15765data->target_address = config->target_address_fixed;
+ iso15765data->address_length = 2; /* could be also 1 Byte but we cannot know for sure */
}
return offset - offset_orig;
}
static int
-dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bus_type, guint32 frame_id, guint32 frame_length)
-{
- static guint32 msg_seqid = 0;
+dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, uint32_t bus_type, uint32_t frame_id, uint32_t frame_length) {
+ static uint32_t msg_seqid = 0;
proto_tree *iso15765_tree;
proto_item *ti;
proto_item *message_type_item;
tvbuff_t* next_tvb = NULL;
- guint16 pci, message_type;
+ uint16_t pci;
+ uint32_t message_type;
iso15765_identifier_t* iso15765_info;
/* LIN is always extended addressing */
- guint8 ae = (addressing == NORMAL_ADDRESSING && bus_type != ISO15765_TYPE_LIN) ? 0 : 1;
- guint16 frag_id_low = 0;
- guint32 offset;
- gint32 data_length;
- guint32 full_len;
- gboolean fragmented = FALSE;
- gboolean complete = FALSE;
+ uint8_t ae = (addressing == NORMAL_ADDRESSING && bus_type != ISO15765_TYPE_LIN) ? 0 : 1;
+ uint16_t frag_id_low = 0;
+ uint32_t offset, pci_offset;
+ uint32_t data_length;
+ uint32_t full_len;
+ bool fragmented = false;
+ bool complete = false;
+ uint32_t iface_id = (pinfo->rec->presence_flags & WTAP_HAS_INTERFACE_ID) ? pinfo->rec->rec_header.packet_header.interface_id : 0;
iso15765_info_t iso15765data;
@@ -556,7 +616,8 @@ dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bu
if (!iso15765_info) {
iso15765_info = wmem_new0(wmem_file_scope(), iso15765_identifier_t);
iso15765_info->id = frame_id;
- iso15765_info->last = FALSE;
+ iso15765_info->last = false;
+ iso15765_info->bytes_used = 0;
p_add_proto_data(wmem_file_scope(), pinfo, proto_iso15765, 0, iso15765_info);
}
@@ -566,94 +627,121 @@ dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bu
iso15765data.bus_type = bus_type;
iso15765data.id = frame_id;
iso15765data.number_of_addresses_valid = 0;
+ iso15765data.address_length = 0;
if (bus_type == ISO15765_TYPE_FLEXRAY) {
- guint32 tmp;
+ uint32_t tmp;
proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_source_address, tvb, 0, flexray_addressing, ENC_BIG_ENDIAN, &tmp);
- iso15765data.source_address = (guint16)tmp;
+ iso15765data.source_address = (uint16_t)tmp;
proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_target_address, tvb, flexray_addressing, flexray_addressing, ENC_BIG_ENDIAN, &tmp);
- iso15765data.target_address = (guint16)tmp;
+ iso15765data.target_address = (uint16_t)tmp;
iso15765data.number_of_addresses_valid = 2;
- ae = 2 * flexray_addressing;
+ iso15765data.address_length = flexray_addressing;
+ pci_offset = 2 * flexray_addressing;
} else if (bus_type == ISO15765_TYPE_IPDUM && ipdum_addressing > 0) {
- guint32 tmp;
+ uint32_t tmp;
proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_source_address, tvb, 0, ipdum_addressing, ENC_BIG_ENDIAN, &tmp);
- iso15765data.source_address = (guint16)tmp;
+ iso15765data.source_address = (uint16_t)tmp;
proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_target_address, tvb, ipdum_addressing, ipdum_addressing, ENC_BIG_ENDIAN, &tmp);
- iso15765data.target_address = (guint16)tmp;
+ iso15765data.target_address = (uint16_t)tmp;
iso15765data.number_of_addresses_valid = 2;
- ae = 2 * ipdum_addressing;
+ iso15765data.address_length = ipdum_addressing;
+ pci_offset = 2 * ipdum_addressing;
} else if (bus_type == ISO15765_TYPE_PDU_TRANSPORT) {
- ae = handle_pdu_transport_addresses(tvb, pinfo, iso15765_tree, 0, frame_id, &iso15765data);
+ pci_offset = handle_pdu_transport_addresses(tvb, pinfo, iso15765_tree, 0, frame_id, &iso15765data);
} else {
if (ae != 0) {
- guint32 tmp;
+ uint32_t tmp;
iso15765data.number_of_addresses_valid = 1;
+ iso15765data.address_length = ae;
proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_address, tvb, 0, ae, ENC_NA, &tmp);
- iso15765data.source_address = (guint16)tmp;
- iso15765data.target_address = (guint16)tmp;
+ iso15765data.source_address = (uint16_t)tmp;
+ iso15765data.target_address = (uint16_t)tmp;
+ pci_offset = ae;
} else {
/* Address implicitly encoded? */
if (bus_type == ISO15765_TYPE_CAN || bus_type == ISO15765_TYPE_CAN_FD) {
- gboolean ext_id = (CAN_EFF_FLAG & frame_id) == CAN_EFF_FLAG;
- guint32 can_id = ext_id ? frame_id & CAN_EFF_MASK : frame_id & CAN_SFF_MASK;
- iso15765data.number_of_addresses_valid = find_config_can_addr_mapping(ext_id, can_id, &(iso15765data.source_address), &(iso15765data.target_address));
+ bool ext_id = (CAN_EFF_FLAG & frame_id) == CAN_EFF_FLAG;
+ uint32_t can_id = ext_id ? frame_id & CAN_EFF_MASK : frame_id & CAN_SFF_MASK;
+ iso15765data.number_of_addresses_valid = find_config_can_addr_mapping(ext_id, can_id, &(iso15765data.source_address), &(iso15765data.target_address), &(iso15765data.address_length));
}
+ pci_offset = 0;
}
}
- message_type_item = proto_tree_add_item(iso15765_tree, hf_iso15765_message_type, tvb,
- ae, ISO15765_PCI_LEN, ENC_BIG_ENDIAN);
-
- pci = tvb_get_guint8(tvb, ae);
- message_type = masked_guint16_value(pci, ISO15765_MESSAGE_TYPE_MASK);
-
+ offset = pci_offset;
+ pci = tvb_get_uint8(tvb, offset);
+ message_type_item = proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_message_type, tvb, offset, 1, ENC_NA, &message_type);
col_add_str(pinfo->cinfo, COL_INFO, val_to_str(message_type, iso15765_message_types, "Unknown (0x%02x)"));
switch(message_type) {
case ISO15765_MESSAGE_TYPES_SINGLE_FRAME: {
if (frame_length > 8 && (pci & ISO15765_MESSAGE_DATA_LENGTH_MASK) == 0) {
- offset = ae + ISO15765_PCI_FD_SF_LEN;
- data_length = tvb_get_guint8(tvb, ae + 1);
- proto_tree_add_item(iso15765_tree, hf_iso15765_data_length, tvb, ae + 1, 1, ENC_BIG_ENDIAN);
+ /* Single Frame with CAN_DL > 8 Bytes: TTTT0000 LLLLLLLL, Type, Length */
+
+ /* This is always zero but still we need to dissect... */
+ proto_tree_add_item(iso15765_tree, hf_iso15765_data_length_4bit, tvb, offset, 1, ENC_NA);
+ offset += 1;
+
+ proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_data_length_8bit, tvb, offset, 1, ENC_NA, &data_length);
+ offset += 1;
} else {
- offset = ae + ISO15765_PCI_LEN;
- data_length = masked_guint16_value(pci, ISO15765_MESSAGE_DATA_LENGTH_MASK);
- proto_tree_add_uint(iso15765_tree, hf_iso15765_data_length, tvb, ae, 1, data_length);
+ /* Single Frame with CAN_DL <= 8 Bytes: TTTTLLLL, Type, Length */
+ proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_data_length_4bit, tvb, offset, 1, ENC_NA, &data_length);
+ offset += 1;
}
next_tvb = tvb_new_subset_length(tvb, offset, data_length);
- complete = TRUE;
+ complete = true;
col_append_fstr(pinfo->cinfo, COL_INFO, "(Len: %d)", data_length);
break;
}
case ISO15765_MESSAGE_TYPES_FIRST_FRAME: {
- pci = tvb_get_guint16(tvb, ae, ENC_BIG_ENDIAN);
+ pci = tvb_get_uint16(tvb, offset, ENC_BIG_ENDIAN);
if (pci == 0x1000) {
- full_len = tvb_get_guint32(tvb, ae + 2, ENC_BIG_ENDIAN);
- proto_tree_add_item(iso15765_tree, hf_iso15765_frame_length, tvb, ae + 2, 4, ENC_BIG_ENDIAN);
- offset = ae + 2 + 4;
+ /* First Frame with CAN_DL > 4095 Bytes: TTTT0000 00000000 LLLLLLLL LLLLLLLL LLLLLLLL LLLLLLLL, Type, Length */
+
+ /* This is always zero but still we need to dissect... */
+ proto_tree_add_item(iso15765_tree, hf_iso15765_frame_length_12bit, tvb, offset, 2, ENC_BIG_ENDIAN);
+ offset += 2;
+
+ proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_frame_length_32bit, tvb, offset, 4, ENC_BIG_ENDIAN, &full_len);
+ offset += 4;
} else {
- full_len = tvb_get_guint16(tvb, ae, ENC_BIG_ENDIAN) & 0xFFF;
- proto_tree_add_uint(iso15765_tree, hf_iso15765_frame_length, tvb, ae, 2, full_len);
- offset = ae + 2;
+ /* First Frame with CAN_DL <= 4095 Bytes: TTTTLLLL LLLLLLLL, Type, Length */
+ full_len = pci & ISO15765_MESSAGE_FIRST_FRAME_DATA_LENGTH_MASK;
+ proto_tree_add_item(iso15765_tree, hf_iso15765_frame_length_12bit, tvb, offset, 2, ENC_BIG_ENDIAN);
+ offset += 2;
}
+ /* we need to assume that all following bytes are of the first frame data */
data_length = tvb_reported_length(tvb) - offset;
- if (bus_type == ISO15765_TYPE_FLEXRAY && flexray_segment_size_limit != 0
- && (guint32)data_length > flexray_segment_size_limit - (offset - ae)) {
- data_length = flexray_segment_size_limit - (offset - ae);
+
+ /* FlexRay data_length cut off, if configured */
+ if (bus_type == ISO15765_TYPE_FLEXRAY && flexray_segment_size_limit != 0 && (uint32_t)data_length > flexray_segment_size_limit - (offset - pci_offset)) {
+ data_length = flexray_segment_size_limit - (offset - pci_offset);
}
- fragmented = TRUE;
+ fragmented = true;
frag_id_low = 0;
/* Save information */
if (!(pinfo->fd->visited)) {
+ iso15765_seq_key_t* key;
+ void* old_value;
+ iso15765_seq_key_t temp_key = { bus_type, frame_id, iface_id };
+ msg_seqid++;
+ if (!wmem_map_lookup_extended(iso15765_seq_table, &temp_key, (const void**)&key, &old_value)) {
+ key = wmem_new(wmem_file_scope(), iso15765_seq_key_t);
+ *key = temp_key;
+ }
+ wmem_map_insert(iso15765_seq_table, key, GUINT_TO_POINTER(msg_seqid));
+
iso15765_frame_t *iso15765_frame = wmem_new0(wmem_file_scope(), iso15765_frame_t);
- iso15765_frame->seq = iso15765_info->seq = ++msg_seqid;
+ iso15765_frame->seq = iso15765_info->seq = msg_seqid;
iso15765_frame->len = full_len;
+ iso15765_frame->bytes_in_cf = MAX(8, tvb_reported_length(tvb)) - pci_offset - 1;
wmem_map_insert(iso15765_frame_table, GUINT_TO_POINTER(iso15765_info->seq), iso15765_frame);
}
@@ -663,57 +751,62 @@ dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bu
}
case ISO15765_MESSAGE_TYPES_FR_CONSECUTIVE_FRAME_2:
case ISO15765_MESSAGE_TYPES_CONSECUTIVE_FRAME: {
- offset = ae + ISO15765_PCI_LEN;
+ /* Consecutive Frame (DF): TTTTSSSS, Type, SeqNo */
+ proto_tree_add_item(iso15765_tree, hf_iso15765_sequence_number, tvb, offset, 1, ENC_NA);
+ col_append_fstr(pinfo->cinfo, COL_INFO, "(Seq: %d)", (pci & ISO15765_MESSAGE_DATA_LENGTH_MASK));
+ offset += 1;
+
+ /* we need to assume that all following bytes are of the first frame data */
data_length = tvb_reported_length(tvb) - offset;
- frag_id_low = masked_guint16_value(pci, ISO15765_MESSAGE_SEQUENCE_NUMBER_MASK);
- fragmented = TRUE;
- if (bus_type == ISO15765_TYPE_FLEXRAY && flexray_segment_size_limit != 0
- && (guint32)data_length > flexray_segment_size_limit - (offset - ae)) {
- data_length = flexray_segment_size_limit - (offset - ae);
+ frag_id_low = masked_uint16_value(pci, ISO15765_MESSAGE_SEQUENCE_NUMBER_MASK);
+ fragmented = true;
+
+ /* FlexRay data_length cut off, if configured */
+ if (bus_type == ISO15765_TYPE_FLEXRAY && flexray_segment_size_limit != 0 && (uint32_t)data_length > flexray_segment_size_limit - (offset - pci_offset)) {
+ data_length = flexray_segment_size_limit - (offset - pci_offset);
}
/* Save information */
if (!(pinfo->fd->visited)) {
- iso15765_info->seq = msg_seqid;
+ iso15765_seq_key_t temp_key = { bus_type, frame_id, iface_id };
+ void* old_value = wmem_map_lookup(iso15765_seq_table, &temp_key);
+ iso15765_info->seq = old_value ? GPOINTER_TO_UINT(old_value) : 0;
}
-
- proto_tree_add_item(iso15765_tree, hf_iso15765_sequence_number,
- tvb, ae, ISO15765_PCI_LEN, ENC_BIG_ENDIAN);
- col_append_fstr(pinfo->cinfo, COL_INFO, "(Seq: %d)", (pci & ISO15765_MESSAGE_DATA_LENGTH_MASK));
break;
}
case ISO15765_MESSAGE_TYPES_FR_ACK_FRAME:
case ISO15765_MESSAGE_TYPES_FLOW_CONTROL: {
- guint32 status = 0;
- guint32 bs = 0;
- guint32 stmin = 0;
- gboolean stmin_in_us = FALSE;
+ /* Flow Control Frame (FC): TTTTFFFF, BBBBBBBB, SSSSSSSS, Type, Flow status, Block size, Separation time */
+ uint32_t status = 0;
+ uint32_t bs = 0;
+ uint32_t stmin = 0;
+ bool stmin_in_us = false;
data_length = 0;
- proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_flow_status, tvb, ae,
- ISO15765_PCI_LEN, ENC_BIG_ENDIAN, &status);
- proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_fc_bs, tvb, ae + ISO15765_FC_BS_OFFSET,
- ISO15765_FC_BS_LEN, ENC_BIG_ENDIAN, &bs);
+ proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_flow_status, tvb, offset, 1, ENC_NA, &status);
+ offset += 1;
+
+ proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_fc_bs, tvb, offset, 1, ENC_NA, &bs);
+ offset += 1;
- stmin = tvb_get_guint8(tvb, ae + ISO15765_FC_STMIN_OFFSET);
+ stmin = tvb_get_uint8(tvb, offset);
if (stmin >= 0xF1 && stmin <= 0xF9) {
- stmin_in_us = TRUE;
+ stmin_in_us = true;
stmin = (stmin - 0xF0) * 100U;
- proto_tree_add_uint(iso15765_tree, hf_iso15765_fc_stmin_in_us, tvb, ae + ISO15765_FC_STMIN_OFFSET,
- ISO15765_FC_STMIN_LEN, stmin);
+ proto_tree_add_uint(iso15765_tree, hf_iso15765_fc_stmin_in_us, tvb, offset, 1, stmin);
} else {
- proto_tree_add_uint(iso15765_tree, hf_iso15765_fc_stmin, tvb, ae + ISO15765_FC_STMIN_OFFSET,
- ISO15765_FC_STMIN_LEN, stmin);
+ proto_tree_add_uint(iso15765_tree, hf_iso15765_fc_stmin, tvb, offset, 1, stmin);
}
+ offset += 1;
if (message_type == ISO15765_MESSAGE_TYPES_FR_ACK_FRAME) {
- guint32 ack = 0;
- guint32 sn = 0;
- offset = ae + ISO15765_FC_STMIN_OFFSET + ISO15765_FC_STMIN_LEN;
+ uint32_t ack = 0;
+ uint32_t sn = 0;
- proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_autosar_ack, tvb, offset, 1, ENC_BIG_ENDIAN, &ack);
- proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_sequence_number, tvb, offset, 1, ENC_BIG_ENDIAN, &sn);
+ proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_autosar_ack, tvb, offset, 1, ENC_NA, &ack);
+ proto_tree_add_item_ret_uint(iso15765_tree, hf_iso15765_sequence_number, tvb, offset, 1, ENC_NA, &sn);
+ offset += 1;
col_append_fstr(pinfo->cinfo, COL_INFO, "(Status: %d, Block size: 0x%x, Separation time minimum: %d %s, Ack: %d, Seq: %d)",
status, bs, stmin, stmin_in_us ? "µs" : "ms", ack, sn);
@@ -723,70 +816,78 @@ dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bu
}
break;
}
- /* And now the AUTOSAR FlexRay TP Types... */
case ISO15765_MESSAGE_TYPES_FR_SINGLE_FRAME_EXT: {
- offset = ae + ISO15765_PCI_FD_SF_LEN;
- data_length = tvb_get_guint8(tvb, ae + 1);
- proto_tree_add_item(iso15765_tree, hf_iso15765_data_length, tvb, ae + 1, 1, ENC_BIG_ENDIAN);
+ offset += 1;
+
+ data_length = tvb_get_uint8(tvb, offset);
+ proto_tree_add_item(iso15765_tree, hf_iso15765_data_length_8bit, tvb, offset, 1, ENC_NA);
+ offset += 1;
next_tvb = tvb_new_subset_length(tvb, offset, data_length);
- complete = TRUE;
+ complete = true;
- /* Show some info */
col_append_fstr(pinfo->cinfo, COL_INFO, "(Len: %d)", data_length);
break;
}
case ISO15765_MESSAGE_TYPES_FR_FIRST_FRAME_EXT: {
- full_len = tvb_get_guint32(tvb, ae + 1, ENC_BIG_ENDIAN);
- proto_tree_add_item(iso15765_tree, hf_iso15765_frame_length, tvb, ae + 1, 4, ENC_BIG_ENDIAN);
- offset = ae + 1 + 4;
+ offset += 1;
+
+ full_len = tvb_get_uint32(tvb, offset, ENC_BIG_ENDIAN);
+ proto_tree_add_item(iso15765_tree, hf_iso15765_frame_length_32bit, tvb, offset, 4, ENC_BIG_ENDIAN);
+ offset += 4;
data_length = tvb_reported_length(tvb) - offset;
- if (bus_type == ISO15765_TYPE_FLEXRAY && flexray_segment_size_limit != 0
- && (guint32)data_length > flexray_segment_size_limit - (offset - ae)) {
- data_length = flexray_segment_size_limit - (offset - ae);
+ if (bus_type == ISO15765_TYPE_FLEXRAY && flexray_segment_size_limit != 0 && (uint32_t)data_length > flexray_segment_size_limit - (offset - pci_offset)) {
+ data_length = flexray_segment_size_limit - (offset - pci_offset);
}
- fragmented = TRUE;
+ fragmented = true;
frag_id_low = 0;
/* Save information */
if (!(pinfo->fd->visited)) {
+ iso15765_seq_key_t* key;
+ void* old_value;
+ iso15765_seq_key_t temp_key = { bus_type, frame_id, iface_id };
+ msg_seqid++;
+ if (!wmem_map_lookup_extended(iso15765_seq_table, &temp_key, (const void **)&key, &old_value)) {
+ key = wmem_new(wmem_file_scope(), iso15765_seq_key_t);
+ *key = temp_key;
+ }
+ wmem_map_insert(iso15765_seq_table, key, GUINT_TO_POINTER(msg_seqid));
+
iso15765_frame_t *iso15765_frame = wmem_new0(wmem_file_scope(), iso15765_frame_t);
- iso15765_frame->seq = iso15765_info->seq = ++msg_seqid;
+ iso15765_frame->seq = iso15765_info->seq = msg_seqid;
iso15765_frame->len = full_len;
+ iso15765_frame->bytes_in_cf = MAX(8, tvb_reported_length(tvb)) - pci_offset - 1;
wmem_map_insert(iso15765_frame_table, GUINT_TO_POINTER(iso15765_info->seq), iso15765_frame);
}
- /* Show some info */
col_append_fstr(pinfo->cinfo, COL_INFO, "(Frame Len: %d)", full_len);
break;
}
default:
- expert_add_info_format(pinfo, message_type_item, &ei_iso15765_message_type_bad,
- "Bad Message Type value %u <= 7", message_type);
- return ae;
+ expert_add_info_format(pinfo, message_type_item, &ei_iso15765_message_type_bad, "Bad Message Type value %u!", message_type);
+ return offset;
}
/* Show data */
if (data_length > 0) {
- col_append_fstr(pinfo->cinfo, COL_INFO, " %s",
- tvb_bytes_to_str_punct(pinfo->pool, tvb, offset, data_length, ' '));
+ col_append_fstr(pinfo->cinfo, COL_INFO, " %s", tvb_bytes_to_str_punct(pinfo->pool, tvb, offset, data_length, ' '));
}
if (fragmented) {
tvbuff_t *new_tvb = NULL;
iso15765_frame_t *iso15765_frame;
- guint16 frag_id = frag_id_low;
+ uint16_t frag_id = frag_id_low;
/* Get frame information */
- iso15765_frame = (iso15765_frame_t *)wmem_map_lookup(iso15765_frame_table,
- GUINT_TO_POINTER(iso15765_info->seq));
+ iso15765_frame = (iso15765_frame_t *)wmem_map_lookup(iso15765_frame_table, GUINT_TO_POINTER(iso15765_info->seq));
if (iso15765_frame != NULL) {
if (!(pinfo->fd->visited)) {
DISSECTOR_ASSERT(frag_id < 16);
- guint16 tmp = iso15765_frame->frag_id_high[frag_id]++;
+ uint16_t tmp = iso15765_frame->frag_id_high[frag_id]++;
/* Make sure that we assert on using more than 4096 (16*255) segments.*/
DISSECTOR_ASSERT(iso15765_frame->frag_id_high[frag_id] != 0);
frag_id += tmp * 16;
@@ -797,30 +898,47 @@ dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bu
/* Check if there is an error in conversation */
if (iso15765_info->frag_id + window < iso15765_frame->last_frag_id) {
/* Error in conversation */
- iso15765_frame->error = TRUE;
+ iso15765_frame->error = true;
}
}
if (!iso15765_frame->error) {
- gboolean save_fragmented = pinfo->fragmented;
- guint32 len = data_length;
+ bool save_fragmented = pinfo->fragmented;
+ uint32_t len = data_length;
+ uint32_t missing_bytes = 0;
fragment_head *frag_msg;
/* Check if it's the last packet */
if (!(pinfo->fd->visited)) {
- /* Update the last_frag_id */
- if (frag_id > iso15765_frame->last_frag_id) {
+ iso15765_info->bytes_used = data_length;
+
+ if (frag_id > iso15765_frame->last_frag_id || !iso15765_frame->ff_seen) {
+ if (frag_id > iso15765_frame->last_frag_id + 1) {
+ missing_bytes = (frag_id - iso15765_frame->last_frag_id - 1) * iso15765_frame->bytes_in_cf;
+ }
+ /* Update the last_frag_id */
+ iso15765_frame->ff_seen = true;
iso15765_frame->last_frag_id = frag_id;
- }
- iso15765_frame->offset += len;
- if (iso15765_frame->offset >= iso15765_frame->len) {
- iso15765_info->last = TRUE;
- iso15765_frame->complete = TRUE;
- len -= (iso15765_frame->offset - iso15765_frame->len);
+
+ /* Here we use iso15765_frame->last_byte_seen to make sure that we correctly detect
+ * the last Consecutive Frame, even if some frames were missing in the middle.
+ * Note that the last Consecutive Frame might not be the last packet,
+ * as it might arrive out of order.
+ */
+ iso15765_frame->last_byte_seen += missing_bytes;
+ iso15765_frame->last_byte_seen += len;
+ if (iso15765_frame->last_byte_seen >= iso15765_frame->len) {
+ iso15765_info->last = true;
+ len -= (iso15765_frame->last_byte_seen - iso15765_frame->len);
+
+ /* Determine how many bytes were needed to calculate padding latter. */
+ iso15765_info->bytes_used = data_length - (iso15765_frame->last_byte_seen - iso15765_frame->len);
+ }
+
}
}
- pinfo->fragmented = TRUE;
+ pinfo->fragmented = true;
/* Add fragment to fragment table */
frag_msg = fragment_add_seq_check(&iso15765_reassembly_table, tvb, offset, pinfo, iso15765_info->seq, NULL,
@@ -830,8 +948,7 @@ dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bu
&iso15765_frag_items, NULL, iso15765_tree);
if (frag_msg && frag_msg->reassembled_in != pinfo->num) {
- col_append_frame_number(pinfo, COL_INFO, " [Reassembled in #%u]",
- frag_msg->reassembled_in);
+ col_append_frame_number(pinfo, COL_INFO, " [Reassembled in #%u]", frag_msg->reassembled_in);
}
pinfo->fragmented = save_fragmented;
@@ -840,17 +957,32 @@ dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bu
if (new_tvb) {
/* This is a complete TVB to dissect */
next_tvb = new_tvb;
- complete = TRUE;
- } else {
- next_tvb = tvb_new_subset_length(tvb, offset, data_length);
+ complete = true;
}
}
}
+ /* Let us correct bytes used for last segment to identify padding. */
+ if (iso15765_info != NULL && iso15765_info->last) {
+ data_length = iso15765_info->bytes_used;
+ }
+
+ if (message_type == ISO15765_MESSAGE_TYPES_FIRST_FRAME || message_type == ISO15765_MESSAGE_TYPES_CONSECUTIVE_FRAME ||
+ message_type == ISO15765_MESSAGE_TYPES_FR_FIRST_FRAME_EXT || message_type == ISO15765_MESSAGE_TYPES_FR_CONSECUTIVE_FRAME_2) {
+ proto_tree_add_item(iso15765_tree, hf_iso15765_segment_data, tvb, offset, data_length, ENC_NA);
+ }
+
+ offset += data_length;
+
+ if (offset < tvb_captured_length(tvb)) {
+ /* Unused bytes should be filled with 0xCC padding. */
+ proto_tree_add_item(iso15765_tree, hf_iso15765_padding, tvb, offset, tvb_captured_length(tvb) - offset, ENC_NA);
+ }
+
if (next_tvb) {
iso15765data.len = frame_length;
- if (!complete || !dissector_try_payload_new(subdissector_table, next_tvb, pinfo, tree, TRUE, &iso15765data)) {
+ if (!complete || !dissector_try_payload_new(subdissector_table, next_tvb, pinfo, tree, true, &iso15765data)) {
call_data_dissector(next_tvb, pinfo, tree);
}
}
@@ -859,12 +991,11 @@ dissect_iso15765(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 bu
}
static int
-dissect_iso15765_can(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
-{
- struct can_info can_info;
+dissect_iso15765_can(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data) {
+ can_info_t can_info;
DISSECTOR_ASSERT(data);
- can_info = *((struct can_info*)data);
+ can_info = *((can_info_t*)data);
if (can_info.id & (CAN_ERR_FLAG | CAN_RTR_FLAG)) {
/* Error and RTR frames are not for us. */
@@ -886,8 +1017,7 @@ dissect_iso15765_can(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void*
}
static int
-dissect_iso15765_lin(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
-{
+dissect_iso15765_lin(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data) {
DISSECTOR_ASSERT(data);
lin_info_t *lininfo = (lin_info_t *)data;
@@ -896,20 +1026,18 @@ dissect_iso15765_lin(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void*
}
static int
-dissect_iso15765_flexray(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
-{
+dissect_iso15765_flexray(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data) {
DISSECTOR_ASSERT(data);
flexray_info_t *flexray_id = (flexray_info_t *)data;
- guint32 id = (((guint32)flexray_id->id) << 16) | (((guint32)flexray_id->cc) << 8) | flexray_id->ch;
+ uint32_t id = (((uint32_t)flexray_id->id) << 16) | (((uint32_t)flexray_id->cc) << 8) | flexray_id->ch;
return dissect_iso15765(tvb, pinfo, tree, ISO15765_TYPE_FLEXRAY, id, tvb_captured_length(tvb));
}
static int
-dissect_iso15765_ipdum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
-{
+dissect_iso15765_ipdum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data) {
DISSECTOR_ASSERT(data);
autosar_ipdu_multiplexer_info_t *ipdum_data = (autosar_ipdu_multiplexer_info_t *)data;
@@ -918,8 +1046,7 @@ dissect_iso15765_ipdum(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void
}
static int
-dissect_iso15765_pdu_transport(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
-{
+dissect_iso15765_pdu_transport(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data) {
DISSECTOR_ASSERT(data);
pdu_transport_info_t *pdu_transport_data = (pdu_transport_info_t *)data;
@@ -928,8 +1055,7 @@ dissect_iso15765_pdu_transport(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tr
}
static void
-update_config(void)
-{
+update_config(void) {
if (iso15765_handle_lin != NULL) {
dissector_delete_all("lin.frame_id", iso15765_handle_lin);
if (register_lin_diag_frames) {
@@ -953,239 +1079,83 @@ update_config(void)
}
void
-proto_register_iso15765(void)
-{
+proto_register_iso15765(void) {
uat_t *config_can_addr_mapping_uat;
uat_t *config_pdu_transport_config_uat;
static hf_register_info hf[] = {
- {
- &hf_iso15765_address,
- {
- "Address", "iso15765.address",
- FT_UINT8, BASE_HEX,
- NULL, 0,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_target_address,
- {
- "Target Address", "iso15765.target_address",
- FT_UINT16, BASE_HEX,
- NULL, 0,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_source_address,
- {
- "Source Address", "iso15765.source_address",
- FT_UINT16, BASE_HEX,
- NULL, 0,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_message_type,
- {
- "Message Type", "iso15765.message_type",
- FT_UINT8, BASE_HEX,
- VALS(iso15765_message_types), ISO15765_MESSAGE_TYPE_MASK,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_data_length,
- {
- "Data length", "iso15765.data_length",
- FT_UINT32, BASE_DEC,
- NULL, 0,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_frame_length,
- {
- "Frame length", "iso15765.frame_length",
- FT_UINT32, BASE_DEC,
- NULL, 0x0,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_sequence_number,
- {
- "Sequence number", "iso15765.sequence_number",
- FT_UINT8, BASE_HEX,
- NULL, ISO15765_MESSAGE_SEQUENCE_NUMBER_MASK,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_flow_status,
- {
- "Flow status", "iso15765.flow_status",
- FT_UINT8, BASE_HEX,
- VALS(iso15765_flow_status_types), ISO15765_MESSAGE_FLOW_STATUS_MASK,
- NULL, HFILL
- }
- },
-
- {
- &hf_iso15765_fc_bs,
- {
- "Block size", "iso15765.flow_control.bs",
- FT_UINT8, BASE_HEX,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_fc_stmin,
- {
- "Separation time minimum (ms)", "iso15765.flow_control.stmin",
- FT_UINT8, BASE_DEC,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_fc_stmin_in_us,
- {
- "Separation time minimum (µs)", "iso15765.flow_control.stmin",
- FT_UINT8, BASE_DEC,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_autosar_ack,
- {
- "Acknowledgement", "iso15765.autosar_ack.ack",
- FT_UINT8, BASE_HEX,
- NULL, ISO15765_MESSAGE_AUTOSAR_ACK_MASK,
- NULL, HFILL
- }
- },
-
- {
- &hf_iso15765_fragments,
- {
- "Message fragments", "iso15765.fragments",
- FT_NONE, BASE_NONE,
- NULL, 0x00,
- NULL, HFILL
- },
- },
- {
- &hf_iso15765_fragment,
- {
- "Message fragment", "iso15765.fragment",
- FT_FRAMENUM, BASE_NONE,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_fragment_overlap,
- {
- "Message fragment overlap", "iso15765.fragment.overlap",
- FT_BOOLEAN, 0,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_fragment_overlap_conflicts,
- {
- "Message fragment overlapping with conflicting data", "iso15765.fragment.overlap.conflicts",
- FT_BOOLEAN, 0,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_fragment_multiple_tails,
- {
- "Message has multiple tail fragments", "iso15765.fragment.multiple_tails",
- FT_BOOLEAN, 0,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_fragment_too_long_fragment,
- {
- "Message fragment too long", "iso15765.fragment.too_long_fragment",
- FT_BOOLEAN, 0, NULL,
- 0x00, NULL, HFILL
- }
- },
- {
- &hf_iso15765_fragment_error,
- {
- "Message defragmentation error", "iso15765.fragment.error",
- FT_FRAMENUM, BASE_NONE,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_fragment_count,
- {
- "Message fragment count", "iso15765.fragment.count",
- FT_UINT32, BASE_DEC,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_reassembled_in,
- {
- "Reassembled in", "iso15765.reassembled.in",
- FT_FRAMENUM, BASE_NONE,
- NULL, 0x00,
- NULL, HFILL
- }
- },
- {
- &hf_iso15765_reassembled_length,
- {
- "Reassembled length", "iso15765.reassembled.length",
- FT_UINT32, BASE_DEC,
- NULL, 0x00,
- NULL, HFILL
- }
- },
+ { &hf_iso15765_address, {
+ "Address", "iso15765.address", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL } },
+ { &hf_iso15765_target_address, {
+ "Target Address", "iso15765.target_address", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
+ { &hf_iso15765_source_address, {
+ "Source Address", "iso15765.source_address", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL } },
+ { &hf_iso15765_message_type, {
+ "Message Type", "iso15765.message_type", FT_UINT8, BASE_HEX, VALS(iso15765_message_types), ISO15765_MESSAGE_TYPE_MASK, NULL, HFILL } },
+ { &hf_iso15765_data_length_8bit, {
+ "Data length (8bit)", "iso15765.data_length_8bit", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL } },
+ { &hf_iso15765_data_length_4bit, {
+ "Data length (4bit)", "iso15765.data_length_4bit", FT_UINT8, BASE_DEC, NULL, ISO15765_MESSAGE_DATA_LENGTH_MASK, NULL, HFILL } },
+ { &hf_iso15765_frame_length_32bit, {
+ "Frame length (32bit)", "iso15765.frame_length_32bit", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+ { &hf_iso15765_frame_length_12bit, {
+ "Frame length (12bit)", "iso15765.frame_length_12bit", FT_UINT16, BASE_DEC, NULL, ISO15765_MESSAGE_FIRST_FRAME_DATA_LENGTH_MASK, NULL, HFILL } },
+ { &hf_iso15765_sequence_number, {
+ "Sequence number", "iso15765.sequence_number", FT_UINT8, BASE_HEX, NULL, ISO15765_MESSAGE_SEQUENCE_NUMBER_MASK, NULL, HFILL } },
+ { &hf_iso15765_flow_status, {
+ "Flow status", "iso15765.flow_status", FT_UINT8, BASE_HEX, VALS(iso15765_flow_status_types), ISO15765_MESSAGE_FLOW_STATUS_MASK, NULL, HFILL } },
+
+ { &hf_iso15765_fc_bs, {
+ "Block size", "iso15765.flow_control.bs", FT_UINT8, BASE_HEX, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_fc_stmin, {
+ "Separation time minimum (ms)", "iso15765.flow_control.stmin", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_fc_stmin_in_us, {
+ "Separation time minimum (µs)", "iso15765.flow_control.stmin", FT_UINT8, BASE_DEC, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_autosar_ack, {
+ "Acknowledgment", "iso15765.autosar_ack.ack", FT_UINT8, BASE_HEX, NULL, ISO15765_MESSAGE_AUTOSAR_ACK_MASK, NULL, HFILL } },
+ { &hf_iso15765_segment_data, {
+ "Segment Data", "iso15765.segment_data", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_padding, {
+ "Padding", "iso15765.padding", FT_BYTES, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+
+ { &hf_iso15765_fragments, {
+ "Message fragments", "iso15765.fragments", FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL }, },
+ { &hf_iso15765_fragment, {
+ "Message fragment", "iso15765.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_fragment_overlap, {
+ "Message fragment overlap", "iso15765.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_fragment_overlap_conflicts, {
+ "Message fragment overlapping with conflicting data", "iso15765.fragment.overlap.conflicts", FT_BOOLEAN, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_fragment_multiple_tails, {
+ "Message has multiple tail fragments", "iso15765.fragment.multiple_tails", FT_BOOLEAN, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_fragment_too_long_fragment, {
+ "Message fragment too long", "iso15765.fragment.too_long_fragment", FT_BOOLEAN, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_fragment_error, {
+ "Message defragmentation error", "iso15765.fragment.error", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_fragment_count, {
+ "Message fragment count", "iso15765.fragment.count", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_reassembled_in, {
+ "Reassembled in", "iso15765.reassembled.in", FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL } },
+ { &hf_iso15765_reassembled_length, {
+ "Reassembled length", "iso15765.reassembled.length", FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL } },
};
/* Setup protocol subtree array */
- static gint *ett[] =
- {
- &ett_iso15765,
- &ett_iso15765_fragment,
- &ett_iso15765_fragments,
- };
+ static int *ett[] = {
+ &ett_iso15765,
+ &ett_iso15765_fragment,
+ &ett_iso15765_fragments,
+ };
static ei_register_info ei[] = {
- {
- &ei_iso15765_message_type_bad,
- {
- "iso15765.message_type.bad", PI_MALFORMED,
- PI_ERROR, "Bad Message Type value", EXPFILL
- }
- },
+ { &ei_iso15765_message_type_bad, {
+ "iso15765.message_type.bad", PI_MALFORMED, PI_ERROR, "Bad Message Type value", EXPFILL } },
};
module_t *iso15765_module;
expert_module_t* expert_iso15765;
- proto_iso15765 = proto_register_protocol (
- "ISO15765 Protocol", /* name */
- "ISO 15765", /* short name */
- "iso15765" /* abbrev */
- );
+ proto_iso15765 = proto_register_protocol ( "ISO15765 Protocol", "ISO 15765", "iso15765");
register_dissector("iso15765", dissect_iso15765_lin, proto_iso15765);
expert_iso15765 = expert_register_protocol(proto_iso15765);
@@ -1200,7 +1170,7 @@ proto_register_iso15765(void)
"Addressing",
"Addressing of ISO 15765. Normal or Extended",
&addressing,
- enum_addressing, TRUE);
+ enum_addressing, true);
prefs_register_uint_preference(iso15765_module, "window",
"Window",
@@ -1223,19 +1193,19 @@ proto_register_iso15765(void)
/* UATs for config_can_addr_mapping_uat */
static uat_field_t config_can_addr_mapping_uat_fields[] = {
- UAT_FLD_BOOL(config_can_addr_mappings, extended_address, "Ext. Addr.", "Extended Addressing (TRUE), Standard Addressing (FALSE)"),
- UAT_FLD_HEX(config_can_addr_mappings, can_id, "CAN ID", "CAN ID (hex)"),
- UAT_FLD_HEX(config_can_addr_mappings, can_id_mask, "CAN ID Mask", "CAN ID Mask (hex)"),
- UAT_FLD_HEX(config_can_addr_mappings, source_addr_mask, "Source Addr Mask", "Bitmask to specify location of Source Address (hex)"),
- UAT_FLD_HEX(config_can_addr_mappings, target_addr_mask, "Target Addr Mask", "Bitmask to specify location of Target Address (hex)"),
- UAT_FLD_HEX(config_can_addr_mappings, ecu_addr_mask, "ECU Addr Mask", "Bitmask to specify location of ECU Address (hex)"),
+ UAT_FLD_BOOL(config_can_addr_mappings, extended_address, "Ext Addr (29bit)", "29bit Addressing (true), 11bit Addressing (false)"),
+ UAT_FLD_HEX(config_can_addr_mappings, can_id, "CAN ID", "CAN ID (hex)"),
+ UAT_FLD_HEX(config_can_addr_mappings, can_id_mask, "CAN ID Mask", "CAN ID Mask (hex)"),
+ UAT_FLD_HEX(config_can_addr_mappings, source_addr_mask, "Source Addr Mask", "Bitmask to specify location of Source Address (hex)"),
+ UAT_FLD_HEX(config_can_addr_mappings, target_addr_mask, "Target Addr Mask", "Bitmask to specify location of Target Address (hex)"),
+ UAT_FLD_HEX(config_can_addr_mappings, ecu_addr_mask, "ECU Addr Mask", "Bitmask to specify location of ECU Address (hex)"),
UAT_END_FIELDS
};
config_can_addr_mapping_uat = uat_new("ISO15765 CAN ID Mapping",
sizeof(config_can_addr_mapping_t), /* record size */
DATAFILE_CAN_ADDR_MAPPING, /* filename */
- TRUE, /* from profile */
+ true, /* from profile */
(void**)&config_can_addr_mappings, /* data_ptr */
&config_can_addr_mappings_num, /* numitems_ptr */
UAT_AFFECTS_DISSECTION, /* but not fields */
@@ -1262,7 +1232,7 @@ proto_register_iso15765(void)
"FlexRay Addressing",
"Addressing of FlexRay TP. 1 Byte or 2 Byte",
&flexray_addressing,
- enum_flexray_addressing, TRUE);
+ enum_flexray_addressing, true);
prefs_register_uint_preference(iso15765_module, "flexray_segment_size_limit",
"FlexRay Segment Cutoff",
@@ -1281,7 +1251,7 @@ proto_register_iso15765(void)
"I-PduM Addressing",
"Addressing of I-PduM TP. 0, 1, or 2 Bytes",
&ipdum_addressing,
- enum_ipdum_addressing, TRUE);
+ enum_ipdum_addressing, true);
prefs_register_static_text_preference(iso15765_module, "empty_pdu_transport", "", NULL);
@@ -1300,7 +1270,7 @@ proto_register_iso15765(void)
config_pdu_transport_config_uat = uat_new("ISO15765 PDU Transport Config",
sizeof(config_pdu_transport_config_t), /* record size */
DATAFILE_PDU_TRANSPORT_CONFIG, /* filename */
- TRUE, /* from profile */
+ true, /* from profile */
(void**)&config_pdu_transport_config_items, /* data_ptr */
&config_pdu_transport_config_items_num, /* numitems_ptr */
UAT_AFFECTS_DISSECTION, /* but not fields */
@@ -1317,6 +1287,7 @@ proto_register_iso15765(void)
"A table to define the PDU Transport Config", config_pdu_transport_config_uat);
+ iso15765_seq_table = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), iso15765_seq_hash_func, iso15765_seq_equal_func);
iso15765_frame_table = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), g_direct_hash, g_direct_equal);
reassembly_table_register(&iso15765_reassembly_table, &addresses_reassembly_table_functions);
@@ -1325,8 +1296,7 @@ proto_register_iso15765(void)
}
void
-proto_reg_handoff_iso15765(void)
-{
+proto_reg_handoff_iso15765(void) {
iso15765_handle_can = create_dissector_handle(dissect_iso15765_can, proto_iso15765);
iso15765_handle_lin = create_dissector_handle(dissect_iso15765_lin, proto_iso15765);
iso15765_handle_flexray = create_dissector_handle(dissect_iso15765_flexray, proto_iso15765);
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-27 02:51:12 +0000