9b08b02d8e
Trying to parse LUS and LNS files if the protocol version was "A1" led to them being marked as a malformed packets. THis is because protocol version A1 LUS and LNS files do not have the exception timer field. So to fix it, we check if the protocol version is not A1, and only if it isn't do we try to parse the exception timer field.
510 lines
20 KiB
C
510 lines
20 KiB
C
/* packet-arinc615a.c
|
|
* Routines for a615a packet disassembly
|
|
*
|
|
* Copyright 2020 Roman Koshelev
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 1998 Gerald Combs
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <epan/packet.h>
|
|
#include <epan/ptvcursor.h>
|
|
|
|
#include "packet-tftp.h"
|
|
|
|
void proto_register_a615a(void);
|
|
void proto_reg_handoff_a615a(void);
|
|
|
|
enum A615A_SUFFIX { LCI, LCL, LCS, LNA, LND, LNL, LNO, LNR, LNS, LUI, LUR, LUS };
|
|
|
|
typedef struct _string_pair {
|
|
const char *abbreviated;
|
|
const char *full;
|
|
} string_pair;
|
|
|
|
static string_pair a615a_file[] = {{"LCI", "Load Configuration Initialization"},
|
|
{"LCL", "Load Configuration List"},
|
|
{"LCS", "Load Configuration Status"},
|
|
{"LNA", "Load Downloading Answer"},
|
|
{"LND", "Load Downloading Media"},
|
|
{"LNL", "Load Downloading List"},
|
|
{"LNO", "Load Downloading Operator"},
|
|
{"LNR", "Load Downloading Request"},
|
|
{"LNS", "Load Downloading Status"},
|
|
{"LUI", "Load Upload Initialization"},
|
|
{"LUR", "Load Uploading Request"},
|
|
{"LUS", "Load Uploading Status"}};
|
|
|
|
static const value_string a615a_operation_status_codes[] = {
|
|
{0x0001, "Accepted, not yet started"},
|
|
{0x0002, "Operation in progress"},
|
|
{0x0003, "Operation completed without error"},
|
|
{0x0004, "Operation in progress, details in status description"},
|
|
{0x1000, "Operation denied, reason in status description"},
|
|
{0x1002, "Operation not supported by the target"},
|
|
{0x1003, "Operation aborted by target hardware, info in status description"},
|
|
{0x1004, "Operation aborted by target on Dataloader error message"},
|
|
{0x1005, "Operation aborted by target on operator action"},
|
|
{0x1007, "Load of this header file has failed, details in status description"},
|
|
{0, NULL}};
|
|
|
|
static int proto_a615a = -1;
|
|
|
|
static gint ett_a615a = -1;
|
|
|
|
static int hf_a615a_file_length = -1;
|
|
static int hf_a615a_protocol_version = -1;
|
|
static int hf_a615a_counter = -1;
|
|
static int hf_a615a_operation_status = -1;
|
|
static int hf_a615a_exception_timer = -1;
|
|
static int hf_a615a_estimated_time = -1;
|
|
static int hf_a615a_status_description = -1;
|
|
static int hf_a615a_load_ratio = -1;
|
|
static int hf_a615a_file_count = -1;
|
|
static int hf_a615a_file_name = -1;
|
|
static int hf_a615a_file_description = -1;
|
|
static int hf_a615a_part_number = -1;
|
|
static int hf_a615a_number_target_hardware = -1;
|
|
static int hf_a615a_literal_name = -1;
|
|
static int hf_a615a_serial_number = -1;
|
|
static int hf_a615a_part_number_count = -1;
|
|
static int hf_a615a_amendment = -1;
|
|
static int hf_a615a_designation = -1;
|
|
static int hf_a615a_user_data = -1;
|
|
static int hf_a615a_file_type = -1;
|
|
|
|
#define FIND_PORT 1001
|
|
|
|
static int proto_find = -1;
|
|
|
|
static gint ett_find = -1;
|
|
|
|
static int hf_find_opcode = -1;
|
|
static int hf_find_target_hardware_identifier = -1;
|
|
static int hf_find_target_type_name = -1;
|
|
static int hf_find_target_position = -1;
|
|
static int hf_find_literal_name = -1;
|
|
static int hf_find_manufacturer_code = -1;
|
|
static int hf_find_packet_terminator = -1;
|
|
|
|
static dissector_handle_t find_handle;
|
|
|
|
#define FIND_IRQ 1
|
|
#define FIND_IAN 2
|
|
|
|
static const value_string find_opcode_vals[] = {
|
|
{ FIND_IRQ, "Information ReQuest (IRQ)" },
|
|
{ FIND_IAN, "Information ANswer (IAN)" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static void dissect_a615a_LCL(ptvcursor_t *ptvc, packet_info *pinfo _U_)
|
|
{
|
|
guint32 th_count, pn_count;
|
|
proto_item *pi;
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_number_target_hardware, 2, ENC_BIG_ENDIAN, &th_count);
|
|
|
|
for (unsigned i = 0; i < th_count; ++i) {
|
|
pi = ptvcursor_add(ptvc, hf_a615a_literal_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_push_subtree(ptvc, pi, ett_a615a);
|
|
ptvcursor_add(ptvc, hf_a615a_serial_number, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_part_number_count, 2, ENC_BIG_ENDIAN, &pn_count);
|
|
|
|
for (unsigned j = 0; j < pn_count; ++j) {
|
|
pi = ptvcursor_add(ptvc, hf_a615a_part_number, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_push_subtree(ptvc, pi, ett_a615a);
|
|
ptvcursor_add(ptvc, hf_a615a_amendment, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_designation, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_pop_subtree(ptvc);
|
|
}
|
|
ptvcursor_pop_subtree(ptvc);
|
|
}
|
|
}
|
|
|
|
static void dissect_a615a_LUS(ptvcursor_t *ptvc, packet_info *pinfo)
|
|
{
|
|
guint32 status, file_count;
|
|
const guint8 *ratio;
|
|
const guint8 *protocol_version = NULL;
|
|
proto_item *pi;
|
|
|
|
ptvcursor_add_ret_string(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA,
|
|
pinfo->pool, &protocol_version);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN, &status);
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, ", Status: %s",
|
|
val_to_str(status, a615a_operation_status_codes, "Unknown (0x%04x)"));
|
|
ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_counter, 2, ENC_BIG_ENDIAN);
|
|
|
|
if(protocol_version && strcmp((const char*)protocol_version, "A1"))
|
|
{
|
|
ptvcursor_add(ptvc, hf_a615a_exception_timer, 2, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_estimated_time, 2, ENC_BIG_ENDIAN);
|
|
ptvcursor_add_ret_string(ptvc, hf_a615a_load_ratio, 3, ENC_ASCII | ENC_NA, pinfo->pool,
|
|
&ratio);
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, ", Load Ratio: %s %%", ratio);
|
|
pi = ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
|
|
|
|
ptvcursor_push_subtree(ptvc, pi, ett_a615a);
|
|
for (unsigned i = 0; i < file_count; ++i) {
|
|
pi = ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_push_subtree(ptvc, pi, ett_a615a);
|
|
ptvcursor_add(ptvc, hf_a615a_part_number, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_load_ratio, 3, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_pop_subtree(ptvc);
|
|
}
|
|
ptvcursor_pop_subtree(ptvc);
|
|
}
|
|
|
|
static void dissect_a615a_LCS(ptvcursor_t *ptvc, packet_info *pinfo)
|
|
{
|
|
guint32 status;
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add(ptvc, hf_a615a_counter, 2, ENC_BIG_ENDIAN);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN, &status);
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, ", Status: %s",
|
|
val_to_str(status, a615a_operation_status_codes, "Unknown (0x%04x)"));
|
|
ptvcursor_add(ptvc, hf_a615a_exception_timer, 2, ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_estimated_time, 2, ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static void dissect_a615a_LUI_LCI_LND_LNO(ptvcursor_t *ptvc, packet_info *pinfo)
|
|
{
|
|
guint32 status;
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN, &status);
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, ", Status: %s",
|
|
val_to_str(status, a615a_operation_status_codes, "Unknown (0x%04x)"));
|
|
ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static void dissect_a615a_LUR(ptvcursor_t *ptvc, packet_info *pinfo _U_)
|
|
{
|
|
guint32 file_count;
|
|
proto_item *pi;
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
|
|
for (unsigned i = 0; i < file_count; ++i) {
|
|
pi = ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_push_subtree(ptvc, pi, ett_a615a);
|
|
ptvcursor_add(ptvc, hf_a615a_part_number, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_pop_subtree(ptvc);
|
|
}
|
|
}
|
|
|
|
static void dissect_a615a_LNL(ptvcursor_t *ptvc, packet_info *pinfo _U_)
|
|
{
|
|
guint32 file_count;
|
|
proto_item *pi;
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
|
|
for (unsigned i = 0; i < file_count; ++i) {
|
|
pi = ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_push_subtree(ptvc, pi, ett_a615a);
|
|
ptvcursor_add(ptvc, hf_a615a_file_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_pop_subtree(ptvc);
|
|
}
|
|
}
|
|
|
|
static void dissect_a615a_LNR(ptvcursor_t *ptvc, packet_info *pinfo _U_)
|
|
{
|
|
guint32 file_count;
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
|
|
for (unsigned i = 0; i < file_count; ++i) {
|
|
ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
}
|
|
ptvcursor_add(ptvc, hf_a615a_user_data, 1, ENC_NA);
|
|
}
|
|
|
|
static void dissect_a615a_LNS(ptvcursor_t *ptvc, packet_info *pinfo)
|
|
{
|
|
guint32 status, file_count;
|
|
proto_item *pi;
|
|
const guint8 *protocol_version = NULL;
|
|
|
|
ptvcursor_add_ret_string(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA,
|
|
pinfo->pool, &protocol_version);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN, &status);
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, ", Status: %s",
|
|
val_to_str(status, a615a_operation_status_codes, "Unknown (0x%04x)"));
|
|
ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_counter, 2, ENC_BIG_ENDIAN);
|
|
|
|
if (protocol_version && strcmp((const char*)protocol_version, "A1"))
|
|
{
|
|
ptvcursor_add(ptvc, hf_a615a_exception_timer, 2, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_estimated_time, 2, ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_load_ratio, 3, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
|
|
|
|
for (unsigned i = 0; i < file_count; ++i) {
|
|
pi = ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_push_subtree(ptvc, pi, ett_a615a);
|
|
ptvcursor_add(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN);
|
|
ptvcursor_add(ptvc, hf_a615a_file_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
ptvcursor_pop_subtree(ptvc);
|
|
}
|
|
}
|
|
|
|
static void dissect_a615a_LNA(ptvcursor_t *ptvc, packet_info *pinfo _U_)
|
|
{
|
|
guint32 file_count;
|
|
|
|
ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
|
|
for (unsigned i = 0; i < file_count; ++i) {
|
|
ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
|
|
}
|
|
}
|
|
|
|
static void dissect_a615a_protocol_file(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
int suffix)
|
|
{
|
|
proto_item *ti;
|
|
ti = proto_tree_add_item(tree, proto_a615a, tvb, 0, -1, ENC_NA);
|
|
proto_tree *a615a_tree = proto_item_add_subtree(ti, ett_a615a);
|
|
ti = proto_tree_add_string(a615a_tree, hf_a615a_file_type, tvb, 0, 0, a615a_file[suffix].full);
|
|
proto_item_set_generated(ti);
|
|
|
|
ptvcursor_t *ptvc = ptvcursor_new(pinfo->pool, a615a_tree, tvb, 0);
|
|
ptvcursor_add(ptvc, hf_a615a_file_length, 4, ENC_BIG_ENDIAN);
|
|
|
|
switch (suffix) {
|
|
case LUI:
|
|
case LCI:
|
|
case LND:
|
|
case LNO: {
|
|
dissect_a615a_LUI_LCI_LND_LNO(ptvc, pinfo);
|
|
break;
|
|
}
|
|
case LCL: {
|
|
dissect_a615a_LCL(ptvc, pinfo);
|
|
break;
|
|
}
|
|
case LCS: {
|
|
dissect_a615a_LCS(ptvc, pinfo);
|
|
break;
|
|
}
|
|
case LNA: {
|
|
dissect_a615a_LNA(ptvc, pinfo);
|
|
break;
|
|
}
|
|
case LNL: {
|
|
dissect_a615a_LNL(ptvc, pinfo);
|
|
break;
|
|
}
|
|
case LNR: {
|
|
dissect_a615a_LNR(ptvc, pinfo);
|
|
break;
|
|
}
|
|
case LNS: {
|
|
dissect_a615a_LNS(ptvc, pinfo);
|
|
break;
|
|
}
|
|
case LUR: {
|
|
dissect_a615a_LUR(ptvc, pinfo);
|
|
break;
|
|
}
|
|
case LUS: {
|
|
dissect_a615a_LUS(ptvc, pinfo);
|
|
break;
|
|
}
|
|
default: {
|
|
DISSECTOR_ASSERT_NOT_REACHED();
|
|
break;
|
|
}
|
|
}
|
|
ptvcursor_free(ptvc);
|
|
}
|
|
|
|
static gboolean dissect_a615a_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
|
|
{
|
|
guint psize = tvb_captured_length(tvb);
|
|
if (psize < 6) return FALSE;
|
|
if ((tvb_get_ntohl(tvb, 0) != psize) || ((gchar)tvb_get_guint8(tvb, 4) != 'A')) return FALSE;
|
|
|
|
const char *filename = ((struct tftpinfo *)data)->filename;
|
|
if (filename == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
for (unsigned i = 0; i < array_length(a615a_file); ++i) {
|
|
if (g_str_has_suffix(filename, a615a_file[i].abbreviated)) {
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "A615a");
|
|
col_add_str(pinfo->cinfo, COL_INFO, filename);
|
|
dissect_a615a_protocol_file(tvb, pinfo, tree, i);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static int dissect_find(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
|
|
{
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FIND");
|
|
proto_item *ti = proto_tree_add_item(tree, proto_find, tvb, 0, -1, ENC_NA);
|
|
proto_tree *find_tree = proto_item_add_subtree(ti, ett_find);
|
|
|
|
ptvcursor_t *ptvc = ptvcursor_new(pinfo->pool, find_tree, tvb, 0);
|
|
|
|
guint32 opcode;
|
|
ptvcursor_add_ret_uint(ptvc, hf_find_opcode, 2, ENC_BIG_ENDIAN, &opcode);
|
|
col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", val_to_str(opcode, find_opcode_vals, "Unknown (0x%04x)"));
|
|
|
|
if (opcode == FIND_IAN) {
|
|
ptvcursor_add(ptvc, hf_find_target_hardware_identifier, -1, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add(ptvc, hf_find_target_type_name, -1, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add(ptvc, hf_find_target_position, -1, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add(ptvc, hf_find_literal_name, -1, ENC_ASCII | ENC_NA);
|
|
ptvcursor_add(ptvc, hf_find_manufacturer_code, -1, ENC_ASCII | ENC_NA);
|
|
} else {
|
|
ptvcursor_advance(ptvc, 1);
|
|
}
|
|
ptvcursor_add(ptvc, hf_find_packet_terminator, 1, ENC_NA);
|
|
|
|
ptvcursor_free(ptvc);
|
|
|
|
return tvb_captured_length(tvb);
|
|
}
|
|
|
|
void proto_register_a615a(void)
|
|
{
|
|
static hf_register_info hf[] = {
|
|
{&hf_a615a_file_length,
|
|
{"File Length", "a615a.file_length", FT_UINT32, BASE_DEC, NULL, 0x0,
|
|
"A615a Protocol File Length", HFILL}},
|
|
{&hf_a615a_protocol_version,
|
|
{"Protocol Version", "a615a.protocol_version", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a Protocol File Version", HFILL}},
|
|
{&hf_a615a_counter,
|
|
{"Counter", "a615a.counter", FT_UINT16, BASE_DEC, NULL, 0x0, "A615a Protocol Counter",
|
|
HFILL}},
|
|
{&hf_a615a_operation_status,
|
|
{"Status Code", "a615a.status_code", FT_UINT16, BASE_DEC,
|
|
VALS(a615a_operation_status_codes), 0x0, NULL, HFILL}},
|
|
{&hf_a615a_exception_timer,
|
|
{"Exception Timer", "a615a.exception_timer", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
"A615a Exception Timer", HFILL}},
|
|
{&hf_a615a_estimated_time,
|
|
{"Estimated Time", "a615a.estimated_time", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
"A615a Estimated Time", HFILL}},
|
|
{&hf_a615a_status_description,
|
|
{"Status Description", "a615a.status", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a Status Description", HFILL}},
|
|
{&hf_a615a_load_ratio,
|
|
{"Load Ratio", "a615a.load_ratio", FT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a Load Operation Ratio", HFILL}},
|
|
{&hf_a615a_file_count,
|
|
{"File Count", "a615a.file_count", FT_UINT16, BASE_DEC, NULL, 0x0, "A615a File Count",
|
|
HFILL}},
|
|
{&hf_a615a_file_name,
|
|
{"File Name", "a615a.file_name", FT_UINT_STRING, BASE_NONE, NULL, 0x0, "A615a File Name",
|
|
HFILL}},
|
|
{&hf_a615a_file_description,
|
|
{"File Description", "a615a.file_description", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a File Description", HFILL}},
|
|
{&hf_a615a_part_number,
|
|
{"Part Number", "a615a.part_number", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a Part Number", HFILL}},
|
|
{&hf_a615a_number_target_hardware,
|
|
{"Number of Target Hardware", "a615a.num_hardware", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
"A615a Number of Target Hardware", HFILL}},
|
|
{&hf_a615a_literal_name,
|
|
{"Literal Name", "a615a.literal_name", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a Literal Name", HFILL}},
|
|
{&hf_a615a_serial_number,
|
|
{"Serial Number", "a615a.serial_number", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a Serial Number", HFILL}},
|
|
{&hf_a615a_part_number_count,
|
|
{"Part Number Count", "a615a.num_parts", FT_UINT16, BASE_DEC, NULL, 0x0,
|
|
"A615a Part Number Count", HFILL}},
|
|
{&hf_a615a_amendment,
|
|
{"Amendment", "a615a.amendment", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a Amendment", HFILL}},
|
|
{&hf_a615a_designation,
|
|
{"Designation", "a615a.designation", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
|
|
"A615a Designation", HFILL}},
|
|
{&hf_a615a_user_data,
|
|
{"User Data", "a615a.user_data", FT_UINT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}},
|
|
{&hf_a615a_file_type,
|
|
{"Type", "a615a.type", FT_STRINGZ, BASE_NONE, NULL, 0x0, "A615a File type", HFILL}},
|
|
};
|
|
|
|
static gint *ett[] = {&ett_a615a};
|
|
|
|
proto_a615a = proto_register_protocol("Arinc 615a Protocol", "A615a", "a615a");
|
|
proto_register_field_array(proto_a615a, hf, array_length(hf));
|
|
proto_register_subtree_array(ett, array_length(ett));
|
|
|
|
static hf_register_info hf_find[] = {
|
|
{&hf_find_opcode,
|
|
{"Opcode", "find.opcode", FT_UINT16, BASE_DEC, VALS(find_opcode_vals), 0x0,
|
|
"FIND Opcode", HFILL}},
|
|
{&hf_find_target_hardware_identifier,
|
|
{"Target Hardware Identifier", "find.target_hardware_identifier", FT_STRINGZ,
|
|
BASE_NONE, NULL, 0x0, "FIND Target Hardware Identifier", HFILL}},
|
|
{&hf_find_target_type_name,
|
|
{"Target Type Name", "find.target_type_name", FT_STRINGZ, BASE_NONE, NULL, 0x0,
|
|
"FIND Target Type Name", HFILL}},
|
|
{&hf_find_target_position,
|
|
{"Target Position", "find.target_position", FT_STRINGZ, BASE_NONE, NULL, 0x0,
|
|
"FIND Target Position", HFILL}},
|
|
{&hf_find_literal_name,
|
|
{"Literal Name", "find.literal_name", FT_STRINGZ, BASE_NONE, NULL, 0x0,
|
|
"FIND Literal Name", HFILL}},
|
|
{&hf_find_manufacturer_code,
|
|
{"Manufacturer Code", "find.manufacturer_code", FT_STRINGZ, BASE_NONE, NULL, 0x0,
|
|
"FIND Manufacturer Code", HFILL}},
|
|
{&hf_find_packet_terminator,
|
|
{"Packet terminator", "find.packet_terminator", FT_UINT8, BASE_HEX, NULL, 0x0,
|
|
"FIND Packet terminator", HFILL}}
|
|
};
|
|
|
|
static gint *etts_find[] = {&ett_find};
|
|
|
|
proto_find = proto_register_protocol("Find Identification of Network Devices", "FIND", "find");
|
|
proto_register_field_array(proto_find, hf_find, array_length(hf_find));
|
|
proto_register_subtree_array(etts_find, array_length(etts_find));
|
|
find_handle = register_dissector("find", dissect_find, proto_find);
|
|
}
|
|
|
|
void proto_reg_handoff_a615a(void)
|
|
{
|
|
heur_dissector_add("tftp", dissect_a615a_heur, "Arinc 615a Protocol over TFTP", "a615a", proto_a615a,
|
|
HEURISTIC_ENABLE);
|
|
dissector_add_uint_with_preference("udp.port", FIND_PORT, find_handle);
|
|
}
|
|
|
|
/*
|
|
* 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:
|
|
*/
|