Adding upstream version 4.2.2.upstream/4.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 555 insertions, 0 deletions

diff --git a/epan/dissectors/packet-ppi-sensor.c b/epan/dissectors/packet-ppi-sensor.c
new file mode 100644
index 00000000..527a0aba
--- /dev/null
+++ b/epan/dissectors/packet-ppi-sensor.c
@@ -0,0 +1,555 @@
+/* packet-ppi-sensor.c
+ * Routines for PPI-GEOLOCATION-SENSOR dissection
+ * Copyright 2010, Harris Corp, jellch@harris.com
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * Copied from packet-ppi-antenna.c
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "config.h"
+
+#include <epan/packet.h>
+#include <epan/expert.h>
+#include "packet-ppi-geolocation-common.h"
+
+enum ppi_sensor_type {
+    PPI_SENSOR_SENSORTYPE   = 0, /* Velocity, Acceleration, etc */
+    PPI_SENSOR_SCALEFACTOR  = 1, /* 10^scalefactor applied to all values */
+    PPI_SENSOR_VAL_X        = 2, /* X-dimension reading */
+    PPI_SENSOR_VAL_Y        = 3, /* Y-dimension reading */
+    PPI_SENSOR_VAL_Z        = 4, /* Z-dimension reading */
+    PPI_SENSOR_VAL_T        = 5, /* Total reading */
+    PPI_SENSOR_VAL_E        = 6, /* Error reading */
+    PPI_SENSOR_DESCSTR     = 28, /*32 bytes, fixed length, null terminated description of what the sensor is for */
+    PPI_SENSOR_APPID       = 29, /*4-byte identifier*/
+    PPI_SENSOR_APPDATA     = 30, /* 60-byte app-id specific data*/
+    PPI_SENSOR_EXT         = 31  /* Indicates n extended bitmap follows */
+};
+#define PPI_SENSOR_MAXTAGLEN 127 /* Increase as fields are added */
+
+
+/*Sensor types */
+#define SENSOR_RESERVED0       0
+/*The values of these sensors corresponds to the order of their derivatives. double geek win */
+#define SENSOR_VELOCITY        1
+#define SENSOR_ACCELERATION    2
+#define SENSOR_JERK            3
+#define SENSOR_ROTATION      100
+#define SENSOR_MAGNETIC      101
+#define SENSOR_TEMPERATURE  1000
+#define SENSOR_BAROMETER    1001
+#define SENSOR_HUMIDITY     1002
+#define SENSOR_TDOA_CLOCK   2000
+#define SENSOR_PHASE        2001
+
+static const value_string sensor_type_str[] = {
+  { SENSOR_RESERVED0,    "Reserved" },
+  { SENSOR_VELOCITY,     "Velocity"},
+  { SENSOR_ACCELERATION, "Acceleration"},
+  { SENSOR_JERK,         "Jerk"},
+  { SENSOR_ROTATION,     "Rotation"},
+  { SENSOR_MAGNETIC,     "Magnetic"},
+  { SENSOR_TEMPERATURE,  "Temperature"},
+  { SENSOR_BAROMETER,    "Barometer"},
+  { SENSOR_HUMIDITY,     "Humidity"},
+  { SENSOR_TDOA_CLOCK,   "TDOA_Clock"},
+  { SENSOR_PHASE,         "Phase"},
+  { 0, NULL}
+  };
+
+static const value_string sensor_unit_str[] = {
+  { SENSOR_RESERVED0,    "Reserved" },
+  { SENSOR_VELOCITY,     "Meters/sec"},
+  { SENSOR_ACCELERATION, "Meters/sec/sec"},
+  { SENSOR_JERK,         "Meters/sec/sec/sec"},
+  { SENSOR_ROTATION,     "Degrees/sec"},
+  { SENSOR_MAGNETIC,     "Tesla"},
+  { SENSOR_TEMPERATURE,  "Degrees Celsius"},
+  { SENSOR_BAROMETER,    "Pascal"},
+  { SENSOR_HUMIDITY,     "Humidity"},
+  { SENSOR_TDOA_CLOCK,   "Seconds"},
+  { SENSOR_PHASE,        "Degrees"},
+  { 0, NULL}
+  };
+
+void proto_register_ppi_sensor(void);
+/* protocol */
+static int proto_ppi_sensor = -1;
+
+static int hf_ppi_sensor_version = -1;
+static int hf_ppi_sensor_pad = -1;
+static int hf_ppi_sensor_length = -1;
+static int hf_ppi_sensor_present = -1;
+static int hf_ppi_sensor_sensortype = -1;
+static int hf_ppi_sensor_scalefactor = -1;
+static int hf_ppi_sensor_val_x = -1;
+static int hf_ppi_sensor_val_y= -1;
+static int hf_ppi_sensor_val_z= -1;
+static int hf_ppi_sensor_val_t= -1;
+static int hf_ppi_sensor_val_e = -1;
+static int hf_ppi_sensor_descstr = -1;
+static int hf_ppi_sensor_appspecific_num = -1; /* 4-byte tag no */
+static int hf_ppi_sensor_appspecific_data = -1; /* 60 byte arbitrary data */
+
+
+/* "Present" flags */
+/* These represent decoded-bits in the gui */
+static int hf_ppi_sensor_present_sensortype = -1;
+static int hf_ppi_sensor_present_scalefactor = -1;
+static int hf_ppi_sensor_present_val_x= -1;
+static int hf_ppi_sensor_present_val_y= -1;
+static int hf_ppi_sensor_present_val_z= -1;
+static int hf_ppi_sensor_present_val_t= -1;
+static int hf_ppi_sensor_present_val_e = -1;
+static int hf_ppi_sensor_present_descstr = -1;
+static int hf_ppi_sensor_present_appspecific_num = -1;
+static int hf_ppi_sensor_present_appspecific_data = -1;
+static int hf_ppi_sensor_present_ext = -1;
+
+
+/* These represent arrow-dropdownthings in the gui */
+static gint ett_ppi_sensor = -1;
+static gint ett_ppi_sensor_present = -1;
+
+static expert_field ei_ppi_sensor_present_bit = EI_INIT;
+static expert_field ei_ppi_sensor_version = EI_INIT;
+static expert_field ei_ppi_sensor_length = EI_INIT;
+
+/* used with ScaleFactor */
+static gdouble
+base_10_expt(int power)
+{
+    gdouble ret = 1;
+    int provide_frac = 0;
+
+    if (power == 0) /* likely*/
+        return 1;
+
+    /* if negative, negate when we return*/
+    if (power < 0)
+    {
+        power *= -1;
+        provide_frac = 1;
+    }
+    while (power > 0)
+    {
+        ret = ret * 10;
+        power--;
+    }
+    if (! provide_frac)
+        return ret;
+    else
+        return (1.0/ret);
+}
+
+static int
+dissect_ppi_sensor(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) {
+    /* The fixed values up front */
+    guint32 version;
+    guint length;
+    guint length_remaining;
+
+    proto_tree *ppi_sensor_tree = NULL;
+    proto_tree *pt, *my_pt;
+    proto_item *version_item, *length_item;
+    proto_tree *sensor_line;
+    /* sensor type in english */
+    const gchar *type_str = "Unknown sensor";
+    const gchar *unit_str = "Unknown unit";
+
+    static int * const ppi_sensor_present_flags[] = {
+        &hf_ppi_sensor_present_sensortype,
+        &hf_ppi_sensor_present_scalefactor,
+        &hf_ppi_sensor_present_val_x,
+        &hf_ppi_sensor_present_val_y,
+        &hf_ppi_sensor_present_val_z,
+        &hf_ppi_sensor_present_val_t,
+        &hf_ppi_sensor_present_val_e,
+        &hf_ppi_sensor_present_descstr,
+        &hf_ppi_sensor_present_appspecific_num,
+        &hf_ppi_sensor_present_appspecific_data,
+        &hf_ppi_sensor_present_ext,
+        NULL
+    };
+
+    /* bits*/
+    int bit;
+    guint32 present, next_present;
+    int offset = 0;
+    /* values actually read out, for displaying */
+    guint16 sensortype =0;
+    gchar  scalefactor = 0;
+    gdouble c_val=0; /*curr val */
+    guint32 val_t=0; /*temp curr val*/
+    guint32 t_appspecific_num; /* temporary conversions */
+
+    gdouble curr_native_val; /* this will have scaling_factor applied. displayed in sensor line */
+    gchar* curr_str;
+
+
+
+    /* Clear out stuff in the info column */
+    col_clear(pinfo->cinfo,COL_INFO);
+
+    /* pull out the first three fields of the BASE-GEOTAG-HEADER */
+    version = tvb_get_guint8(tvb, offset);
+    length = tvb_get_letohs(tvb, offset+2);
+    present = tvb_get_letohl(tvb, offset+4);
+
+    /* Setup basic column info */
+    col_add_fstr(pinfo->cinfo, COL_INFO, "PPI Sensor info v%u, Length %u ",
+                     version, length);
+
+    /* Create the basic dissection tree*/
+    sensor_line = proto_tree_add_protocol_format(tree, proto_ppi_sensor,
+                                        tvb, 0, length, "PPI Sensor Header v%u, Length %u", version, length);
+    /*Add in the fixed ppi-geotagging-header fields: ver, pad, len */
+    ppi_sensor_tree = proto_item_add_subtree(sensor_line, ett_ppi_sensor);
+    version_item = proto_tree_add_uint(ppi_sensor_tree, hf_ppi_sensor_version,
+                        tvb, offset, 1, version);
+    proto_tree_add_item(ppi_sensor_tree, hf_ppi_sensor_pad,
+                        tvb, offset + 1, 1, ENC_BIG_ENDIAN);
+    length_item = proto_tree_add_uint(ppi_sensor_tree, hf_ppi_sensor_length,
+                                tvb, offset + 2, 2, length);
+    /*fixed ppi-geotagging-header fields finished, move onto the fields marked present*/
+
+    /* We support v1 and v2 of Sensor tags (identical) */
+    if (! (version == 1 || version == 2) ) {
+        expert_add_info_format(pinfo, version_item, &ei_ppi_sensor_version, "Invalid version (got %d,  expected 1 or 2)", version);
+    }
+
+    length_remaining = length;
+    /* minimum length check, should atleast be a fixed-size geotagging-base header*/
+    if (length_remaining < PPI_GEOBASE_MIN_HEADER_LEN) {
+        /*
+         * Base-geotag-header (Radiotap lookalike) is shorter than the fixed-length portion
+         * plus one "present" bitset.
+         */
+        expert_add_info_format(pinfo, length_item, &ei_ppi_sensor_length, "Invalid PPI-Sensor length - minimum length is 8");
+        return 2;
+    }
+
+    /* perform max length sanity checking */
+    if (length > PPI_SENSOR_MAXTAGLEN ) {
+        expert_add_info_format(pinfo, length_item, &ei_ppi_sensor_length, "Invalid PPI-Sensor length  (got %d, %d max\n)", length, PPI_SENSOR_MAXTAGLEN);
+        return 2;
+    }
+
+    /* Subtree for the "present flags" bitfield. */
+    pt = proto_tree_add_bitmask(ppi_sensor_tree, tvb, offset + 4, hf_ppi_sensor_present, ett_ppi_sensor_present, ppi_sensor_present_flags, ENC_LITTLE_ENDIAN);
+
+    offset += PPI_GEOBASE_MIN_HEADER_LEN;
+    length_remaining -= PPI_GEOBASE_MIN_HEADER_LEN;
+
+    /* Now all of the fixed length, fixed location stuff is over. Loop over the bits */
+    for (; present; present = next_present) {
+        /* clear the least significant bit that is set */
+        next_present = present & (present - 1);
+        /* extract the least significant bit that is set */
+        bit = BITNO_32(present ^ next_present);
+        switch (bit) {
+        case  PPI_SENSOR_SENSORTYPE:
+            if (length_remaining < 2)
+                break;
+            sensortype= tvb_get_letohs(tvb, offset);
+            type_str = val_to_str_const (sensortype, sensor_type_str, "Unknown Sensor type");
+            unit_str = val_to_str_const (sensortype, sensor_unit_str, "Unknown Unit");
+
+            if (tree) {
+                my_pt = proto_tree_add_uint(ppi_sensor_tree, hf_ppi_sensor_sensortype, tvb, offset , 2, sensortype);
+                proto_item_append_text (my_pt, " %s", type_str);
+                proto_item_set_text(sensor_line, "Sensor: %s", type_str);
+            }
+            offset+=2;
+            length_remaining-=2;
+            break;
+        case PPI_SENSOR_SCALEFACTOR:
+            if (length_remaining < 1)
+                break;
+            scalefactor = (gchar) tvb_get_guint8(tvb, offset);
+            proto_tree_add_int(ppi_sensor_tree, hf_ppi_sensor_scalefactor, tvb, offset, 1, scalefactor);
+            offset+=1;
+            length_remaining-=1;
+            break;
+        case  PPI_SENSOR_VAL_X:
+            if (length_remaining < 4)
+                break;
+            val_t = tvb_get_letohl(tvb, offset);
+            c_val = ppi_fixed6_4_to_gdouble(val_t);
+            if (tree) {
+                my_pt = proto_tree_add_double(ppi_sensor_tree, hf_ppi_sensor_val_x, tvb, offset, 4, c_val);
+                proto_item_append_text (my_pt, " %s", unit_str);
+                curr_native_val = c_val * base_10_expt(scalefactor); /* this will almost always be equal to the original val */
+                proto_item_set_text(sensor_line, "Sensor: %s %f %s", type_str, curr_native_val, unit_str);
+            }
+            offset+=4;
+            length_remaining-=4;
+            break;
+        case  PPI_SENSOR_VAL_Y:
+            if (length_remaining < 4)
+                break;
+            val_t = tvb_get_letohl(tvb, offset);
+            c_val = ppi_fixed6_4_to_gdouble(val_t);
+            if (tree) {
+                my_pt = proto_tree_add_double(ppi_sensor_tree, hf_ppi_sensor_val_y, tvb, offset, 4, c_val);
+                proto_item_append_text (my_pt, " %s", unit_str);
+                curr_native_val = c_val * base_10_expt(scalefactor); /* this will almost always be equal to the original val */
+                proto_item_set_text(sensor_line, "Sensor: %s %f %s", type_str, curr_native_val, unit_str);
+
+            }
+            offset+=4;
+            length_remaining-=4;
+            break;
+        case  PPI_SENSOR_VAL_Z:
+            if (length_remaining < 4)
+                break;
+            val_t = tvb_get_letohl(tvb, offset);
+            c_val = ppi_fixed6_4_to_gdouble(val_t);
+            if (tree) {
+                my_pt = proto_tree_add_double(ppi_sensor_tree, hf_ppi_sensor_val_z, tvb, offset, 4, c_val);
+                proto_item_append_text (my_pt, " %s", unit_str);
+                curr_native_val = c_val * base_10_expt(scalefactor); /* this will almost always be equal to the original val */
+                proto_item_set_text(sensor_line, "Sensor: %s %f %s", type_str, curr_native_val, unit_str);
+            }
+            offset+=4;
+            length_remaining-=4;
+            break;
+        case  PPI_SENSOR_VAL_T:
+            if (length_remaining < 4)
+                break;
+            val_t = tvb_get_letohl(tvb, offset);
+            c_val = ppi_fixed6_4_to_gdouble(val_t);
+            if (tree) {
+                my_pt = proto_tree_add_double(ppi_sensor_tree, hf_ppi_sensor_val_t, tvb, offset, 4, c_val);
+                proto_item_append_text (my_pt, " %s", unit_str);
+                curr_native_val = c_val * base_10_expt(scalefactor); /* this will almost always be equal to the original val */
+                proto_item_set_text(sensor_line, "Sensor: %s %f %s", type_str, curr_native_val, unit_str);
+            }
+            offset+=4;
+            length_remaining-=4;
+            break;
+        case  PPI_SENSOR_VAL_E:
+            if (length_remaining < 4)
+                break;
+            val_t = tvb_get_letohl(tvb, offset);
+            c_val = ppi_fixed6_4_to_gdouble(val_t);
+            if (tree) {
+                my_pt = proto_tree_add_double(ppi_sensor_tree, hf_ppi_sensor_val_e, tvb, offset, 4, c_val);
+                proto_item_append_text (my_pt, " %s", unit_str);
+            }
+            offset+=4;
+            length_remaining-=4;
+            break;
+
+        case  PPI_SENSOR_DESCSTR:
+            if (length_remaining < 32)
+                break;
+            if (tree)
+            {
+                /* proto_tree_add_item(ppi_vector_tree, hf_ppi_vector_descstr, tvb, offset, 32, ENC_NA); */
+                curr_str = tvb_format_stringzpad(pinfo->pool, tvb, offset, 32);
+                proto_tree_add_string(ppi_sensor_tree, hf_ppi_sensor_descstr, tvb, offset, 32, curr_str);
+                proto_item_append_text(sensor_line, " (%s)", curr_str);
+            }
+            offset+=32;
+            length_remaining-=32;
+            break;
+        case  PPI_SENSOR_APPID:
+            if (length_remaining < 4)
+                break;
+            t_appspecific_num  = tvb_get_letohl(tvb, offset); /* application specific parsers may switch on this later */
+            proto_tree_add_uint(ppi_sensor_tree, hf_ppi_sensor_appspecific_num, tvb, offset, 4, t_appspecific_num);
+            offset+=4;
+            length_remaining-=4;
+            break;
+        case  PPI_SENSOR_APPDATA:
+            if (length_remaining < 60)
+                break;
+            proto_tree_add_item(ppi_sensor_tree, hf_ppi_sensor_appspecific_data, tvb, offset, 60,  ENC_NA);
+            offset+=60;
+            length_remaining-=60;
+            break;
+        default:
+            /*
+             * This indicates a field whose size we do not
+             * know, so we cannot proceed.
+             */
+            expert_add_info_format(pinfo, pt, &ei_ppi_sensor_present_bit, "Error: PPI-SENSOR: unknown bit (%d) set in present field.", bit);
+            next_present = 0;
+            continue;
+        }
+
+    };
+    return tvb_captured_length(tvb);
+}
+
+void
+proto_register_ppi_sensor(void) {
+    /* The following array initializes those header fields declared above to the values displayed */
+    static hf_register_info hf[] = {
+        { &hf_ppi_sensor_version,
+          { "Header revision", "ppi_sensor.version",
+            FT_UINT8, BASE_DEC, NULL, 0x0,
+            "Version of ppi_sensor header format", HFILL } },
+        { &hf_ppi_sensor_pad,
+          { "Header pad", "ppi_sensor.pad",
+            FT_UINT8, BASE_DEC, NULL, 0x0,
+            "Padding", HFILL } },
+        { &hf_ppi_sensor_length,
+          { "Header length", "ppi_sensor.length",
+            FT_UINT16, BASE_DEC, NULL, 0x0,
+            "Length of header including version, pad, length and data fields", HFILL } },
+        { &hf_ppi_sensor_present,
+          { "Present", "ppi_sensor.present",
+            FT_UINT32, BASE_HEX, NULL, 0x0, "Bitmask indicating which fields are present", HFILL } },
+
+        /* This first set is for the base_tag_header.it_present bitfield */
+#define PPI_SENSOR_MASK_SENSORTYPE      0x00000001  /* 0 */
+#define PPI_SENSOR_MASK_SCALEFACTOR     0x00000002  /* 1 */
+#define PPI_SENSOR_MASK_VAL_X           0x00000004  /* 2 */
+#define PPI_SENSOR_MASK_VAL_Y           0x00000008  /* 3 */
+#define PPI_SENSOR_MASK_VAL_Z           0x00000010  /* 4 */
+#define PPI_SENSOR_MASK_VAL_T           0x00000020  /* 5 */
+#define PPI_SENSOR_MASK_VAL_E           0x00000040  /* 6 */
+#define PPI_SENSOR_MASK_SERIALNUM       0x04000000  /* 26 */
+#define PPI_SENSOR_MASK_MODELSTR        0x08000000  /* 27 */
+#define PPI_SENSOR_MASK_DESCSTR         0x10000000  /* 28 */
+#define PPI_SENSOR_MASK_APPID           0x20000000  /* 29 */
+#define PPI_SENSOR_MASK_APPDATA         0x40000000  /* 30 */
+#define PPI_SENSOR_MASK_EXT             0x80000000  /* 31 */
+
+        /* Boolean 'present' flags */
+        { &hf_ppi_sensor_present_sensortype,
+          { "sensortype", "ppi_sensor.present.sensortype",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_SENSORTYPE,
+            "Specifies if the sensor type field  is present", HFILL } },
+        { &hf_ppi_sensor_present_scalefactor,
+          { "scalefactor", "ppi_sensor.present.scalefactor",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_SCALEFACTOR,
+            "Specifies if the sensor scale factor field is present", HFILL } },
+
+        { &hf_ppi_sensor_present_val_x,
+          { "val_x", "ppi_sensor.present.val_x",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_VAL_X,
+            "Specifies if the sensor val_x field is present", HFILL } },
+        { &hf_ppi_sensor_present_val_y,
+          { "val_y", "ppi_sensor.present.val_y",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_VAL_Y,
+            "Specifies if the sensor val_y field is present", HFILL } },
+        { &hf_ppi_sensor_present_val_z,
+          { "val_z", "ppi_sensor.present.val_z",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_VAL_Z,
+            "Specifies if the BeamID field is present", HFILL } },
+
+        { &hf_ppi_sensor_present_val_t,
+          { "val_t", "ppi_sensor.present.val_t",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_VAL_T,
+            "Specifies if the val_t field is present", HFILL } },
+        { &hf_ppi_sensor_present_val_e,
+          { "val_e", "ppi_sensor.present.val_e",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_VAL_E,
+            "Specifies if the val_e field is present", HFILL } },
+
+        { &hf_ppi_sensor_present_descstr,
+          { "Description", "ppi_sensor.present.descr",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_DESCSTR,
+            "Specifies if the description string is present", HFILL } },
+        { &hf_ppi_sensor_present_appspecific_num,
+          { "appid", "ppi_sensor.present.appid",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_APPID,
+            "Specifies if the application specific field id is present", HFILL } },
+        { &hf_ppi_sensor_present_appspecific_data,
+          { "appdata", "ppi_sensor.present.appdata",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_APPDATA,
+            "Specifies if the application specific data field  is present", HFILL } },
+        { &hf_ppi_sensor_present_ext,
+          { "ext", "ppi_sensor.present.ext",
+            FT_BOOLEAN, 32, NULL, PPI_SENSOR_MASK_EXT,
+            "Specifies if there are any extensions to the header present", HFILL } },
+
+
+        /* Now we get to the actual data fields */
+        { &hf_ppi_sensor_sensortype,
+          { "SensorType", "ppi_sensor.sensortype",
+            FT_UINT16, BASE_DEC, NULL, 0x0,
+            "Type of sensor", HFILL } },
+        { &hf_ppi_sensor_scalefactor,
+          { "ScaleFactor", "ppi_sensor.scalefactor",
+            FT_INT8, BASE_DEC, NULL, 0x0,
+            "Scaling factor", HFILL } },
+        { &hf_ppi_sensor_val_x,
+          { "Val_X", "ppi_sensor.val_x",
+            FT_DOUBLE, BASE_NONE, NULL, 0x0,
+            "Value in X-dimesion", HFILL } },
+        { &hf_ppi_sensor_val_y,
+          { "Val_Y", "ppi_sensor.val_y",
+            FT_DOUBLE, BASE_NONE, NULL, 0x0,
+            "Value in Y-dimension", HFILL } },
+        { &hf_ppi_sensor_val_z,
+          { "Val_Z", "ppi_sensor.val_z",
+            FT_DOUBLE, BASE_NONE, NULL, 0x0,
+            "Value in Z-dimension", HFILL } },
+        { &hf_ppi_sensor_val_t,
+          { "Val_T", "ppi_sensor.val_t",
+            FT_DOUBLE, BASE_NONE, NULL, 0x0,
+            "Value total (dimensionless)", HFILL } },
+        { &hf_ppi_sensor_val_e,
+          { "Val_E", "ppi_sensor.val_e",
+            FT_DOUBLE, BASE_NONE, NULL, 0x0,
+            "Margin of error", HFILL } },
+
+
+        { &hf_ppi_sensor_descstr,
+          { "Description", "ppi_sensor.descr",
+            FT_STRING,  BASE_NONE, NULL, 0x0,
+            NULL, HFILL } } ,
+        { &hf_ppi_sensor_appspecific_num,
+          { "Application Specific id", "ppi_sensor.appid",
+            FT_UINT32, BASE_HEX, NULL, 0x0,
+            "Application-specific identifier", HFILL } },
+        { &hf_ppi_sensor_appspecific_data,
+          { "Application specific data", "ppi_sensor.appdata",
+            FT_BYTES, BASE_NONE, NULL, 0x0,
+            "Application-specific data", HFILL } },
+    };
+    static gint *ett[] = {
+        &ett_ppi_sensor,
+        &ett_ppi_sensor_present,
+    };
+
+    static ei_register_info ei[] = {
+        { &ei_ppi_sensor_present_bit, { "ppi_sensor.present.unknown_bit", PI_PROTOCOL, PI_WARN, "Error: PPI-ANTENNA: unknown bit set in present field.", EXPFILL }},
+        { &ei_ppi_sensor_version, { "ppi_sensor.version.unsupported", PI_PROTOCOL, PI_WARN, "Invalid version", EXPFILL }},
+        { &ei_ppi_sensor_length, { "ppi_sensor.length.invalid", PI_MALFORMED, PI_ERROR, "Invalid length", EXPFILL }},
+    };
+
+    expert_module_t* expert_ppi_sensor;
+
+    proto_ppi_sensor = proto_register_protocol("PPI sensor decoder", "PPI sensor Decoder", "ppi_sensor");
+    proto_register_field_array(proto_ppi_sensor, hf, array_length(hf));
+    proto_register_subtree_array(ett, array_length(ett));
+    expert_ppi_sensor = expert_register_protocol(proto_ppi_sensor);
+    expert_register_field_array(expert_ppi_sensor, ei, array_length(ei));
+    register_dissector("ppi_sensor", dissect_ppi_sensor, proto_ppi_sensor);
+
+}
+
+/*
+ * Editor modelines
+ *
+ * Local Variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * ex: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */
+
+