epan/dissectors/packet-arinc615a.c

   1 /* packet-arinc615a.c
   2  * Routines for a615a packet disassembly
   3  *
   4  * Copyright 2020 Roman Koshelev
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * SPDX-License-Identifier: GPL-2.0-or-later
  11  */
  12
  13 #include "config.h"
  14
  15 #include <epan/packet.h>
  16 #include <epan/ptvcursor.h>
  17
  18 #include "packet-tftp.h"
  19
  20 void proto_register_a615a(void);
  21 void proto_reg_handoff_a615a(void);
  22
  23 enum A615A_SUFFIX { LCI, LCL, LCS, LNA, LND, LNL, LNO, LNR, LNS, LUI, LUR, LUS };
  24
  25 typedef struct _string_pair {
  26     const char *abbreviated;
  27     const char *full;
  28 } string_pair;
  29
  30 static string_pair a615a_file[] = {{"LCI", "Load Configuration Initialization"},
  31                                    {"LCL", "Load Configuration List"},
  32                                    {"LCS", "Load Configuration Status"},
  33                                    {"LNA", "Load Downloading Answer"},
  34                                    {"LND", "Load Downloading Media"},
  35                                    {"LNL", "Load Downloading List"},
  36                                    {"LNO", "Load Downloading Operator"},
  37                                    {"LNR", "Load Downloading Request"},
  38                                    {"LNS", "Load Downloading Status"},
  39                                    {"LUI", "Load Upload Initialization"},
  40                                    {"LUR", "Load Uploading Request"},
  41                                    {"LUS", "Load Uploading Status"}};
  42
  43 static const value_string a615a_operation_status_codes[] = {
  44     {0x0001, "Accepted, not yet started"},
  45     {0x0002, "Operation in progress"},
  46     {0x0003, "Operation completed without error"},
  47     {0x0004, "Operation in progress, details in status description"},
  48     {0x1000, "Operation denied, reason in status description"},
  49     {0x1002, "Operation not supported by the target"},
  50     {0x1003, "Operation aborted by target hardware, info in status description"},
  51     {0x1004, "Operation aborted by target on Dataloader error message"},
  52     {0x1005, "Operation aborted by target on operator action"},
  53     {0x1007, "Load of this header file has failed, details in status description"},
  54     {0, NULL}};
  55
  56 static int proto_a615a;
  57
  58 static int ett_a615a;
  59
  60 static int hf_a615a_file_length;
  61 static int hf_a615a_protocol_version;
  62 static int hf_a615a_counter;
  63 static int hf_a615a_operation_status;
  64 static int hf_a615a_exception_timer;
  65 static int hf_a615a_estimated_time;
  66 static int hf_a615a_status_description;
  67 static int hf_a615a_load_ratio;
  68 static int hf_a615a_file_count;
  69 static int hf_a615a_file_name;
  70 static int hf_a615a_file_description;
  71 static int hf_a615a_part_number;
  72 static int hf_a615a_number_target_hardware;
  73 static int hf_a615a_literal_name;
  74 static int hf_a615a_serial_number;
  75 static int hf_a615a_part_number_count;
  76 static int hf_a615a_amendment;
  77 static int hf_a615a_designation;
  78 static int hf_a615a_user_data;
  79 static int hf_a615a_file_type;
  80
  81 #define FIND_PORT 1001
  82
  83 static int proto_find;
  84
  85 static int ett_find;
  86
  87 static int hf_find_opcode;
  88 static int hf_find_target_hardware_identifier;
  89 static int hf_find_target_type_name;
  90 static int hf_find_target_position;
  91 static int hf_find_literal_name;
  92 static int hf_find_manufacturer_code;
  93 static int hf_find_packet_terminator;
  94
  95 static dissector_handle_t find_handle;
  96
  97 #define FIND_IRQ 1
  98 #define FIND_IAN 2
  99
 100 static const value_string find_opcode_vals[] = {
 101   { FIND_IRQ, "Information ReQuest (IRQ)" },
 102   { FIND_IAN, "Information ANswer (IAN)" },
 103   { 0, NULL }
 104 };
 105
 106 static void dissect_a615a_LCL(ptvcursor_t *ptvc, packet_info *pinfo _U_)
 107 {
 108     uint32_t th_count, pn_count;
 109     proto_item *pi;
 110
 111     ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
 112     ptvcursor_add_ret_uint(ptvc, hf_a615a_number_target_hardware, 2, ENC_BIG_ENDIAN, &th_count);
 113
 114     for (unsigned i = 0; i < th_count; ++i) {
 115         pi = ptvcursor_add(ptvc, hf_a615a_literal_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 116         ptvcursor_push_subtree(ptvc, pi, ett_a615a);
 117         ptvcursor_add(ptvc, hf_a615a_serial_number, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 118         ptvcursor_add_ret_uint(ptvc, hf_a615a_part_number_count, 2, ENC_BIG_ENDIAN, &pn_count);
 119
 120         for (unsigned j = 0; j < pn_count; ++j) {
 121             pi = ptvcursor_add(ptvc, hf_a615a_part_number, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 122             ptvcursor_push_subtree(ptvc, pi, ett_a615a);
 123             ptvcursor_add(ptvc, hf_a615a_amendment, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 124             ptvcursor_add(ptvc, hf_a615a_designation, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 125             ptvcursor_pop_subtree(ptvc);
 126         }
 127         ptvcursor_pop_subtree(ptvc);
 128     }
 129 }
 130
 131 static void dissect_a615a_LUS(ptvcursor_t *ptvc, packet_info *pinfo)
 132 {
 133     uint32_t status, file_count;
 134     const uint8_t *ratio;
 135     const uint8_t *protocol_version = NULL;
 136     proto_item *pi;
 137
 138     ptvcursor_add_ret_string(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA,
 139                             pinfo->pool, &protocol_version);
 140     ptvcursor_add_ret_uint(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN, &status);
 141     col_append_fstr(pinfo->cinfo, COL_INFO, ", Status: %s",
 142                     val_to_str(status, a615a_operation_status_codes, "Unknown (0x%04x)"));
 143     ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 144     ptvcursor_add(ptvc, hf_a615a_counter, 2, ENC_BIG_ENDIAN);
 145
 146     if(protocol_version && strcmp((const char*)protocol_version, "A1"))
 147     {
 148         ptvcursor_add(ptvc, hf_a615a_exception_timer, 2, ENC_BIG_ENDIAN);
 149     }
 150
 151     ptvcursor_add(ptvc, hf_a615a_estimated_time, 2, ENC_BIG_ENDIAN);
 152     ptvcursor_add_ret_string(ptvc, hf_a615a_load_ratio, 3, ENC_ASCII | ENC_NA, pinfo->pool,
 153                              &ratio);
 154     col_append_fstr(pinfo->cinfo, COL_INFO, ", Load Ratio: %s %%", ratio);
 155     pi = ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
 156
 157     ptvcursor_push_subtree(ptvc, pi, ett_a615a);
 158     for (unsigned i = 0; i < file_count; ++i) {
 159         pi = ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 160         ptvcursor_push_subtree(ptvc, pi, ett_a615a);
 161         ptvcursor_add(ptvc, hf_a615a_part_number, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 162         ptvcursor_add(ptvc, hf_a615a_load_ratio, 3, ENC_ASCII | ENC_NA);
 163         ptvcursor_add(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN);
 164         ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 165         ptvcursor_pop_subtree(ptvc);
 166     }
 167     ptvcursor_pop_subtree(ptvc);
 168 }
 169
 170 static void dissect_a615a_LCS(ptvcursor_t *ptvc, packet_info *pinfo)
 171 {
 172     uint32_t status;
 173
 174     ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
 175     ptvcursor_add(ptvc, hf_a615a_counter, 2, ENC_BIG_ENDIAN);
 176     ptvcursor_add_ret_uint(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN, &status);
 177     col_append_fstr(pinfo->cinfo, COL_INFO, ", Status: %s",
 178                     val_to_str(status, a615a_operation_status_codes, "Unknown (0x%04x)"));
 179     ptvcursor_add(ptvc, hf_a615a_exception_timer, 2, ENC_BIG_ENDIAN);
 180     ptvcursor_add(ptvc, hf_a615a_estimated_time, 2, ENC_BIG_ENDIAN);
 181     ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 182 }
 183
 184 static void dissect_a615a_LUI_LCI_LND_LNO(ptvcursor_t *ptvc, packet_info *pinfo)
 185 {
 186     uint32_t status;
 187
 188     ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
 189     ptvcursor_add_ret_uint(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN, &status);
 190     col_append_fstr(pinfo->cinfo, COL_INFO, ", Status: %s",
 191                     val_to_str(status, a615a_operation_status_codes, "Unknown (0x%04x)"));
 192     ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 193 }
 194
 195 static void dissect_a615a_LUR(ptvcursor_t *ptvc, packet_info *pinfo _U_)
 196 {
 197     uint32_t file_count;
 198     proto_item *pi;
 199
 200     ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
 201     ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
 202     for (unsigned i = 0; i < file_count; ++i) {
 203         pi = ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 204         ptvcursor_push_subtree(ptvc, pi, ett_a615a);
 205         ptvcursor_add(ptvc, hf_a615a_part_number, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 206         ptvcursor_pop_subtree(ptvc);
 207     }
 208 }
 209
 210 static void dissect_a615a_LNL(ptvcursor_t *ptvc, packet_info *pinfo _U_)
 211 {
 212     uint32_t file_count;
 213     proto_item *pi;
 214
 215     ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
 216     ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
 217     for (unsigned i = 0; i < file_count; ++i) {
 218         pi = ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 219         ptvcursor_push_subtree(ptvc, pi, ett_a615a);
 220         ptvcursor_add(ptvc, hf_a615a_file_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 221         ptvcursor_pop_subtree(ptvc);
 222     }
 223 }
 224
 225 static void dissect_a615a_LNR(ptvcursor_t *ptvc, packet_info *pinfo _U_)
 226 {
 227     uint32_t file_count;
 228
 229     ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
 230     ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
 231     for (unsigned i = 0; i < file_count; ++i) {
 232         ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 233     }
 234     ptvcursor_add(ptvc, hf_a615a_user_data, 1, ENC_NA);
 235 }
 236
 237 static void dissect_a615a_LNS(ptvcursor_t *ptvc, packet_info *pinfo)
 238 {
 239     uint32_t status, file_count;
 240     proto_item *pi;
 241     const uint8_t *protocol_version = NULL;
 242
 243     ptvcursor_add_ret_string(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA,
 244                             pinfo->pool, &protocol_version);
 245     ptvcursor_add_ret_uint(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN, &status);
 246     col_append_fstr(pinfo->cinfo, COL_INFO, ", Status: %s",
 247                     val_to_str(status, a615a_operation_status_codes, "Unknown (0x%04x)"));
 248     ptvcursor_add(ptvc, hf_a615a_status_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 249     ptvcursor_add(ptvc, hf_a615a_counter, 2, ENC_BIG_ENDIAN);
 250
 251     if (protocol_version && strcmp((const char*)protocol_version, "A1"))
 252     {
 253         ptvcursor_add(ptvc, hf_a615a_exception_timer, 2, ENC_BIG_ENDIAN);
 254     }
 255
 256     ptvcursor_add(ptvc, hf_a615a_estimated_time, 2, ENC_BIG_ENDIAN);
 257     ptvcursor_add(ptvc, hf_a615a_load_ratio, 3, ENC_ASCII | ENC_NA);
 258     ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
 259
 260     for (unsigned i = 0; i < file_count; ++i) {
 261         pi = ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 262         ptvcursor_push_subtree(ptvc, pi, ett_a615a);
 263         ptvcursor_add(ptvc, hf_a615a_operation_status, 2, ENC_BIG_ENDIAN);
 264         ptvcursor_add(ptvc, hf_a615a_file_description, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 265         ptvcursor_pop_subtree(ptvc);
 266     }
 267 }
 268
 269 static void dissect_a615a_LNA(ptvcursor_t *ptvc, packet_info *pinfo _U_)
 270 {
 271     uint32_t file_count;
 272
 273     ptvcursor_add(ptvc, hf_a615a_protocol_version, 2, ENC_ASCII | ENC_NA);
 274     ptvcursor_add_ret_uint(ptvc, hf_a615a_file_count, 2, ENC_BIG_ENDIAN, &file_count);
 275     for (unsigned i = 0; i < file_count; ++i) {
 276         ptvcursor_add(ptvc, hf_a615a_file_name, 1, ENC_ASCII | ENC_BIG_ENDIAN);
 277     }
 278 }
 279
 280 static void dissect_a615a_protocol_file(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 281                                         int suffix)
 282 {
 283     proto_item *ti;
 284     ti = proto_tree_add_item(tree, proto_a615a, tvb, 0, -1, ENC_NA);
 285     proto_tree *a615a_tree = proto_item_add_subtree(ti, ett_a615a);
 286     ti = proto_tree_add_string(a615a_tree, hf_a615a_file_type, tvb, 0, 0, a615a_file[suffix].full);
 287     proto_item_set_generated(ti);
 288
 289     ptvcursor_t *ptvc = ptvcursor_new(pinfo->pool, a615a_tree, tvb, 0);
 290     ptvcursor_add(ptvc, hf_a615a_file_length, 4, ENC_BIG_ENDIAN);
 291
 292     switch (suffix) {
 293         case LUI:
 294         case LCI:
 295         case LND:
 296         case LNO: {
 297             dissect_a615a_LUI_LCI_LND_LNO(ptvc, pinfo);
 298             break;
 299         }
 300         case LCL: {
 301             dissect_a615a_LCL(ptvc, pinfo);
 302             break;
 303         }
 304         case LCS: {
 305             dissect_a615a_LCS(ptvc, pinfo);
 306             break;
 307         }
 308         case LNA: {
 309             dissect_a615a_LNA(ptvc, pinfo);
 310             break;
 311         }
 312         case LNL: {
 313             dissect_a615a_LNL(ptvc, pinfo);
 314             break;
 315         }
 316         case LNR: {
 317             dissect_a615a_LNR(ptvc, pinfo);
 318             break;
 319         }
 320         case LNS: {
 321             dissect_a615a_LNS(ptvc, pinfo);
 322             break;
 323         }
 324         case LUR: {
 325             dissect_a615a_LUR(ptvc, pinfo);
 326             break;
 327         }
 328         case LUS: {
 329             dissect_a615a_LUS(ptvc, pinfo);
 330             break;
 331         }
 332         default: {
 333             DISSECTOR_ASSERT_NOT_REACHED();
 334             break;
 335         }
 336     }
 337     ptvcursor_free(ptvc);
 338 }
 339
 340 static bool dissect_a615a_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 341 {
 342     unsigned psize = tvb_captured_length(tvb);
 343     if (psize < 6) return false;
 344     if ((tvb_get_ntohl(tvb, 0) != psize) || ((char)tvb_get_uint8(tvb, 4) != 'A')) return false;
 345
 346     const char *filename = ((struct tftpinfo *)data)->filename;
 347     if (filename == NULL) {
 348       return false;
 349     }
 350
 351     for (unsigned i = 0; i < array_length(a615a_file); ++i) {
 352         if (g_str_has_suffix(filename, a615a_file[i].abbreviated)) {
 353             col_set_str(pinfo->cinfo, COL_PROTOCOL, "A615a");
 354             col_add_str(pinfo->cinfo, COL_INFO, filename);
 355             dissect_a615a_protocol_file(tvb, pinfo, tree, i);
 356             return true;
 357         }
 358     }
 359     return false;
 360 }
 361
 362 static int dissect_find(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
 363 {
 364     col_set_str(pinfo->cinfo, COL_PROTOCOL, "FIND");
 365     proto_item *ti = proto_tree_add_item(tree, proto_find, tvb, 0, -1, ENC_NA);
 366     proto_tree *find_tree = proto_item_add_subtree(ti, ett_find);
 367
 368     ptvcursor_t *ptvc = ptvcursor_new(pinfo->pool, find_tree, tvb, 0);
 369
 370     uint32_t opcode;
 371     ptvcursor_add_ret_uint(ptvc, hf_find_opcode, 2, ENC_BIG_ENDIAN, &opcode);
 372     col_append_fstr(pinfo->cinfo, COL_INFO, ", %s", val_to_str(opcode, find_opcode_vals, "Unknown (0x%04x)"));
 373
 374     if (opcode == FIND_IAN) {
 375         ptvcursor_add(ptvc, hf_find_target_hardware_identifier, -1, ENC_ASCII | ENC_NA);
 376         ptvcursor_add(ptvc, hf_find_target_type_name, -1, ENC_ASCII | ENC_NA);
 377         ptvcursor_add(ptvc, hf_find_target_position, -1, ENC_ASCII | ENC_NA);
 378         ptvcursor_add(ptvc, hf_find_literal_name, -1, ENC_ASCII | ENC_NA);
 379         ptvcursor_add(ptvc, hf_find_manufacturer_code, -1, ENC_ASCII | ENC_NA);
 380     } else {
 381         ptvcursor_advance(ptvc, 1);
 382     }
 383     ptvcursor_add(ptvc, hf_find_packet_terminator, 1, ENC_NA);
 384
 385     ptvcursor_free(ptvc);
 386
 387     return tvb_captured_length(tvb);
 388 }
 389
 390 void proto_register_a615a(void)
 391 {
 392     static hf_register_info hf[] = {
 393         {&hf_a615a_file_length,
 394          {"File Length", "a615a.file_length", FT_UINT32, BASE_DEC, NULL, 0x0,
 395           "A615a Protocol File Length", HFILL}},
 396         {&hf_a615a_protocol_version,
 397          {"Protocol Version", "a615a.protocol_version", FT_STRING, BASE_NONE, NULL, 0x0,
 398           "A615a Protocol File Version", HFILL}},
 399         {&hf_a615a_counter,
 400          {"Counter", "a615a.counter", FT_UINT16, BASE_DEC, NULL, 0x0, "A615a Protocol Counter",
 401           HFILL}},
 402         {&hf_a615a_operation_status,
 403          {"Status Code", "a615a.status_code", FT_UINT16, BASE_DEC,
 404           VALS(a615a_operation_status_codes), 0x0, NULL, HFILL}},
 405         {&hf_a615a_exception_timer,
 406          {"Exception Timer", "a615a.exception_timer", FT_UINT16, BASE_DEC, NULL, 0x0,
 407           "A615a Exception Timer", HFILL}},
 408         {&hf_a615a_estimated_time,
 409          {"Estimated Time", "a615a.estimated_time", FT_UINT16, BASE_DEC, NULL, 0x0,
 410           "A615a Estimated Time", HFILL}},
 411         {&hf_a615a_status_description,
 412          {"Status Description", "a615a.status", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
 413           "A615a Status Description", HFILL}},
 414         {&hf_a615a_load_ratio,
 415          {"Load Ratio", "a615a.load_ratio", FT_STRING, BASE_NONE, NULL, 0x0,
 416           "A615a Load Operation Ratio", HFILL}},
 417         {&hf_a615a_file_count,
 418          {"File Count", "a615a.file_count", FT_UINT16, BASE_DEC, NULL, 0x0, "A615a File Count",
 419           HFILL}},
 420         {&hf_a615a_file_name,
 421          {"File Name", "a615a.file_name", FT_UINT_STRING, BASE_NONE, NULL, 0x0, "A615a File Name",
 422           HFILL}},
 423         {&hf_a615a_file_description,
 424          {"File Description", "a615a.file_description", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
 425           "A615a File Description", HFILL}},
 426         {&hf_a615a_part_number,
 427          {"Part Number", "a615a.part_number", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
 428           "A615a Part Number", HFILL}},
 429         {&hf_a615a_number_target_hardware,
 430          {"Number of Target Hardware", "a615a.num_hardware", FT_UINT16, BASE_DEC, NULL, 0x0,
 431           "A615a Number of Target Hardware", HFILL}},
 432         {&hf_a615a_literal_name,
 433          {"Literal Name", "a615a.literal_name", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
 434           "A615a Literal Name", HFILL}},
 435         {&hf_a615a_serial_number,
 436          {"Serial Number", "a615a.serial_number", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
 437           "A615a Serial Number", HFILL}},
 438         {&hf_a615a_part_number_count,
 439          {"Part Number Count", "a615a.num_parts", FT_UINT16, BASE_DEC, NULL, 0x0,
 440           "A615a Part Number Count", HFILL}},
 441         {&hf_a615a_amendment,
 442          {"Amendment", "a615a.amendment", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
 443           "A615a Amendment", HFILL}},
 444         {&hf_a615a_designation,
 445          {"Designation", "a615a.designation", FT_UINT_STRING, BASE_NONE, NULL, 0x0,
 446           "A615a Designation", HFILL}},
 447         {&hf_a615a_user_data,
 448          {"User Data", "a615a.user_data", FT_UINT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}},
 449         {&hf_a615a_file_type,
 450          {"Type", "a615a.type", FT_STRINGZ, BASE_NONE, NULL, 0x0, "A615a File type", HFILL}},
 451     };
 452
 453     static int *ett[] = {&ett_a615a};
 454
 455     proto_a615a = proto_register_protocol("Arinc 615a Protocol", "A615a", "a615a");
 456     proto_register_field_array(proto_a615a, hf, array_length(hf));
 457     proto_register_subtree_array(ett, array_length(ett));
 458
 459     static hf_register_info hf_find[] = {
 460         {&hf_find_opcode,
 461          {"Opcode", "find.opcode", FT_UINT16, BASE_DEC, VALS(find_opcode_vals), 0x0,
 462           "FIND Opcode", HFILL}},
 463         {&hf_find_target_hardware_identifier,
 464          {"Target Hardware Identifier", "find.target_hardware_identifier", FT_STRINGZ,
 465           BASE_NONE, NULL, 0x0, "FIND Target Hardware Identifier", HFILL}},
 466         {&hf_find_target_type_name,
 467          {"Target Type Name", "find.target_type_name", FT_STRINGZ, BASE_NONE, NULL, 0x0,
 468           "FIND Target Type Name", HFILL}},
 469         {&hf_find_target_position,
 470          {"Target Position", "find.target_position", FT_STRINGZ, BASE_NONE, NULL, 0x0,
 471           "FIND Target Position", HFILL}},
 472         {&hf_find_literal_name,
 473          {"Literal Name", "find.literal_name", FT_STRINGZ, BASE_NONE, NULL, 0x0,
 474           "FIND Literal Name", HFILL}},
 475         {&hf_find_manufacturer_code,
 476          {"Manufacturer Code", "find.manufacturer_code", FT_STRINGZ, BASE_NONE, NULL, 0x0,
 477           "FIND Manufacturer Code", HFILL}},
 478         {&hf_find_packet_terminator,
 479          {"Packet terminator", "find.packet_terminator", FT_UINT8, BASE_HEX, NULL, 0x0,
 480           "FIND Packet terminator", HFILL}}
 481     };
 482
 483     static int *etts_find[] = {&ett_find};
 484
 485     proto_find = proto_register_protocol("Find Identification of Network Devices", "FIND", "find");
 486     proto_register_field_array(proto_find, hf_find, array_length(hf_find));
 487     proto_register_subtree_array(etts_find, array_length(etts_find));
 488     find_handle = register_dissector("find", dissect_find, proto_find);
 489 }
 490
 491 void proto_reg_handoff_a615a(void)
 492 {
 493     heur_dissector_add("tftp", dissect_a615a_heur, "Arinc 615a Protocol over TFTP", "a615a", proto_a615a,
 494                        HEURISTIC_ENABLE);
 495     dissector_add_uint_with_preference("udp.port", FIND_PORT, find_handle);
 496 }
 497
 498 /*
 499  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 500  *
 501  * Local variables:
 502  * c-basic-offset: 4
 503  * tab-width: 8
 504  * indent-tabs-mode: nil
 505  * End:
 506  *
 507  * vi: set shiftwidth=4 tabstop=8 expandtab:
 508  * :indentSize=4:tabSize=8:noTabs=true:
 509  */