summaryrefslogtreecommitdiffstats
path: root/tools/asterix/packet-asterix-template.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--tools/asterix/packet-asterix-template.c867
1 files changed, 867 insertions, 0 deletions
diff --git a/tools/asterix/packet-asterix-template.c b/tools/asterix/packet-asterix-template.c
new file mode 100644
index 0000000..e655cfd
--- /dev/null
+++ b/tools/asterix/packet-asterix-template.c
@@ -0,0 +1,867 @@
+/*
+
+Notice:
+
+
+This file is auto generated, do not edit!
+See tools/asterix/README.md for details.
+
+
+Data source:
+---{gitrev}---
+
+
+*/
+
+/* packet-asterix.c
+ * Routines for ASTERIX decoding
+ * By Marko Hrastovec <marko.hrastovec@sloveniacontrol.si>
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+/*
+ * ASTERIX (All-purpose structured EUROCONTROL surveillances
+ * information exchange) is a protocol related to air traffic control.
+ *
+ * The specifications can be downloaded from
+ * http://www.eurocontrol.int/services/asterix
+ */
+
+#include <config.h>
+
+#include <wsutil/bits_ctz.h>
+
+#include <epan/packet.h>
+#include <epan/prefs.h>
+#include <epan/proto_data.h>
+
+void proto_register_asterix(void);
+void proto_reg_handoff_asterix(void);
+
+#define PROTO_TAG_ASTERIX "ASTERIX"
+#define ASTERIX_PORT 8600
+
+#define MAX_DISSECT_STR 1024
+#define MAX_BUFFER 256
+
+static int proto_asterix = -1;
+
+static int hf_asterix_category = -1;
+static int hf_asterix_length = -1;
+static int hf_asterix_message = -1;
+static int hf_asterix_fspec = -1;
+static int hf_re_field_len = -1;
+static int hf_spare = -1;
+static int hf_counter = -1;
+static int hf_XXX_FX = -1;
+
+static int ett_asterix = -1;
+static int ett_asterix_category = -1;
+static int ett_asterix_length = -1;
+static int ett_asterix_message = -1;
+static int ett_asterix_subtree = -1;
+
+static dissector_handle_t asterix_handle;
+/* The following defines tell us how to decode the length of
+ * fields and how to construct their display structure */
+#define FIXED 1
+#define REPETITIVE 2
+#define FX 3
+/*#define FX_1 4*/
+/*#define RE 5*/
+#define COMPOUND 6
+/*#define SP 7*/
+/*#define FX_UAP 8*/
+#define EXP 9 /* Explicit (RE or SP) */
+
+/* The following defines tell us how to
+ * decode and display individual fields. */
+#define FIELD_PART_INT 0
+#define FIELD_PART_UINT 1
+#define FIELD_PART_FLOAT 2
+#define FIELD_PART_UFLOAT 3
+#define FIELD_PART_SQUAWK 4
+#define FIELD_PART_CALLSIGN 5
+#define FIELD_PART_ASCII 6
+#define FIELD_PART_FX 7
+#define FIELD_PART_HEX 8
+#define FIELD_PART_IAS_IM 9
+#define FIELD_PART_IAS_ASPD 10
+
+typedef struct FieldPart_s FieldPart;
+struct FieldPart_s {
+ uint16_t bit_length; /* length of field in bits */
+ double scaling_factor; /* scaling factor of the field (for instance: 1/128) */
+ uint8_t type; /* Pre-defined type for proper presentation */
+ int *hf; /* Pointer to hf representing this kind of data */
+ const char *format_string; /* format string for showing float values */
+};
+
+DIAG_OFF_PEDANTIC
+typedef struct AsterixField_s AsterixField;
+struct AsterixField_s {
+ uint8_t type; /* type of field */
+ unsigned length; /* fixed length */
+ unsigned repetition_counter_size; /* size of repetition counter, length of one item is in length */
+ unsigned header_length; /* the size is in first header_length bytes of the field */
+ int *hf; /* pointer to Wireshark hf_register_info */
+ const FieldPart **part; /* Look declaration and description of FieldPart above. */
+ const AsterixField *field[]; /* subfields */
+};
+DIAG_ON_PEDANTIC
+
+static void dissect_asterix_packet (tvbuff_t *, packet_info *pinfo, proto_tree *);
+static void dissect_asterix_data_block (tvbuff_t *tvb, packet_info *pinfo, unsigned, proto_tree *, uint8_t, int);
+static int dissect_asterix_fields (tvbuff_t *, packet_info *pinfo, unsigned, proto_tree *, uint8_t, const AsterixField *[]);
+
+static void asterix_build_subtree (tvbuff_t *, packet_info *pinfo, unsigned, proto_tree *, const AsterixField *);
+static void twos_complement (int64_t *, int);
+static uint8_t asterix_bit (uint8_t, uint8_t);
+static unsigned asterix_fspec_len (tvbuff_t *, unsigned);
+static uint8_t asterix_field_exists (tvbuff_t *, unsigned, int);
+static uint8_t asterix_get_active_uap (tvbuff_t *, unsigned, uint8_t);
+static int asterix_field_length (tvbuff_t *, unsigned, const AsterixField *);
+static int asterix_field_offset (tvbuff_t *, unsigned, const AsterixField *[], int);
+static int asterix_message_length (tvbuff_t *, unsigned, uint8_t, uint8_t);
+
+static const char AISCode[] = { ' ', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', ' ', ' ', ' ', ' ', ' ',
+ ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ' ', ' ', ' ', ' ', ' ', ' ' };
+
+static const value_string valstr_XXX_FX[] = {
+ { 0, "End of data item" },
+ { 1, "Extension into next extent" },
+ { 0, NULL }
+};
+static const FieldPart IXXX_FX = { 1, 1.0, FIELD_PART_FX, &hf_XXX_FX, NULL };
+static const FieldPart IXXX_1bit_spare = { 1, 1.0, FIELD_PART_UINT, NULL, NULL };
+static const FieldPart IXXX_2bit_spare = { 2, 1.0, FIELD_PART_UINT, NULL, NULL };
+static const FieldPart IXXX_3bit_spare = { 3, 1.0, FIELD_PART_UINT, NULL, NULL };
+static const FieldPart IXXX_4bit_spare = { 4, 1.0, FIELD_PART_UINT, NULL, NULL };
+static const FieldPart IXXX_5bit_spare = { 5, 1.0, FIELD_PART_UINT, NULL, NULL };
+static const FieldPart IXXX_6bit_spare = { 6, 1.0, FIELD_PART_UINT, NULL, NULL };
+static const FieldPart IXXX_7bit_spare = { 7, 1.0, FIELD_PART_UINT, NULL, NULL };
+
+/* Spare Item */
+DIAG_OFF_PEDANTIC
+static const AsterixField IX_SPARE = { FIXED, 0, 0, 0, &hf_spare, NULL, { NULL } };
+
+/* insert1 */
+---{insert1}---
+/* insert1 */
+
+/* settings which category version to use for each ASTERIX category */
+static int global_categories_version[] = {
+ 0, /* 000 */
+ 0, /* 001 */
+ 0, /* 002 */
+ 0, /* 003 */
+ 0, /* 004 */
+ 0, /* 005 */
+ 0, /* 006 */
+ 0, /* 007 */
+ 0, /* 008 */
+ 0, /* 009 */
+ 0, /* 010 */
+ 0, /* 011 */
+ 0, /* 012 */
+ 0, /* 013 */
+ 0, /* 014 */
+ 0, /* 015 */
+ 0, /* 016 */
+ 0, /* 017 */
+ 0, /* 018 */
+ 0, /* 019 */
+ 0, /* 020 */
+ 0, /* 021 */
+ 0, /* 022 */
+ 0, /* 023 */
+ 0, /* 024 */
+ 0, /* 025 */
+ 0, /* 026 */
+ 0, /* 027 */
+ 0, /* 028 */
+ 0, /* 029 */
+ 0, /* 030 */
+ 0, /* 031 */
+ 0, /* 032 */
+ 0, /* 033 */
+ 0, /* 034 */
+ 0, /* 035 */
+ 0, /* 036 */
+ 0, /* 037 */
+ 0, /* 038 */
+ 0, /* 039 */
+ 0, /* 040 */
+ 0, /* 041 */
+ 0, /* 042 */
+ 0, /* 043 */
+ 0, /* 044 */
+ 0, /* 045 */
+ 0, /* 046 */
+ 0, /* 047 */
+ 0, /* 048 */
+ 0, /* 049 */
+ 0, /* 050 */
+ 0, /* 051 */
+ 0, /* 052 */
+ 0, /* 053 */
+ 0, /* 054 */
+ 0, /* 055 */
+ 0, /* 056 */
+ 0, /* 057 */
+ 0, /* 058 */
+ 0, /* 059 */
+ 0, /* 060 */
+ 0, /* 061 */
+ 0, /* 062 */
+ 0, /* 063 */
+ 0, /* 064 */
+ 0, /* 065 */
+ 0, /* 066 */
+ 0, /* 067 */
+ 0, /* 068 */
+ 0, /* 069 */
+ 0, /* 070 */
+ 0, /* 071 */
+ 0, /* 072 */
+ 0, /* 073 */
+ 0, /* 074 */
+ 0, /* 075 */
+ 0, /* 076 */
+ 0, /* 077 */
+ 0, /* 078 */
+ 0, /* 079 */
+ 0, /* 080 */
+ 0, /* 081 */
+ 0, /* 082 */
+ 0, /* 083 */
+ 0, /* 084 */
+ 0, /* 085 */
+ 0, /* 086 */
+ 0, /* 087 */
+ 0, /* 088 */
+ 0, /* 089 */
+ 0, /* 090 */
+ 0, /* 091 */
+ 0, /* 092 */
+ 0, /* 093 */
+ 0, /* 094 */
+ 0, /* 095 */
+ 0, /* 096 */
+ 0, /* 097 */
+ 0, /* 098 */
+ 0, /* 099 */
+ 0, /* 100 */
+ 0, /* 101 */
+ 0, /* 102 */
+ 0, /* 103 */
+ 0, /* 104 */
+ 0, /* 105 */
+ 0, /* 106 */
+ 0, /* 107 */
+ 0, /* 108 */
+ 0, /* 109 */
+ 0, /* 110 */
+ 0, /* 111 */
+ 0, /* 112 */
+ 0, /* 113 */
+ 0, /* 114 */
+ 0, /* 115 */
+ 0, /* 116 */
+ 0, /* 117 */
+ 0, /* 118 */
+ 0, /* 119 */
+ 0, /* 120 */
+ 0, /* 121 */
+ 0, /* 122 */
+ 0, /* 123 */
+ 0, /* 124 */
+ 0, /* 125 */
+ 0, /* 126 */
+ 0, /* 127 */
+ 0, /* 128 */
+ 0, /* 129 */
+ 0, /* 130 */
+ 0, /* 131 */
+ 0, /* 132 */
+ 0, /* 133 */
+ 0, /* 134 */
+ 0, /* 135 */
+ 0, /* 136 */
+ 0, /* 137 */
+ 0, /* 138 */
+ 0, /* 139 */
+ 0, /* 140 */
+ 0, /* 141 */
+ 0, /* 142 */
+ 0, /* 143 */
+ 0, /* 144 */
+ 0, /* 145 */
+ 0, /* 146 */
+ 0, /* 147 */
+ 0, /* 148 */
+ 0, /* 149 */
+ 0, /* 150 */
+ 0, /* 151 */
+ 0, /* 152 */
+ 0, /* 153 */
+ 0, /* 154 */
+ 0, /* 155 */
+ 0, /* 156 */
+ 0, /* 157 */
+ 0, /* 158 */
+ 0, /* 159 */
+ 0, /* 160 */
+ 0, /* 161 */
+ 0, /* 162 */
+ 0, /* 163 */
+ 0, /* 164 */
+ 0, /* 165 */
+ 0, /* 166 */
+ 0, /* 167 */
+ 0, /* 168 */
+ 0, /* 169 */
+ 0, /* 170 */
+ 0, /* 171 */
+ 0, /* 172 */
+ 0, /* 173 */
+ 0, /* 174 */
+ 0, /* 175 */
+ 0, /* 176 */
+ 0, /* 177 */
+ 0, /* 178 */
+ 0, /* 179 */
+ 0, /* 180 */
+ 0, /* 181 */
+ 0, /* 182 */
+ 0, /* 183 */
+ 0, /* 184 */
+ 0, /* 185 */
+ 0, /* 186 */
+ 0, /* 187 */
+ 0, /* 188 */
+ 0, /* 189 */
+ 0, /* 190 */
+ 0, /* 191 */
+ 0, /* 192 */
+ 0, /* 193 */
+ 0, /* 194 */
+ 0, /* 195 */
+ 0, /* 196 */
+ 0, /* 197 */
+ 0, /* 198 */
+ 0, /* 199 */
+ 0, /* 200 */
+ 0, /* 201 */
+ 0, /* 202 */
+ 0, /* 203 */
+ 0, /* 204 */
+ 0, /* 205 */
+ 0, /* 206 */
+ 0, /* 207 */
+ 0, /* 208 */
+ 0, /* 209 */
+ 0, /* 210 */
+ 0, /* 211 */
+ 0, /* 212 */
+ 0, /* 213 */
+ 0, /* 214 */
+ 0, /* 215 */
+ 0, /* 216 */
+ 0, /* 217 */
+ 0, /* 218 */
+ 0, /* 219 */
+ 0, /* 220 */
+ 0, /* 221 */
+ 0, /* 222 */
+ 0, /* 223 */
+ 0, /* 224 */
+ 0, /* 225 */
+ 0, /* 226 */
+ 0, /* 227 */
+ 0, /* 228 */
+ 0, /* 229 */
+ 0, /* 230 */
+ 0, /* 231 */
+ 0, /* 232 */
+ 0, /* 233 */
+ 0, /* 234 */
+ 0, /* 235 */
+ 0, /* 236 */
+ 0, /* 237 */
+ 0, /* 238 */
+ 0, /* 239 */
+ 0, /* 240 */
+ 0, /* 241 */
+ 0, /* 242 */
+ 0, /* 243 */
+ 0, /* 244 */
+ 0, /* 245 */
+ 0, /* 246 */
+ 0, /* 247 */
+ 0, /* 248 */
+ 0, /* 249 */
+ 0, /* 250 */
+ 0, /* 251 */
+ 0, /* 252 */
+ 0, /* 253 */
+ 0, /* 254 */
+ 0 /* 255 */
+};
+
+static int dissect_asterix (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+{
+ col_set_str (pinfo->cinfo, COL_PROTOCOL, "ASTERIX");
+ col_clear (pinfo->cinfo, COL_INFO);
+
+ if (tree) { /* we are being asked for details */
+ dissect_asterix_packet (tvb, pinfo, tree);
+ }
+
+ return tvb_captured_length(tvb);
+}
+
+static void dissect_asterix_packet (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
+{
+ unsigned i;
+ uint8_t category;
+ uint16_t length;
+ proto_item *asterix_packet_item;
+ proto_tree *asterix_packet_tree;
+
+ for (i = 0; i < tvb_reported_length (tvb); i += length + 3) {
+ /* all ASTERIX messages have the same structure:
+ *
+ * header:
+ *
+ * 1 byte category even though a category is referenced as I019,
+ * this is just stored as decimal 19 (i.e. 0x13)
+ * 2 bytes length the total length of this ASTERIX message, the
+ * length includes the size of the header.
+ *
+ * Note that the there was a structural change at
+ * one point that changes whether multiple
+ * records can occur after the header or not
+ * (each category specifies this explicitly. All
+ * of the currently supported categories can have
+ * multiple records so this implementation just
+ * assumes that is always the case)
+ *
+ * record (multiple records can exists):
+ *
+ * n bytes FSPEC the field specifier is a bit mask where the
+ * lowest bit of each byte is called the FX bit.
+ * When the FX bit is set this indicates that
+ * the FSPEC extends into the next byte.
+ * Any other bit indicates the presence of the
+ * field that owns that bit (as per the User
+ * Application Profile (UAP)).
+ * X bytes Field Y X is as per the specification for field Y.
+ * etc.
+ *
+ * The User Application Profile (UAP) is simply a mapping from the
+ * FSPEC to fields. Each category has its own UAP.
+ */
+ category = tvb_get_guint8 (tvb, i);
+ length = (tvb_get_guint8 (tvb, i + 1) << 8) + tvb_get_guint8 (tvb, i + 2) - 3; /* -3 for category and length */
+
+ asterix_packet_item = proto_tree_add_item (tree, proto_asterix, tvb, i, length + 3, ENC_NA);
+ proto_item_append_text (asterix_packet_item, ", Category %03d", category);
+ asterix_packet_tree = proto_item_add_subtree (asterix_packet_item, ett_asterix);
+ proto_tree_add_item (asterix_packet_tree, hf_asterix_category, tvb, i, 1, ENC_BIG_ENDIAN);
+ proto_tree_add_item (asterix_packet_tree, hf_asterix_length, tvb, i + 1, 2, ENC_BIG_ENDIAN);
+
+ dissect_asterix_data_block (tvb, pinfo, i + 3, asterix_packet_tree, category, length);
+ }
+}
+
+static void dissect_asterix_data_block (tvbuff_t *tvb, packet_info *pinfo, unsigned offset, proto_tree *tree, uint8_t category, int length)
+{
+ uint8_t active_uap;
+ int fspec_len, inner_offset, size, counter;
+ proto_item *asterix_message_item = NULL;
+ proto_tree *asterix_message_tree = NULL;
+
+ for (counter = 1, inner_offset = 0; inner_offset < length; counter++) {
+
+ /* This loop handles parsing of each ASTERIX record */
+
+ active_uap = asterix_get_active_uap (tvb, offset + inner_offset, category);
+ size = asterix_message_length (tvb, offset + inner_offset, category, active_uap);
+ if (size > 0) {
+ asterix_message_item = proto_tree_add_item (tree, hf_asterix_message, tvb, offset + inner_offset, size, ENC_NA);
+ proto_item_append_text (asterix_message_item, ", #%02d, length: %d", counter, size);
+ asterix_message_tree = proto_item_add_subtree (asterix_message_item, ett_asterix_message);
+ fspec_len = asterix_fspec_len (tvb, offset + inner_offset);
+ /*show_fspec (tvb, asterix_message_tree, offset + inner_offset, fspec_len);*/
+ proto_tree_add_item (asterix_message_tree, hf_asterix_fspec, tvb, offset + inner_offset, fspec_len, ENC_NA);
+
+ size = dissect_asterix_fields (tvb, pinfo, offset + inner_offset, asterix_message_tree, category, categories[category][global_categories_version[category]][active_uap]);
+
+ inner_offset += size + fspec_len;
+ }
+ else {
+ inner_offset = length;
+ }
+ }
+}
+
+static int dissect_asterix_fields (tvbuff_t *tvb, packet_info *pinfo, unsigned offset, proto_tree *tree, uint8_t category, const AsterixField *current_uap[])
+{
+ unsigned i, j, size, start, len, inner_offset, fspec_len;
+ uint64_t counter;
+ proto_item *asterix_field_item = NULL;
+ proto_tree *asterix_field_tree = NULL;
+ proto_item *asterix_field_item2 = NULL;
+ proto_tree *asterix_field_tree2 = NULL;
+
+ if (current_uap == NULL)
+ return 0;
+
+ for (i = 0, size = 0; current_uap[i] != NULL; i++) {
+ start = asterix_field_offset (tvb, offset, current_uap, i);
+ if (start > 0) {
+ len = asterix_field_length (tvb, offset + start, current_uap[i]);
+ size += len;
+ switch(current_uap[i]->type) {
+ case COMPOUND:
+ asterix_field_item = proto_tree_add_item (tree, *current_uap[i]->hf, tvb, offset + start, len, ENC_NA);
+ asterix_field_tree = proto_item_add_subtree (asterix_field_item, ett_asterix_subtree);
+ fspec_len = asterix_fspec_len (tvb, offset + start);
+ proto_tree_add_item (asterix_field_tree, hf_asterix_fspec, tvb, offset + start, fspec_len, ENC_NA);
+ dissect_asterix_fields (tvb, pinfo, offset + start, asterix_field_tree, category, (const AsterixField **)current_uap[i]->field);
+ break;
+ case REPETITIVE:
+ asterix_field_item = proto_tree_add_item (tree, *current_uap[i]->hf, tvb, offset + start, len, ENC_NA);
+ asterix_field_tree = proto_item_add_subtree (asterix_field_item, ett_asterix_subtree);
+ for (j = 0, counter = 0; j < current_uap[i]->repetition_counter_size; j++) {
+ counter = (counter << 8) + tvb_get_guint8 (tvb, offset + start + j);
+ }
+ proto_tree_add_item (asterix_field_tree, hf_counter, tvb, offset + start, current_uap[i]->repetition_counter_size, ENC_BIG_ENDIAN);
+ for (j = 0, inner_offset = 0; j < counter; j++, inner_offset += current_uap[i]->length) {
+ asterix_field_item2 = proto_tree_add_item (asterix_field_tree, *current_uap[i]->hf, tvb, offset + start + current_uap[i]->repetition_counter_size + inner_offset, current_uap[i]->length, ENC_NA);
+ asterix_field_tree2 = proto_item_add_subtree (asterix_field_item2, ett_asterix_subtree);
+ asterix_build_subtree (tvb, pinfo, offset + start + current_uap[i]->repetition_counter_size + inner_offset, asterix_field_tree2, current_uap[i]);
+ }
+ break;
+ /* currently not generated from asterix-spec*/
+ /*case EXP:
+ asterix_field_item = proto_tree_add_item (tree, *current_uap[i]->hf, tvb, offset + start, len, ENC_NA);
+ asterix_field_tree = proto_item_add_subtree (asterix_field_item, ett_asterix_subtree);
+ proto_tree_add_item (asterix_field_tree, hf_re_field_len, tvb, offset + start, 1, ENC_BIG_ENDIAN);
+ start++;
+ fspec_len = asterix_fspec_len (tvb, offset + start);
+ proto_tree_add_item (asterix_field_tree, hf_asterix_fspec, tvb, offset + start, fspec_len, ENC_NA);
+ dissect_asterix_fields (tvb, pinfo, offset + start, asterix_field_tree, category, (const AsterixField **)current_uap[i]->field);
+ break;*/
+ default: /* FIXED, FX, FX_1, FX_UAP */
+ asterix_field_item = proto_tree_add_item (tree, *current_uap[i]->hf, tvb, offset + start, len, ENC_NA);
+ asterix_field_tree = proto_item_add_subtree (asterix_field_item, ett_asterix_subtree);
+ asterix_build_subtree (tvb, pinfo, offset + start, asterix_field_tree, current_uap[i]);
+ break;
+ }
+ }
+ }
+ return size;
+}
+
+static void asterix_build_subtree (tvbuff_t *tvb, packet_info *pinfo, unsigned offset, proto_tree *parent, const AsterixField *field)
+{
+ header_field_info* hfi;
+ int bytes_in_type, byte_offset_of_mask;
+ int i, inner_offset, offset_in_tvb, length_in_tvb;
+ uint8_t go_on;
+ int64_t value;
+ char *str_buffer = NULL;
+ double scaling_factor = 1.0;
+ uint8_t *air_speed_im_bit;
+ if (field->part != NULL) {
+ for (i = 0, inner_offset = 0, go_on = 1; go_on && field->part[i] != NULL; i++) {
+ value = tvb_get_bits64 (tvb, offset * 8 + inner_offset, field->part[i]->bit_length, ENC_BIG_ENDIAN);
+ if (field->part[i]->hf != NULL) {
+ offset_in_tvb = offset + inner_offset / 8;
+ length_in_tvb = (inner_offset % 8 + field->part[i]->bit_length + 7) / 8;
+ switch (field->part[i]->type) {
+ case FIELD_PART_FX:
+ if (!value) go_on = 0;
+ /* Fall through */
+ case FIELD_PART_INT:
+ case FIELD_PART_UINT:
+ case FIELD_PART_HEX:
+ case FIELD_PART_ASCII:
+ case FIELD_PART_SQUAWK:
+ hfi = proto_registrar_get_nth (*field->part[i]->hf);
+ if (hfi->bitmask)
+ {
+ // for a small bit field to decode correctly with
+ // a mask that belongs to a large(r) one we need to
+ // re-adjust offset_in_tvb and length_in_tvb to
+ // correctly align with the given hf mask.
+ //
+ // E.g. the following would not decode correctly:
+ // { &hf_020_050_V, ... FT_UINT16, ... 0x8000, ...
+ // instead one would have to use
+ // { &hf_020_050_V, ... FT_UINT8, ... 0x80, ...
+ //
+ bytes_in_type = ftype_wire_size(hfi->type);
+ if (bytes_in_type > 1)
+ {
+ byte_offset_of_mask = bytes_in_type - (ws_ilog2 (hfi->bitmask) + 8)/8;
+ if (byte_offset_of_mask >= 0)
+ {
+ offset_in_tvb -= byte_offset_of_mask;
+ length_in_tvb = bytes_in_type;
+ }
+ }
+ }
+ proto_tree_add_item (parent, *field->part[i]->hf, tvb, offset_in_tvb, length_in_tvb, ENC_BIG_ENDIAN);
+ break;
+ case FIELD_PART_FLOAT:
+ twos_complement (&value, field->part[i]->bit_length);
+ /* Fall through */
+ case FIELD_PART_UFLOAT:
+ scaling_factor = field->part[i]->scaling_factor;
+ if (field->part[i]->format_string != NULL)
+ proto_tree_add_double_format_value (parent, *field->part[i]->hf, tvb, offset_in_tvb, length_in_tvb, value * scaling_factor, field->part[i]->format_string, value * scaling_factor);
+ else
+ proto_tree_add_double (parent, *field->part[i]->hf, tvb, offset_in_tvb, length_in_tvb, value * scaling_factor);
+ break;
+ case FIELD_PART_CALLSIGN:
+ str_buffer = wmem_strdup_printf(
+ pinfo->pool,
+ "%c%c%c%c%c%c%c%c",
+ AISCode[(value >> 42) & 63],
+ AISCode[(value >> 36) & 63],
+ AISCode[(value >> 30) & 63],
+ AISCode[(value >> 24) & 63],
+ AISCode[(value >> 18) & 63],
+ AISCode[(value >> 12) & 63],
+ AISCode[(value >> 6) & 63],
+ AISCode[value & 63]);
+ proto_tree_add_string (parent, *field->part[i]->hf, tvb, offset_in_tvb, length_in_tvb, str_buffer);
+ break;
+ case FIELD_PART_IAS_IM:
+ /* special processing for I021/150 and I062/380#4 because Air Speed depends on IM subfield */
+ air_speed_im_bit = wmem_new (pinfo->pool, uint8_t);
+ *air_speed_im_bit = (tvb_get_guint8 (tvb, offset_in_tvb) & 0x80) >> 7;
+ /* Save IM info for the packet. key = 21150. */
+ p_add_proto_data (pinfo->pool, pinfo, proto_asterix, 21150, air_speed_im_bit);
+ proto_tree_add_item (parent, *field->part[i]->hf, tvb, offset_in_tvb, length_in_tvb, ENC_BIG_ENDIAN);
+ break;
+ case FIELD_PART_IAS_ASPD:
+ /* special processing for I021/150 and I062/380#4 because Air Speed depends on IM subfield */
+ air_speed_im_bit = (uint8_t *)p_get_proto_data (pinfo->pool, pinfo, proto_asterix, 21150);
+ if (!air_speed_im_bit || *air_speed_im_bit == 0)
+ scaling_factor = 1.0/16384.0;
+ else
+ scaling_factor = 0.001;
+ proto_tree_add_double (parent, *field->part[i]->hf, tvb, offset_in_tvb, length_in_tvb, value * scaling_factor);
+ break;
+ }
+ }
+ inner_offset += field->part[i]->bit_length;
+ }
+ } /* if not null */
+}
+
+static uint8_t asterix_bit (uint8_t b, uint8_t bitNo)
+{
+ return bitNo < 8 && (b & (0x80 >> bitNo)) > 0;
+}
+
+/* Function makes int64_t two's complement.
+ * Only the bit_len bit are set in int64_t. All more significant
+ * bits need to be set to have proper two's complement.
+ * If the number is negative, all other bits must be set to 1.
+ * If the number is positive, all other bits must remain 0. */
+static void twos_complement (int64_t *v, int bit_len)
+{
+ if (*v & (G_GUINT64_CONSTANT(1) << (bit_len - 1))) {
+ *v |= (G_GUINT64_CONSTANT(0xffffffffffffffff) << bit_len);
+ }
+}
+
+static unsigned asterix_fspec_len (tvbuff_t *tvb, unsigned offset)
+{
+ unsigned i;
+ unsigned max_length = tvb_reported_length (tvb) - offset;
+ for (i = 0; (tvb_get_guint8 (tvb, offset + i) & 1) && i < max_length; i++);
+ return i + 1;
+}
+
+static uint8_t asterix_field_exists (tvbuff_t *tvb, unsigned offset, int bitIndex)
+{
+ uint8_t bitNo, i;
+ bitNo = bitIndex + bitIndex / 7;
+ for (i = 0; i < bitNo / 8; i++) {
+ if (!(tvb_get_guint8 (tvb, offset + i) & 1)) return 0;
+ }
+ return asterix_bit (tvb_get_guint8 (tvb, offset + i), bitNo % 8);
+}
+
+static int asterix_field_length (tvbuff_t *tvb, unsigned offset, const AsterixField *field)
+{
+ unsigned size;
+ uint64_t count;
+ uint8_t i;
+
+ size = 0;
+ switch(field->type) {
+ case FIXED:
+ size = field->length;
+ break;
+ case REPETITIVE:
+ for (i = 0, count = 0; i < field->repetition_counter_size && i < sizeof (count); i++)
+ count = (count << 8) + tvb_get_guint8 (tvb, offset + i);
+ size = (unsigned)(field->repetition_counter_size + count * field->length);
+ break;
+ case FX:
+ for (size = field->length + field->header_length; tvb_get_guint8 (tvb, offset + size - 1) & 1; size += field->length);
+ break;
+ case EXP:
+ for (i = 0, size = 0; i < field->header_length; i++) {
+ size = (size << 8) + tvb_get_guint8 (tvb, offset + i);
+ }
+ break;
+ case COMPOUND:
+ /* FSPEC */
+ for (size = 0; tvb_get_guint8 (tvb, offset + size) & 1; size++);
+ size++;
+
+ for (i = 0; field->field[i] != NULL; i++) {
+ if (asterix_field_exists (tvb, offset, i))
+ size += asterix_field_length (tvb, offset + size, field->field[i]);
+ }
+ break;
+ }
+ return size;
+}
+
+/* This works for category 001. For other it may require changes. */
+static uint8_t asterix_get_active_uap (tvbuff_t *tvb, unsigned offset, uint8_t category)
+{
+ int i, inner_offset;
+ AsterixField **current_uap;
+
+ if ((category == 1) && (categories[category] != NULL)) { /* if category is supported */
+ if (categories[category][global_categories_version[category]][1] != NULL) { /* if exists another uap */
+ current_uap = (AsterixField **)categories[category][global_categories_version[category]][0];
+ if (current_uap != NULL) {
+ inner_offset = asterix_fspec_len (tvb, offset);
+ for (i = 0; current_uap[i] != NULL; i++) {
+ if (asterix_field_exists (tvb, offset, i)) {
+ if (i == 1) { /* uap selector (I001/020) is always at index '1' */
+ return tvb_get_guint8 (tvb, offset + inner_offset) >> 7;
+ }
+ inner_offset += asterix_field_length (tvb, offset + inner_offset, current_uap[i]);
+ }
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+static int asterix_field_offset (tvbuff_t *tvb, unsigned offset, const AsterixField *current_uap[], int field_index)
+{
+ int i, inner_offset;
+ inner_offset = 0;
+ if (asterix_field_exists (tvb, offset, field_index)) {
+ inner_offset = asterix_fspec_len (tvb, offset);
+ for (i = 0; i < field_index; i++) {
+ if (asterix_field_exists (tvb, offset, i))
+ inner_offset += asterix_field_length (tvb, offset + inner_offset, current_uap[i]);
+ }
+ }
+ return inner_offset;
+}
+
+static int asterix_message_length (tvbuff_t *tvb, unsigned offset, uint8_t category, uint8_t active_uap)
+{
+ int i, size;
+ AsterixField **current_uap;
+
+ if (categories[category] != NULL) { /* if category is supported */
+ current_uap = (AsterixField **)categories[category][global_categories_version[category]][active_uap];
+ if (current_uap != NULL) {
+ size = asterix_fspec_len (tvb, offset);
+ for (i = 0; current_uap[i] != NULL; i++) {
+ if (asterix_field_exists (tvb, offset, i)) {
+ size += asterix_field_length (tvb, offset + size, current_uap[i]);
+ }
+ }
+ return size;
+ }
+ }
+ return 0;
+}
+
+void proto_register_asterix (void)
+{
+ static hf_register_info hf[] = {
+ { &hf_asterix_category, { "Category", "asterix.category", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+ { &hf_asterix_length, { "Length", "asterix.length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+ { &hf_asterix_message, { "Asterix message", "asterix.message", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+ { &hf_asterix_fspec, { "FSPEC", "asterix.fspec", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+ { &hf_re_field_len, { "RE LEN", "asterix.re_field_len", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+ { &hf_spare, { "Spare", "asterix.spare", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+ { &hf_counter, { "Counter", "asterix.counter", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+ { &hf_XXX_FX, { "FX", "asterix.FX", FT_UINT8, BASE_DEC, VALS (valstr_XXX_FX), 0x01, "Extension into next extent", HFILL } },
+/* insert2 */
+---{insert2}---
+/* insert2 */
+ };
+
+ /* Setup protocol subtree array */
+ static int *ett[] = {
+ &ett_asterix,
+ &ett_asterix_category,
+ &ett_asterix_length,
+ &ett_asterix_message,
+ &ett_asterix_subtree
+ };
+
+ module_t *asterix_prefs_module;
+
+ proto_asterix = proto_register_protocol (
+ "ASTERIX packet", /* name */
+ "ASTERIX", /* short name */
+ "asterix" /* abbrev */
+ );
+
+ proto_register_field_array (proto_asterix, hf, array_length (hf));
+ proto_register_subtree_array (ett, array_length (ett));
+
+ asterix_handle = register_dissector ("asterix", dissect_asterix, proto_asterix);
+
+ asterix_prefs_module = prefs_register_protocol (proto_asterix, NULL);
+
+/* insert3 */
+---{insert3}---
+/* insert3 */
+}
+
+void proto_reg_handoff_asterix (void)
+{
+ dissector_add_uint_with_preference("udp.port", ASTERIX_PORT, asterix_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:
+ */
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-26 19:11:59 +0000