From 1f807cc26a675952bb36f594731d9a7458f166b9 Mon Sep 17 00:00:00 2001 From: Bill Meier Date: Mon, 20 Feb 2012 23:28:23 +0000 Subject: Indentation & whitespace cleanup.... svn path=/trunk/; revision=41093 --- epan/dissectors/packet-ansi_801.c | 1744 ++++++++++++++++++------------------- 1 file changed, 872 insertions(+), 872 deletions(-) (limited to 'epan/dissectors/packet-ansi_801.c') diff --git a/epan/dissectors/packet-ansi_801.c b/epan/dissectors/packet-ansi_801.c index 9face06270..7a4f9781d3 100644 --- a/epan/dissectors/packet-ansi_801.c +++ b/epan/dissectors/packet-ansi_801.c @@ -113,27 +113,27 @@ static proto_tree *g_tree; /* PARAM FUNCTIONS */ -#define EXTRANEOUS_DATA_CHECK(edc_len, edc_max_len) \ - if ((edc_len) > (edc_max_len)) \ - { \ - proto_tree_add_text(tree, tvb, \ - offset, (edc_len) - (edc_max_len), "Extraneous Data"); \ +#define EXTRANEOUS_DATA_CHECK(edc_len, edc_max_len) \ + if ((edc_len) > (edc_max_len)) \ + { \ + proto_tree_add_text(tree, tvb, \ + offset, (edc_len) - (edc_max_len), "Extraneous Data"); \ } -#define SHORT_DATA_CHECK(sdc_len, sdc_min_len) \ - if ((sdc_len) < (sdc_min_len)) \ - { \ - proto_tree_add_text(tree, tvb, \ - offset, (sdc_len), "Short Data (?)"); \ - return; \ +#define SHORT_DATA_CHECK(sdc_len, sdc_min_len) \ + if ((sdc_len) < (sdc_min_len)) \ + { \ + proto_tree_add_text(tree, tvb, \ + offset, (sdc_len), "Short Data (?)"); \ + return; \ } -#define EXACT_DATA_CHECK(edc_len, edc_eq_len) \ - if ((edc_len) != (edc_eq_len)) \ - { \ - proto_tree_add_text(tree, tvb, \ - offset, (edc_len), "Unexpected Data Length"); \ - return; \ +#define EXACT_DATA_CHECK(edc_len, edc_eq_len) \ + if ((edc_len) != (edc_eq_len)) \ + { \ + proto_tree_add_text(tree, tvb, \ + offset, (edc_len), "Unexpected Data Length"); \ + return; \ } @@ -247,7 +247,7 @@ for_req_pseudo_meas(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) offset = bit_offset >> 3; EXTRANEOUS_DATA_CHECK(len, offset - saved_offset); - + } static void @@ -264,48 +264,48 @@ for_req_pilot_ph_meas(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset other_decode_bitfield_value(bigbuf, value >> 16, 0xe0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Preferred response quality, %u", - bigbuf, - (value & 0xe00000) >> 21); + "%s : Preferred response quality, %u", + bigbuf, + (value & 0xe00000) >> 21); other_decode_bitfield_value(bigbuf, value >> 16, 0x1f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number of fixes (MSB), %u", - bigbuf, - (value & 0x1fe000) >> 13); + "%s : Number of fixes (MSB), %u", + bigbuf, + (value & 0x1fe000) >> 13); other_decode_bitfield_value(bigbuf, value >> 8, 0xe0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number of fixes (LSB)", - bigbuf); + "%s : Number of fixes (LSB)", + bigbuf); other_decode_bitfield_value(bigbuf, value >> 8, 0x1f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Time between fixes (MSB), %u", - bigbuf, - (value & 0x001fe0) >> 5); + "%s : Time between fixes (MSB), %u", + bigbuf, + (value & 0x001fe0) >> 5); other_decode_bitfield_value(bigbuf, value, 0xe0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Time between fixes (LSB)", - bigbuf); + "%s : Time between fixes (LSB)", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x10, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Offset %srequested", - bigbuf, - (value & 0x10) ? "" : "not "); + "%s : Offset %srequested", + bigbuf, + (value & 0x10) ? "" : "not "); other_decode_bitfield_value(bigbuf, value, 0x08, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Desired pilot phase resolution: at least %s PN chip resolution", - bigbuf, - (value & 0x08) ? "1/8th" : "1"); + "%s : Desired pilot phase resolution: at least %s PN chip resolution", + bigbuf, + (value & 0x08) ? "1/8th" : "1"); other_decode_bitfield_value(bigbuf, value, 0x07, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset += 3; @@ -326,54 +326,54 @@ for_req_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, value >> 16, 0xe0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Preferred response quality, %u", - bigbuf, - (value & 0xe00000) >> 21); + "%s : Preferred response quality, %u", + bigbuf, + (value & 0xe00000) >> 21); other_decode_bitfield_value(bigbuf, value >> 16, 0x1f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number of fixes (MSB), %u", - bigbuf, - (value & 0x1fe000) >> 13); + "%s : Number of fixes (MSB), %u", + bigbuf, + (value & 0x1fe000) >> 13); other_decode_bitfield_value(bigbuf, value >> 8, 0xe0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number of fixes (LSB)", - bigbuf); + "%s : Number of fixes (LSB)", + bigbuf); other_decode_bitfield_value(bigbuf, value >> 8, 0x1f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Time between fixes (MSB), %u", - bigbuf, - (value & 0x001fe0) >> 5); + "%s : Time between fixes (MSB), %u", + bigbuf, + (value & 0x001fe0) >> 5); other_decode_bitfield_value(bigbuf, value, 0xe0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Time between fixes (LSB)", - bigbuf); + "%s : Time between fixes (LSB)", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x10, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Height information %srequested", - bigbuf, - (value & 0x10) ? "" : "not "); + "%s : Height information %srequested", + bigbuf, + (value & 0x10) ? "" : "not "); other_decode_bitfield_value(bigbuf, value, 0x08, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Clock correction for GPS time %srequested", - bigbuf, - (value & 0x08) ? "" : "not "); + "%s : Clock correction for GPS time %srequested", + bigbuf, + (value & 0x08) ? "" : "not "); other_decode_bitfield_value(bigbuf, value, 0x04, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Velocity information %srequested", - bigbuf, - (value & 0x04) ? "" : "not "); + "%s : Velocity information %srequested", + bigbuf, + (value & 0x04) ? "" : "not "); other_decode_bitfield_value(bigbuf, value, 0x03, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset += 3; @@ -395,28 +395,28 @@ for_req_time_off_meas(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset other_decode_bitfield_value(bigbuf, oct, 0x80, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Use action time indicator", - bigbuf); + "%s : Use action time indicator", + bigbuf); if (oct & 0x80) { - other_decode_bitfield_value(bigbuf, oct, 0x7e, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Action time, %u", - bigbuf, - (oct & 0x7e) >> 1); + other_decode_bitfield_value(bigbuf, oct, 0x7e, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Action time, %u", + bigbuf, + (oct & 0x7e) >> 1); - bit_mask = 0x01; + bit_mask = 0x01; } else { - bit_mask = 0x7f; + bit_mask = 0x7f; } other_decode_bitfield_value(bigbuf, oct, bit_mask, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -426,10 +426,10 @@ for_req_time_off_meas(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset static void for_req_cancel(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; - const gchar *str = NULL; - gint idx; + guint8 oct; + guint32 saved_offset; + const gchar *str = NULL; + gint idx; SHORT_DATA_CHECK(len, 1); @@ -440,20 +440,20 @@ for_req_cancel(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) str = match_strval_idx((oct & 0xf0) >> 4, for_req_type_strings, &idx); if (str == NULL) { - str = "Reserved"; + str = "Reserved"; } other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Cancellation Type: (%u) %s", - bigbuf, - (oct & 0xf0) >> 4, - str); + "%s : Cancellation Type: (%u) %s", + bigbuf, + (oct & 0xf0) >> 4, + str); other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -463,10 +463,10 @@ for_req_cancel(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) static void for_reject(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; - const gchar *str = NULL; - gint idx; + guint8 oct; + guint32 saved_offset; + const gchar *str = NULL; + gint idx; saved_offset = offset; @@ -477,15 +477,15 @@ for_reject(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) str = match_strval_idx((oct & 0xf0) >> 4, rev_req_type_strings, &idx); if (str == NULL) { - str = "Reserved"; + str = "Reserved"; } other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reject request type: (%u) %s", - bigbuf, - (oct & 0xf0) >> 4, - str); + "%s : Reject request type: (%u) %s", + bigbuf, + (oct & 0xf0) >> 4, + str); switch ((oct & 0x0e) >> 1) { @@ -496,14 +496,14 @@ for_reject(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, oct, 0x0e, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reject reason: %s", - bigbuf, - str); + "%s : Reject reason: %s", + bigbuf, + str); other_decode_bitfield_value(bigbuf, oct, 0x01, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -524,32 +524,32 @@ for_pr_bs_cap(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, oct, 0xfc, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : BS_LS_REV", - bigbuf); + "%s : BS_LS_REV", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x02, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : GPSC_ID: GPS capability indicator", - bigbuf); + "%s : GPSC_ID: GPS capability indicator", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x01, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : AFLTC_ID: Advanced forward link trilateration capability indicator", - bigbuf); + "%s : AFLTC_ID: Advanced forward link trilateration capability indicator", + bigbuf); offset++; oct = tvb_get_guint8(tvb, offset); if (oct == 0x00) { - proto_tree_add_text(tree, tvb, offset, 1, - "APDC_ID: Autonomous position determination capability indicator: None"); + proto_tree_add_text(tree, tvb, offset, 1, + "APDC_ID: Autonomous position determination capability indicator: None"); } else { - proto_tree_add_text(tree, tvb, offset, 1, - "APDC_ID: Autonomous position determination capability indicator: Autonomous Location Technology Identifier %u", - oct); + proto_tree_add_text(tree, tvb, offset, 1, + "APDC_ID: Autonomous position determination capability indicator: Autonomous Location Technology Identifier %u", + oct); } offset++; @@ -573,17 +573,17 @@ for_pr_gps_sense_ass(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, value, 0xffe0, 16); proto_tree_add_text(tree, tvb, offset, 2, - "%s : REF_BIT_NUM: %u", - bigbuf, - (value & 0xffe0) >> 5); + "%s : REF_BIT_NUM: %u", + bigbuf, + (value & 0xffe0) >> 5); num_dr_p = (value & 0x001e) >> 1; other_decode_bitfield_value(bigbuf, value, 0x001e, 16); proto_tree_add_text(tree, tvb, offset, 2, - "%s : NUM_DR_P: Number of data records in this part: %u", - bigbuf, - num_dr_p); + "%s : NUM_DR_P: Number of data records in this part: %u", + bigbuf, + num_dr_p); offset += 2; oct = tvb_get_guint8(tvb, offset); @@ -592,14 +592,14 @@ for_pr_gps_sense_ass(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) value = ((value & 0x0001) << 7) | ((oct & 0xfe) >> 1); proto_tree_add_text(tree, tvb, offset - 2, 2, - "%s : DR_SIZE: Data record size in 2-bit units (MSB): %u", - bigbuf, - value); + "%s : DR_SIZE: Data record size in 2-bit units (MSB): %u", + bigbuf, + value); other_decode_bitfield_value(bigbuf, oct, 0xfe, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : DR_SIZE: (LSB)", - bigbuf); + "%s : DR_SIZE: (LSB)", + bigbuf); value = oct; offset++; @@ -610,31 +610,31 @@ for_pr_gps_sense_ass(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) value = ((value & 0x0001) << 2) | ((oct & 0xc0) >> 6); proto_tree_add_text(tree, tvb, offset - 1, 1, - "%s : PART_NUM: The part number (MSB): %u", - bigbuf, - value); + "%s : PART_NUM: The part number (MSB): %u", + bigbuf, + value); other_decode_bitfield_value(bigbuf, oct, 0xc0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : PART_NUM: (LSB)", - bigbuf); + "%s : PART_NUM: (LSB)", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x38, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : TOTAL_PARTS: Total number of parts: %u", - bigbuf, - (oct & 0x38) >> 3); + "%s : TOTAL_PARTS: Total number of parts: %u", + bigbuf, + (oct & 0x38) >> 3); other_decode_bitfield_value(bigbuf, oct, 0x07, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Data records (MSB)", - bigbuf); + "%s : Data records (MSB)", + bigbuf); offset++; proto_tree_add_text(tree, tvb, offset, (len - (offset - saved_offset)), - "%s : Data records (LSB) + Reserved", - bigbuf); + "%s : Data records (LSB) + Reserved", + bigbuf); EXTRANEOUS_DATA_CHECK(len, offset - saved_offset); } @@ -655,39 +655,39 @@ for_pr_gps_almanac(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, value, 0xfc000000, 32); proto_tree_add_text(tree, tvb, offset, 4, - "%s : NUM_SV_P: Number of satellites in this part: %u", - bigbuf, - num_sv); + "%s : NUM_SV_P: Number of satellites in this part: %u", + bigbuf, + num_sv); other_decode_bitfield_value(bigbuf, value, 0x03fc0000, 32); proto_tree_add_text(tree, tvb, offset, 4, - "%s : WEEK_NUM: The GPS week number of the almanac: %u", - bigbuf, - (value & 0x03fc0000) >> 18); + "%s : WEEK_NUM: The GPS week number of the almanac: %u", + bigbuf, + (value & 0x03fc0000) >> 18); other_decode_bitfield_value(bigbuf, value, 0x0003fc00, 32); proto_tree_add_text(tree, tvb, offset, 4, - "%s : TOA: The reference time of the almanac: %u", - bigbuf, - (value & 0x0003fc00) >> 10); + "%s : TOA: The reference time of the almanac: %u", + bigbuf, + (value & 0x0003fc00) >> 10); other_decode_bitfield_value(bigbuf, value, 0x000003e0, 32); proto_tree_add_text(tree, tvb, offset, 4, - "%s : PART_NUM: The part number: %u", - bigbuf, - (value & 0x000003e0) >> 5); + "%s : PART_NUM: The part number: %u", + bigbuf, + (value & 0x000003e0) >> 5); other_decode_bitfield_value(bigbuf, value, 0x0000001f, 32); proto_tree_add_text(tree, tvb, offset, 4, - "%s : TOTAL_PARTS: The total number of parts: %u", - bigbuf, - (value & 0x0000001f)); + "%s : TOTAL_PARTS: The total number of parts: %u", + bigbuf, + (value & 0x0000001f)); offset += 4; proto_tree_add_text(tree, tvb, offset, (len - (offset - saved_offset)), - "%u Data records + Reserved", - num_sv); + "%u Data records + Reserved", + num_sv); EXTRANEOUS_DATA_CHECK(len, offset - saved_offset); } @@ -708,27 +708,27 @@ for_pr_gps_nav_msg_bits(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offs other_decode_bitfield_value(bigbuf, value, 0xfc00, 16); proto_tree_add_text(tree, tvb, offset, 2, - "%s : NUM_SV_P: Number of satellites in this part: %u", - bigbuf, - num_sv); + "%s : NUM_SV_P: Number of satellites in this part: %u", + bigbuf, + num_sv); other_decode_bitfield_value(bigbuf, value, 0x03e0, 16); proto_tree_add_text(tree, tvb, offset, 2, - "%s : PART_NUM: The part number: %u", - bigbuf, - (value & 0x03e0) >> 5); + "%s : PART_NUM: The part number: %u", + bigbuf, + (value & 0x03e0) >> 5); other_decode_bitfield_value(bigbuf, value, 0x001f, 16); proto_tree_add_text(tree, tvb, offset, 2, - "%s : TOTAL_PARTS: The total number of parts: %u", - bigbuf, - (value & 0x001f)); + "%s : TOTAL_PARTS: The total number of parts: %u", + bigbuf, + (value & 0x001f)); offset += 2; proto_tree_add_text(tree, tvb, offset, (len - (offset - saved_offset)), - "%u SUBF_4_5_INCL ... Data records + Reserved", - num_sv); + "%u SUBF_4_5_INCL ... Data records + Reserved", + num_sv); EXTRANEOUS_DATA_CHECK(len, offset - saved_offset); } @@ -744,12 +744,12 @@ static const true_false_string ansi_801_fix_type_vals = { static void pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint32 bit_offset, spare_bits; - guint32 value; - float fl_value; - guint32 saved_offset; - guint64 fix_type, velocity_incl, clock_incl, height_incl; - const gchar *str = NULL; + guint32 bit_offset, spare_bits; + guint32 value; + float fl_value; + guint32 saved_offset; + guint64 fix_type, velocity_incl, clock_incl, height_incl; + const gchar *str = NULL; SHORT_DATA_CHECK(len, 11); saved_offset = offset; @@ -758,28 +758,28 @@ pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) /* TIME_REF_CDMA */ value = tvb_get_bits16(tvb, bit_offset, 14, ENC_BIG_ENDIAN); proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_time_ref_cdma, tvb, bit_offset, 14, value * 50, - "%u frames (0x%04x)", value * 50, value); + "%u frames (0x%04x)", value * 50, value); bit_offset += 14; /* LAT */ value = tvb_get_bits32(tvb, bit_offset, 25, ENC_BIG_ENDIAN); fl_value = (float)(-90.0 + ((float)value * 180 / 33554432)); proto_tree_add_float_bits_format_value(tree, hf_ansi_801_lat, tvb, bit_offset, 25, fl_value, - "%.5f degrees %s (0x%08x)", fabs(fl_value), fl_value < 0 ? "South" : "North", value); + "%.5f degrees %s (0x%08x)", fabs(fl_value), fl_value < 0 ? "South" : "North", value); bit_offset += 25; /* LONG */ value = tvb_get_bits32(tvb, bit_offset, 26, ENC_BIG_ENDIAN); fl_value = (float)(-180.0 + ((float)value * 180 / 33554432)); proto_tree_add_float_bits_format_value(tree, hf_ansi_801_long, tvb, bit_offset, 26, fl_value, - "%.5f degrees %s (0x%08x)", fabs(fl_value), fl_value < 0 ? "West" : "East", value); + "%.5f degrees %s (0x%08x)", fabs(fl_value), fl_value < 0 ? "West" : "East", value); bit_offset += 26; /* LOC_UNCRTNTY_ANG */ value = tvb_get_bits8(tvb, bit_offset, 4); fl_value = (float)(5.625 * value); proto_tree_add_float_bits_format_value(tree, hf_ansi_801_loc_uncrtnty_ang, tvb, bit_offset, 4, fl_value, - "%.5f degrees (0x%02x)", fl_value, value); + "%.5f degrees (0x%02x)", fl_value, value); bit_offset += 4; /* LOC_UNCRTNTY_A */ @@ -795,7 +795,7 @@ pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) str = ep_strdup_printf("%.2f meters", fl_value); } proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_loc_uncrtnty_a, tvb, bit_offset, 5, value, - "%s (0x%02x)", str, value); + "%s (0x%02x)", str, value); bit_offset += 5; /* LOC_UNCRTNTY_P */ @@ -811,7 +811,7 @@ pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) str = ep_strdup_printf("%.2f meters", fl_value); } proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_loc_uncrtnty_p, tvb, bit_offset, 5, value, - "%s (0x%02x)", str, value); + "%s (0x%02x)", str, value); bit_offset += 5; /* FIX_TYPE */ @@ -827,14 +827,14 @@ pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) value = tvb_get_bits16(tvb, bit_offset, 9, ENC_BIG_ENDIAN); fl_value = (float)(0.25 * value); proto_tree_add_float_bits_format_value(tree, hf_ansi_801_velocity_hor, tvb, bit_offset, 9, fl_value, - "%.2f m/s (0x%04x)", fl_value, value); + "%.2f m/s (0x%04x)", fl_value, value); bit_offset += 9; /* HEADING */ value = tvb_get_bits16(tvb, bit_offset, 10, ENC_BIG_ENDIAN); fl_value = (float)value * 360 / 1024; proto_tree_add_float_bits_format_value(tree, hf_ansi_801_heading, tvb, bit_offset, 10, fl_value, - "%.3f degrees (0x%04x)", fl_value, value); + "%.3f degrees (0x%04x)", fl_value, value); bit_offset += 10; if(fix_type) @@ -843,7 +843,7 @@ pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) value = tvb_get_bits8(tvb, bit_offset, 8); fl_value = (float)(-64 + 0.5 * value); proto_tree_add_float_bits_format_value(tree, hf_ansi_801_velocity_ver, tvb, bit_offset, 8, fl_value, - "%.1f m/s (0x%02x)", fl_value, value); + "%.1f m/s (0x%02x)", fl_value, value); bit_offset += 8; } } @@ -856,13 +856,13 @@ pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) /* CLOCK_BIAS */ value = tvb_get_bits32(tvb, bit_offset, 18, ENC_BIG_ENDIAN); proto_tree_add_int_bits_format_value(tree, hf_ansi_801_clock_bias, tvb, bit_offset, 18, (gint32)value - 13000, - "%d ns (0x%06x)", (gint32)value - 13000, value); + "%d ns (0x%06x)", (gint32)value - 13000, value); bit_offset += 18; /* CLOCK_DRIFT */ value = tvb_get_bits16(tvb, bit_offset, 16, ENC_BIG_ENDIAN); proto_tree_add_int_bits_format_value(tree, hf_ansi_801_clock_drift, tvb, bit_offset, 16, (gint16)value, - "%d ppb (ns/s) (0x%04x)", (gint16)value, value); + "%d ppb (ns/s) (0x%04x)", (gint16)value, value); bit_offset += 16; } @@ -874,7 +874,7 @@ pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) /* HEIGHT */ value = tvb_get_bits16(tvb, bit_offset, 14, ENC_BIG_ENDIAN); proto_tree_add_int_bits_format_value(tree, hf_ansi_801_height, tvb, bit_offset, 14, (gint32)value - 500, - "%d m (0x%04x)", (gint32)value - 500, value); + "%d m (0x%04x)", (gint32)value - 500, value); bit_offset += 14; /* LOC_UNCRTNTY_V */ @@ -890,7 +890,7 @@ pr_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) str = ep_strdup_printf("%.2f meters", fl_value); } proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_loc_uncrtnty_v, tvb, bit_offset, 5, value, - "%s (0x%02x)", str, value); + "%s (0x%02x)", str, value); bit_offset += 5; } @@ -923,7 +923,7 @@ for_pr_gps_sat_health(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset SHORT_DATA_CHECK(len, 1); saved_offset = offset; bit_offset = offset << 3; - + /* BAD_SV_PRESENT */ proto_tree_add_bits_ret_val(tree, hf_ansi_801_bad_sv_present, tvb, bit_offset++, 1, &bad_sv_present, ENC_BIG_ENDIAN); @@ -932,7 +932,7 @@ for_pr_gps_sat_health(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset /* NUM_BAD_SV */ num_bad_sv = tvb_get_bits8(tvb, bit_offset, 4) + 1; proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_num_bad_sv, tvb, bit_offset, 4, num_bad_sv, - "%u", num_bad_sv); + "%u", num_bad_sv); bit_offset += 4; for (i=0; i < num_bad_sv; i++) @@ -940,7 +940,7 @@ for_pr_gps_sat_health(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset /* BAD_SV_PRN_NUM */ bad_sv_prn_num = tvb_get_bits8(tvb, bit_offset, 5) + 1; proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_bad_sv_prn_num, tvb, bit_offset, 5, bad_sv_prn_num, - "%u", bad_sv_prn_num); + "%u", bad_sv_prn_num); bit_offset += 5; } } @@ -980,8 +980,8 @@ rev_req_gps_acq_ass(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) static void rev_req_gps_loc_ass(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; + guint8 oct; + guint32 saved_offset; SHORT_DATA_CHECK(len, 1); @@ -991,14 +991,14 @@ rev_req_gps_loc_ass(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, oct, 0x80, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Coordinate type requested: %s coordinates", - bigbuf, - (oct & 0x80) ? "Spherical" : "Cartesian"); + "%s : Coordinate type requested: %s coordinates", + bigbuf, + (oct & 0x80) ? "Spherical" : "Cartesian"); other_decode_bitfield_value(bigbuf, oct, 0x7f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -1008,8 +1008,8 @@ rev_req_gps_loc_ass(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) static void rev_req_bs_alm(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; + guint8 oct; + guint32 saved_offset; SHORT_DATA_CHECK(len, 1); @@ -1019,14 +1019,14 @@ rev_req_bs_alm(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, oct, 0x80, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Extended base station almanac %srequested", - bigbuf, - (oct & 0x80) ? "" : "not "); + "%s : Extended base station almanac %srequested", + bigbuf, + (oct & 0x80) ? "" : "not "); other_decode_bitfield_value(bigbuf, oct, 0x7f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -1036,8 +1036,8 @@ rev_req_bs_alm(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) static void rev_req_gps_ephemeris(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; + guint8 oct; + guint32 saved_offset; SHORT_DATA_CHECK(len, 1); @@ -1047,14 +1047,14 @@ rev_req_gps_ephemeris(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset other_decode_bitfield_value(bigbuf, oct, 0x80, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Alpha and Beta parameters %srequested", - bigbuf, - (oct & 0x80) ? "" : "not "); + "%s : Alpha and Beta parameters %srequested", + bigbuf, + (oct & 0x80) ? "" : "not "); other_decode_bitfield_value(bigbuf, oct, 0x7f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -1064,8 +1064,8 @@ rev_req_gps_ephemeris(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset static void rev_req_gps_nav_msg_bits(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; + guint8 oct; + guint32 saved_offset; SHORT_DATA_CHECK(len, 1); @@ -1075,14 +1075,14 @@ rev_req_gps_nav_msg_bits(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 off other_decode_bitfield_value(bigbuf, oct, 0x80, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Subframes 4 and 5 %srequested", - bigbuf, - (oct & 0x80) ? "" : "not "); + "%s : Subframes 4 and 5 %srequested", + bigbuf, + (oct & 0x80) ? "" : "not "); other_decode_bitfield_value(bigbuf, oct, 0x7f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -1092,8 +1092,8 @@ rev_req_gps_nav_msg_bits(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 off static void rev_req_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; + guint8 oct; + guint32 saved_offset; SHORT_DATA_CHECK(len, 1); @@ -1103,26 +1103,26 @@ rev_req_loc_response(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, oct, 0x80, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Height information %srequested", - bigbuf, - (oct & 0x80) ? "" : "not "); + "%s : Height information %srequested", + bigbuf, + (oct & 0x80) ? "" : "not "); other_decode_bitfield_value(bigbuf, oct, 0x40, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Clock correction for GPS time %srequested", - bigbuf, - (oct & 0x40) ? "" : "not "); + "%s : Clock correction for GPS time %srequested", + bigbuf, + (oct & 0x40) ? "" : "not "); other_decode_bitfield_value(bigbuf, oct, 0x20, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Velocity information %srequested", - bigbuf, - (oct & 0x20) ? "" : "not "); + "%s : Velocity information %srequested", + bigbuf, + (oct & 0x20) ? "" : "not "); other_decode_bitfield_value(bigbuf, oct, 0x1f, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -1139,11 +1139,11 @@ rev_req_gps_alm_correction(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 o saved_offset = offset; proto_tree_add_text(tree, tvb, offset, 1, - "Time of almanac (in units of 4096 seconds)"); + "Time of almanac (in units of 4096 seconds)"); offset++; proto_tree_add_text(tree, tvb, offset, 1, - "GPS week number (8 least significant bits)"); + "GPS week number (8 least significant bits)"); offset++; @@ -1153,10 +1153,10 @@ rev_req_gps_alm_correction(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 o static void rev_reject(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; - const gchar *str = NULL; - gint idx; + guint8 oct; + guint32 saved_offset; + const gchar *str = NULL; + gint idx; saved_offset = offset; @@ -1167,15 +1167,15 @@ rev_reject(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) str = match_strval_idx((oct & 0xf0) >> 4, for_req_type_strings, &idx); if (str == NULL) { - str = "Reserved"; + str = "Reserved"; } other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reject request type: (%u) %s", - bigbuf, - (oct & 0xf0) >> 4, - str); + "%s : Reject request type: (%u) %s", + bigbuf, + (oct & 0xf0) >> 4, + str); switch ((oct & 0x0e) >> 1) { @@ -1186,14 +1186,14 @@ rev_reject(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) other_decode_bitfield_value(bigbuf, oct, 0x0e, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reject reason: %s", - bigbuf, - str); + "%s : Reject reason: %s", + bigbuf, + str); other_decode_bitfield_value(bigbuf, oct, 0x01, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -1203,9 +1203,9 @@ rev_reject(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) static void rev_pr_ms_information(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint32 value; - guint32 saved_offset; - const gchar *str = NULL; + guint32 value; + guint32 saved_offset; + const gchar *str = NULL; saved_offset = offset; @@ -1215,13 +1215,13 @@ rev_pr_ms_information(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset other_decode_bitfield_value(bigbuf, value, 0xfc00, 16); proto_tree_add_text(tree, tvb, offset, 2, - "%s : MS_LS_REV", - bigbuf); + "%s : MS_LS_REV", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x03c0, 16); proto_tree_add_text(tree, tvb, offset, 2, - "%s : MS_MODE", - bigbuf); + "%s : MS_MODE", + bigbuf); switch (value & 0x003f) { @@ -1235,103 +1235,103 @@ rev_pr_ms_information(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset other_decode_bitfield_value(bigbuf, value, 0x003f, 16); proto_tree_add_text(tree, tvb, offset, 2, - "%s : PILOT_PH_CAP: (%u) %s", - bigbuf, - value & 0x3f, - str); + "%s : PILOT_PH_CAP: (%u) %s", + bigbuf, + value & 0x3f, + str); offset += 2; value = tvb_get_ntoh24(tvb, offset); other_decode_bitfield_value(bigbuf, value, 0xf80000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : GPS_ACQ_CAP: Reserved", - bigbuf); + "%s : GPS_ACQ_CAP: Reserved", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x040000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : GPS_ACQ_CAP: GPS Autonomous Acquisition Capable", - bigbuf); + "%s : GPS_ACQ_CAP: GPS Autonomous Acquisition Capable", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x020000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : GPS_ACQ_CAP: GPS Almanac Correction", - bigbuf); + "%s : GPS_ACQ_CAP: GPS Almanac Correction", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x010000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : GPS_ACQ_CAP: GPS Navigation Message Bits", - bigbuf); + "%s : GPS_ACQ_CAP: GPS Navigation Message Bits", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x008000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : GPS_ACQ_CAP: GPS Ephemeris", - bigbuf); + "%s : GPS_ACQ_CAP: GPS Ephemeris", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x004000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : GPS_ACQ_CAP: GPS Almanac", - bigbuf); + "%s : GPS_ACQ_CAP: GPS Almanac", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x002000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : GPS_ACQ_CAP: GPS Sensitivity Assistance", - bigbuf); + "%s : GPS_ACQ_CAP: GPS Sensitivity Assistance", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x001000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : GPS_ACQ_CAP: GPS Acquisition Assistance", - bigbuf); + "%s : GPS_ACQ_CAP: GPS Acquisition Assistance", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000800, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Pre-programmed Location", - bigbuf); + "%s : LOC_CALC_CAP: Pre-programmed Location", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000700, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Reserved", - bigbuf); + "%s : LOC_CALC_CAP: Reserved", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000080, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Hybrid GPS and AFLT Location Calculation Capable", - bigbuf); + "%s : LOC_CALC_CAP: Hybrid GPS and AFLT Location Calculation Capable", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000040, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Autonomous Location Calculation Capable", - bigbuf); + "%s : LOC_CALC_CAP: Autonomous Location Calculation Capable", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000020, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Location Calculation Capable using GPS Almanac Correction", - bigbuf); + "%s : LOC_CALC_CAP: Location Calculation Capable using GPS Almanac Correction", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000010, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Location Calculation Capable using GPS Ephemeris Assistance", - bigbuf); + "%s : LOC_CALC_CAP: Location Calculation Capable using GPS Ephemeris Assistance", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000008, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Location Calculation Capable using GPS Almanac Assistance", - bigbuf); + "%s : LOC_CALC_CAP: Location Calculation Capable using GPS Almanac Assistance", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000004, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Advanced Forward Link Trilateration (AFLT) Location Calculation Capable", - bigbuf); + "%s : LOC_CALC_CAP: Advanced Forward Link Trilateration (AFLT) Location Calculation Capable", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000002, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Location Calculation Capable using Location Assistance - Cartesian", - bigbuf); + "%s : LOC_CALC_CAP: Location Calculation Capable using Location Assistance - Cartesian", + bigbuf); other_decode_bitfield_value(bigbuf, value, 0x000001, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : LOC_CALC_CAP: Location Calculation Capable using Location Assistance - Spherical", - bigbuf); + "%s : LOC_CALC_CAP: Location Calculation Capable using Location Assistance - Spherical", + bigbuf); offset += 3; @@ -1355,27 +1355,27 @@ rev_pr_time_off_meas(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) SHORT_DATA_CHECK(len, 6); proto_tree_add_text(tree, tvb, offset, 3, - "TIME_REF_MS: The time of validity of the parameters reported in this response element."); + "TIME_REF_MS: The time of validity of the parameters reported in this response element."); offset += 3; value = tvb_get_ntoh24(tvb, offset); other_decode_bitfield_value(bigbuf, value, 0xff8000, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : REF_PN: (%u)", - bigbuf, - (value & 0xff8000) >> 15); + "%s : REF_PN: (%u)", + bigbuf, + (value & 0xff8000) >> 15); other_decode_bitfield_value(bigbuf, value, 0x007ffe, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : MOB_SYS_T_OFFSET: (%u)", - bigbuf, - (value & 0x007ffe) >> 1); + "%s : MOB_SYS_T_OFFSET: (%u)", + bigbuf, + (value & 0x007ffe) >> 1); other_decode_bitfield_value(bigbuf, value, 0x000001, 24); proto_tree_add_text(tree, tvb, offset, 3, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset += 3; @@ -1385,10 +1385,10 @@ rev_pr_time_off_meas(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) static void rev_pr_can_ack(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) { - guint8 oct; - guint32 saved_offset; - const gchar *str = NULL; - gint idx; + guint8 oct; + guint32 saved_offset; + const gchar *str = NULL; + gint idx; saved_offset = offset; @@ -1399,25 +1399,25 @@ rev_pr_can_ack(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) str = match_strval_idx((oct & 0xf0) >> 4, for_req_type_strings, &idx); if (str == NULL) { - str = "Reserved"; + str = "Reserved"; } other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Cancellation Type: (%u) %s", - bigbuf, - (oct & 0xf0) >> 4, - str); + "%s : Cancellation Type: (%u) %s", + bigbuf, + (oct & 0xf0) >> 4, + str); other_decode_bitfield_value(bigbuf, oct, 0x08, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : No outstanding request element", - bigbuf); + "%s : No outstanding request element", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x07, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); offset++; @@ -1425,106 +1425,106 @@ rev_pr_can_ack(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) } static void (*for_req_type_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) = { - NULL, /* Reserved */ + NULL, /* Reserved */ NULL, /* no data */ /* Request MS Information */ NULL, /* no data */ /* Request Autonomous Measurement Weighting Factors */ for_req_pseudo_meas, /* Request Pseudorange Measurement */ for_req_pilot_ph_meas, /* Request Pilot Phase Measurement */ for_req_loc_response, /* Request Location Response */ for_req_time_off_meas, /* Request Time Offset Measurement */ - for_req_cancel, /* Request Cancellation */ - NULL, /* NONE */ + for_req_cancel, /* Request Cancellation */ + NULL, /* NONE */ }; static void (*for_rsp_type_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) = { - for_reject, /* Reject */ - for_pr_bs_cap, /* Provide BS Capabilities */ - NULL, /* Provide GPS Acquisition Assistance */ - NULL, /* Provide GPS Location Assistance Spherical Coordinates */ - NULL, /* Provide GPS Location Assistance Cartesian Coordinates */ - for_pr_gps_sense_ass, /* Provide GPS Sensitivity Assistance */ - NULL, /* Provide Base Station Almanac */ - for_pr_gps_almanac, /* Provide GPS Almanac */ - NULL, /* Provide GPS Ephemeris */ - for_pr_gps_nav_msg_bits, /* Provide GPS Navigation Message Bits */ - for_pr_loc_response, /* Provide Location Response */ - NULL, /* Provide GPS Almanac Correction */ - for_pr_gps_sat_health, /* Provide GPS Satellite Health Information */ - NULL, /* NONE */ + for_reject, /* Reject */ + for_pr_bs_cap, /* Provide BS Capabilities */ + NULL, /* Provide GPS Acquisition Assistance */ + NULL, /* Provide GPS Location Assistance Spherical Coordinates */ + NULL, /* Provide GPS Location Assistance Cartesian Coordinates */ + for_pr_gps_sense_ass, /* Provide GPS Sensitivity Assistance */ + NULL, /* Provide Base Station Almanac */ + for_pr_gps_almanac, /* Provide GPS Almanac */ + NULL, /* Provide GPS Ephemeris */ + for_pr_gps_nav_msg_bits, /* Provide GPS Navigation Message Bits */ + for_pr_loc_response, /* Provide Location Response */ + NULL, /* Provide GPS Almanac Correction */ + for_pr_gps_sat_health, /* Provide GPS Satellite Health Information */ + NULL, /* NONE */ }; static void (*rev_req_type_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) = { NULL, /* Reserved */ - NULL, /* no data */ /* Request BS Capabilities */ - rev_req_gps_acq_ass, /* Request GPS Acquisition Assistance */ - rev_req_gps_loc_ass, /* Request GPS Location Assistance */ + NULL, /* no data */ /* Request BS Capabilities */ + rev_req_gps_acq_ass, /* Request GPS Acquisition Assistance */ + rev_req_gps_loc_ass, /* Request GPS Location Assistance */ NULL, /* Reserved */ - NULL, /* no data */ /* Request GPS Sensitivity Assistance */ - rev_req_bs_alm, /* Request Base Station Almanac */ - NULL, /* no data */ /* Request GPS Almanac */ - rev_req_gps_ephemeris, /* Request GPS Ephemeris */ + NULL, /* no data */ /* Request GPS Sensitivity Assistance */ + rev_req_bs_alm, /* Request Base Station Almanac */ + NULL, /* no data */ /* Request GPS Almanac */ + rev_req_gps_ephemeris, /* Request GPS Ephemeris */ rev_req_gps_nav_msg_bits, /* Request GPS Navigation Message Bits */ - rev_req_loc_response, /* Request Location Response */ + rev_req_loc_response, /* Request Location Response */ rev_req_gps_alm_correction, /* Request GPS Almanac Correction */ - NULL, /* no data */ /* Request GPS Satellite Health Information */ + NULL, /* no data */ /* Request GPS Satellite Health Information */ NULL, /* NONE */ }; static void (*rev_rsp_type_fcn[])(tvbuff_t *tvb, proto_tree *tree, guint len, guint32 offset) = { - rev_reject, /* Reject */ - rev_pr_ms_information, /* Provide MS Information */ - NULL, /* Provide Autonomous Measurement Weighting Factors */ - NULL, /* Provide Pseudorange Measurement */ - NULL, /* Provide Pilot Phase Measurement */ - rev_pr_loc_response, /* Provide Location Response */ - rev_pr_time_off_meas, /* Provide Time Offset Measurement */ - rev_pr_can_ack, /* Provide Cancellation Acknowledgement */ - NULL, /* NONE */ + rev_reject, /* Reject */ + rev_pr_ms_information, /* Provide MS Information */ + NULL, /* Provide Autonomous Measurement Weighting Factors */ + NULL, /* Provide Pseudorange Measurement */ + NULL, /* Provide Pilot Phase Measurement */ + rev_pr_loc_response, /* Provide Location Response */ + rev_pr_time_off_meas, /* Provide Time Offset Measurement */ + rev_pr_can_ack, /* Provide Cancellation Acknowledgement */ + NULL, /* NONE */ }; static void for_request(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p, guint8 pd_msg_type) { - guint32 offset; - guint8 oct; - const gchar *str = NULL; - gint idx; - proto_tree *subtree; - proto_item *item; + guint32 offset; + guint8 oct; + const gchar *str = NULL; + gint idx; + proto_tree *subtree; + proto_item *item; offset = *offset_p; oct = tvb_get_guint8(tvb, offset); if (pd_msg_type == 0x00) { - other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Reserved", + bigbuf); - str = match_strval_idx(oct & 0x0f, for_req_type_strings, &idx); - if (str == NULL) - { - return; - } + str = match_strval_idx(oct & 0x0f, for_req_type_strings, &idx); + if (str == NULL) + { + return; + } - other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); - item = - proto_tree_add_uint_format(tree, hf_ansi_801_for_req_type, tvb, offset, - 1, oct & 0x0f, - "%s : Request Type, %s (%u)", - bigbuf, - str, - oct & 0x0f); + other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); + item = + proto_tree_add_uint_format(tree, hf_ansi_801_for_req_type, tvb, offset, + 1, oct & 0x0f, + "%s : Request Type, %s (%u)", + bigbuf, + str, + oct & 0x0f); } else { - /* TBD */ - /* - * It is unclear from TIA-801-A how this was meant to be decoded. - * Are the elements supposed to be byte aligned? - */ - return; + /* TBD */ + /* + * It is unclear from TIA-801-A how this was meant to be decoded. + * Are the elements supposed to be byte aligned? + */ + return; } subtree = proto_item_add_subtree(item, ett_for_req_type[idx]); @@ -1533,22 +1533,22 @@ for_request(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p, guint8 pd_msg_ty oct = tvb_get_guint8(tvb, offset); proto_tree_add_text(subtree, tvb, offset, 1, - "Length: %u", - oct); + "Length: %u", + oct); offset++; if (oct > 0) { - if (for_req_type_fcn[idx] != NULL) - { - (*for_req_type_fcn[idx])(tvb, subtree, oct, offset); - } - else - { - proto_tree_add_text(subtree, tvb, offset, oct, - "Data"); - } + if (for_req_type_fcn[idx] != NULL) + { + (*for_req_type_fcn[idx])(tvb, subtree, oct, offset); + } + else + { + proto_tree_add_text(subtree, tvb, offset, oct, + "Data"); + } } *offset_p = offset + oct; @@ -1557,41 +1557,41 @@ for_request(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p, guint8 pd_msg_ty static void for_response(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p) { - guint32 offset; - guint8 oct; - const gchar *str = NULL; - gint idx; - proto_tree *subtree; - proto_item *item; + guint32 offset; + guint8 oct; + const gchar *str = NULL; + gint idx; + proto_tree *subtree; + proto_item *item; offset = *offset_p; oct = tvb_get_guint8(tvb, offset); other_decode_bitfield_value(bigbuf, oct, 0xe0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x10, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Unsolicited response indicator", - bigbuf); + "%s : Unsolicited response indicator", + bigbuf); str = match_strval_idx(oct & 0x0f, for_rsp_type_strings, &idx); if (str == NULL) { - return; + return; } other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); item = - proto_tree_add_uint_format(tree, hf_ansi_801_for_rsp_type, tvb, offset, - 1, oct & 0x0f, - "%s : Response Type, %s (%u)", - bigbuf, - str, - oct & 0x0f); + proto_tree_add_uint_format(tree, hf_ansi_801_for_rsp_type, tvb, offset, + 1, oct & 0x0f, + "%s : Response Type, %s (%u)", + bigbuf, + str, + oct & 0x0f); subtree = proto_item_add_subtree(item, ett_for_rsp_type[idx]); @@ -1599,19 +1599,19 @@ for_response(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p) oct = tvb_get_guint8(tvb, offset); proto_tree_add_text(subtree, tvb, offset, 1, - "Length: %u", - oct); + "Length: %u", + oct); offset++; if (for_rsp_type_fcn[idx] != NULL) { - (*for_rsp_type_fcn[idx])(tvb, subtree, oct, offset); + (*for_rsp_type_fcn[idx])(tvb, subtree, oct, offset); } else { - proto_tree_add_text(subtree, tvb, offset, oct, - "Data"); + proto_tree_add_text(subtree, tvb, offset, oct, + "Data"); } *offset_p = offset + oct; @@ -1620,46 +1620,46 @@ for_response(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p) static void rev_request(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p, guint8 pd_msg_type) { - guint32 offset; - guint8 oct; - const gchar *str = NULL; - gint idx; - proto_tree *subtree; - proto_item *item; + guint32 offset; + guint8 oct; + const gchar *str = NULL; + gint idx; + proto_tree *subtree; + proto_item *item; offset = *offset_p; oct = tvb_get_guint8(tvb, offset); if (pd_msg_type == 0x00) { - other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Reserved", + bigbuf); - str = match_strval_idx(oct & 0x0f, rev_req_type_strings, &idx); - if (str == NULL) - { - return; - } + str = match_strval_idx(oct & 0x0f, rev_req_type_strings, &idx); + if (str == NULL) + { + return; + } - other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); - item = - proto_tree_add_uint_format(tree, hf_ansi_801_rev_req_type, tvb, offset, - 1, oct & 0x0f, - "%s : Request Type, %s (%u)", - bigbuf, - str, - oct & 0x0f); + other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); + item = + proto_tree_add_uint_format(tree, hf_ansi_801_rev_req_type, tvb, offset, + 1, oct & 0x0f, + "%s : Request Type, %s (%u)", + bigbuf, + str, + oct & 0x0f); } else { - /* TBD */ - /* - * It is unclear from TIA-801-A how this was meant to be decoded. - * Are the elements supposed to be byte aligned? - */ - return; + /* TBD */ + /* + * It is unclear from TIA-801-A how this was meant to be decoded. + * Are the elements supposed to be byte aligned? + */ + return; } subtree = proto_item_add_subtree(item, ett_rev_req_type[idx]); @@ -1668,19 +1668,19 @@ rev_request(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p, guint8 pd_msg_ty oct = tvb_get_guint8(tvb, offset); proto_tree_add_text(subtree, tvb, offset, 1, - "Length: %u", - oct); + "Length: %u", + oct); offset++; if (rev_req_type_fcn[idx] != NULL) { - (*rev_req_type_fcn[idx])(tvb, subtree, oct, offset); + (*rev_req_type_fcn[idx])(tvb, subtree, oct, offset); } else { - proto_tree_add_text(subtree, tvb, offset, oct, - "Data"); + proto_tree_add_text(subtree, tvb, offset, oct, + "Data"); } *offset_p = offset + oct; @@ -1689,41 +1689,41 @@ rev_request(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p, guint8 pd_msg_ty static void rev_response(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p) { - guint32 offset; - guint8 oct; - const gchar *str = NULL; - gint idx; - proto_tree *subtree; - proto_item *item; + guint32 offset; + guint8 oct; + const gchar *str = NULL; + gint idx; + proto_tree *subtree; + proto_item *item; offset = *offset_p; oct = tvb_get_guint8(tvb, offset); other_decode_bitfield_value(bigbuf, oct, 0xe0, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Reserved", - bigbuf); + "%s : Reserved", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x10, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Unsolicited response indicator", - bigbuf); + "%s : Unsolicited response indicator", + bigbuf); str = match_strval_idx(oct & 0x0f, rev_rsp_type_strings, &idx); if (str == NULL) { - return; + return; } other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); item = - proto_tree_add_uint_format(tree, hf_ansi_801_rev_rsp_type, tvb, offset, - 1, oct & 0x0f, - "%s : Response Type, %s (%u)", - bigbuf, - str, - oct & 0x0f); + proto_tree_add_uint_format(tree, hf_ansi_801_rev_rsp_type, tvb, offset, + 1, oct & 0x0f, + "%s : Response Type, %s (%u)", + bigbuf, + str, + oct & 0x0f); subtree = proto_item_add_subtree(item, ett_rev_rsp_type[idx]); @@ -1731,19 +1731,19 @@ rev_response(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p) oct = tvb_get_guint8(tvb, offset); proto_tree_add_text(subtree, tvb, offset, 1, - "Length: %u", - oct); + "Length: %u", + oct); offset++; if (rev_rsp_type_fcn[idx] != NULL) { - (*rev_rsp_type_fcn[idx])(tvb, subtree, oct, offset); + (*rev_rsp_type_fcn[idx])(tvb, subtree, oct, offset); } else { - proto_tree_add_text(subtree, tvb, offset, oct, - "Data"); + proto_tree_add_text(subtree, tvb, offset, oct, + "Data"); } *offset_p = offset + oct; @@ -1752,40 +1752,40 @@ rev_response(tvbuff_t *tvb, proto_tree *tree, guint32 *offset_p) static void dissect_ansi_801_for_message(tvbuff_t *tvb, proto_tree *tree) { - guint32 value; - guint32 offset; - guint8 oct, num_req, num_rsp, pd_msg_type; - guint rem_len; - const gchar *str = NULL; - proto_item *hidden_item; + guint32 value; + guint32 offset; + guint8 oct, num_req, num_rsp, pd_msg_type; + guint rem_len; + const gchar *str = NULL; + proto_item *hidden_item; offset = 0; oct = tvb_get_guint8(tvb, offset); other_decode_bitfield_value(bigbuf, oct, 0x80, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Session Start", - bigbuf); + "%s : Session Start", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x40, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Session End", - bigbuf); + "%s : Session End", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x20, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Session Source", - bigbuf); + "%s : Session Source", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x1f, 8); proto_tree_add_uint_format(tree, hf_ansi_801_for_sess_tag, tvb, offset, - 1, oct & 0x1f, - "%s : Session Tag (%u)", - bigbuf, - oct & 0x1f); + 1, oct & 0x1f, + "%s : Session Tag (%u)", + bigbuf, + oct & 0x1f); hidden_item = proto_tree_add_uint(tree, hf_ansi_801_sess_tag, tvb, offset, - 1, oct & 0x1f); + 1, oct & 0x1f); PROTO_ITEM_SET_HIDDEN(hidden_item); offset++; @@ -1798,181 +1798,181 @@ dissect_ansi_801_for_message(tvbuff_t *tvb, proto_tree *tree) case 0x01: str = "Position Determination Data Message"; break; case 0xff: str = "Reserved"; break; default: - if (pd_msg_type < 0xc0) - { - str = "Reserved for future standardization"; - } - else - { - str = - "Available for manufacturer-specific Position Determination " - "Data Message definition as specified in TSB-58"; - } - break; + if (pd_msg_type < 0xc0) + { + str = "Reserved for future standardization"; + } + else + { + str = + "Available for manufacturer-specific Position Determination " + "Data Message definition as specified in TSB-58"; + } + break; } other_decode_bitfield_value(bigbuf, pd_msg_type, 0xff, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : PD Message Type, %s (%u)", - bigbuf, - str, - pd_msg_type); + "%s : PD Message Type, %s (%u)", + bigbuf, + str, + pd_msg_type); offset++; if ((pd_msg_type != 0x00) && - (pd_msg_type != 0x01)) + (pd_msg_type != 0x01)) { - proto_tree_add_text(tree, tvb, offset, -1, - "Reserved/Proprietary/Future Data"); - return; + proto_tree_add_text(tree, tvb, offset, -1, + "Reserved/Proprietary/Future Data"); + return; } if (pd_msg_type == 0x01) { - value = tvb_get_ntohs(tvb, offset); + value = tvb_get_ntohs(tvb, offset); - other_decode_bitfield_value(bigbuf, value, 0xffc0, 16); - proto_tree_add_text(tree, tvb, offset, 2, - "%s : PD Message Length, (%u)", - bigbuf, - (value & 0xffc0) >> 6); + other_decode_bitfield_value(bigbuf, value, 0xffc0, 16); + proto_tree_add_text(tree, tvb, offset, 2, + "%s : PD Message Length, (%u)", + bigbuf, + (value & 0xffc0) >> 6); - switch ((value & 0x0030) >> 4) - { - case 0x00: str = "No Regulatory service"; break; - case 0x01: str = "Emergency service"; break; - default: str = "Reserved"; break; - } + switch ((value & 0x0030) >> 4) + { + case 0x00: str = "No Regulatory service"; break; + case 0x01: str = "Emergency service"; break; + default: str = "Reserved"; break; + } - other_decode_bitfield_value(bigbuf, value, 0x0030, 16); - proto_tree_add_text(tree, tvb, offset, 2, - "%s : Regulatory Services Indicator - %s (%u)", - bigbuf, - str, - (value & 0x0030) >> 4); + other_decode_bitfield_value(bigbuf, value, 0x0030, 16); + proto_tree_add_text(tree, tvb, offset, 2, + "%s : Regulatory Services Indicator - %s (%u)", + bigbuf, + str, + (value & 0x0030) >> 4); - num_req = value & 0x000f; + num_req = value & 0x000f; - other_decode_bitfield_value(bigbuf, value, 0x000f, 16); - proto_tree_add_text(tree, tvb, offset, 2, - "%s : Number Requests (%u)", - bigbuf, - num_req); + other_decode_bitfield_value(bigbuf, value, 0x000f, 16); + proto_tree_add_text(tree, tvb, offset, 2, + "%s : Number Requests (%u)", + bigbuf, + num_req); - offset += 2; + offset += 2; - oct = tvb_get_guint8(tvb, offset); + oct = tvb_get_guint8(tvb, offset); - num_rsp = oct & 0xf0; + num_rsp = oct & 0xf0; - other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number Responses (%u)", - bigbuf, - num_rsp); + other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Number Responses (%u)", + bigbuf, + num_rsp); - offset++; + offset++; } else { - oct = tvb_get_guint8(tvb, offset); + oct = tvb_get_guint8(tvb, offset); - num_req = (oct & 0xf0) >> 4; - num_rsp = oct & 0x0f; + num_req = (oct & 0xf0) >> 4; + num_rsp = oct & 0x0f; - other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number Requests (%u)", - bigbuf, - num_req); + other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Number Requests (%u)", + bigbuf, + num_req); - other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number Responses (%u)", - bigbuf, - num_rsp); + other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Number Responses (%u)", + bigbuf, + num_rsp); } offset++; rem_len = tvb_length_remaining(tvb, offset); while ((num_req > 0) && - (rem_len >= 2)) + (rem_len >= 2)) { - for_request(tvb, tree, &offset, pd_msg_type); + for_request(tvb, tree, &offset, pd_msg_type); - rem_len = tvb_length_remaining(tvb, offset); - num_req--; + rem_len = tvb_length_remaining(tvb, offset); + num_req--; } if (num_req != 0) { - proto_tree_add_text(tree, tvb, - offset, -1, "Short Data (?)"); - return; + proto_tree_add_text(tree, tvb, + offset, -1, "Short Data (?)"); + return; } while ((num_rsp > 0) && - (rem_len >= 2)) + (rem_len >= 2)) { - for_response(tvb, tree, &offset); + for_response(tvb, tree, &offset); - rem_len = tvb_length_remaining(tvb, offset); - num_rsp--; + rem_len = tvb_length_remaining(tvb, offset); + num_rsp--; } if (num_rsp != 0) { - proto_tree_add_text(tree, tvb, - offset, -1, "Short Data (?)"); - return; + proto_tree_add_text(tree, tvb, + offset, -1, "Short Data (?)"); + return; } if (rem_len > 0) { - proto_tree_add_text(tree, tvb, offset, rem_len, - "Extraneous Data"); + proto_tree_add_text(tree, tvb, offset, rem_len, + "Extraneous Data"); } } static void dissect_ansi_801_rev_message(tvbuff_t *tvb, proto_tree *tree) { - guint32 value; - guint32 offset; - guint8 oct, num_req, num_rsp, pd_msg_type; - guint rem_len; - const gchar *str = NULL; - proto_item *hidden_item; + guint32 value; + guint32 offset; + guint8 oct, num_req, num_rsp, pd_msg_type; + guint rem_len; + const gchar *str = NULL; + proto_item *hidden_item; offset = 0; oct = tvb_get_guint8(tvb, offset); other_decode_bitfield_value(bigbuf, oct, 0x80, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Session Start", - bigbuf); + "%s : Session Start", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x40, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Session End", - bigbuf); + "%s : Session End", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x20, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : Session Source", - bigbuf); + "%s : Session Source", + bigbuf); other_decode_bitfield_value(bigbuf, oct, 0x1f, 8); proto_tree_add_uint_format(tree, hf_ansi_801_rev_sess_tag, tvb, offset, - 1, oct & 0x1f, - "%s : Session Tag (%u)", - bigbuf, - oct & 0x1f); + 1, oct & 0x1f, + "%s : Session Tag (%u)", + bigbuf, + oct & 0x1f); hidden_item = proto_tree_add_uint(tree, hf_ansi_801_sess_tag, tvb, offset, - 1, oct & 0x1f); + 1, oct & 0x1f); PROTO_ITEM_SET_HIDDEN(hidden_item); offset++; @@ -1985,150 +1985,150 @@ dissect_ansi_801_rev_message(tvbuff_t *tvb, proto_tree *tree) case 0x01: str = "Position Determination Data Message"; break; case 0xff: str = "Reserved"; break; default: - if (pd_msg_type < 0xc0) - { - str = "Reserved for future standardization"; - } - else - { - str = - "Available for manufacturer-specific Position Determination " - "Data Message definition as specified in TSB-58"; - } - break; + if (pd_msg_type < 0xc0) + { + str = "Reserved for future standardization"; + } + else + { + str = + "Available for manufacturer-specific Position Determination " + "Data Message definition as specified in TSB-58"; + } + break; } other_decode_bitfield_value(bigbuf, pd_msg_type, 0xff, 8); proto_tree_add_text(tree, tvb, offset, 1, - "%s : PD Message Type, %s (%u)", - bigbuf, - str, - pd_msg_type); + "%s : PD Message Type, %s (%u)", + bigbuf, + str, + pd_msg_type); offset++; if ((pd_msg_type != 0x00) && - (pd_msg_type != 0x01)) + (pd_msg_type != 0x01)) { - proto_tree_add_text(tree, tvb, offset, -1, - "Reserved/Proprietary/Future Data"); - return; + proto_tree_add_text(tree, tvb, offset, -1, + "Reserved/Proprietary/Future Data"); + return; } if (pd_msg_type == 0x01) { - value = tvb_get_ntohs(tvb, offset); + value = tvb_get_ntohs(tvb, offset); - other_decode_bitfield_value(bigbuf, value, 0xffc0, 16); - proto_tree_add_text(tree, tvb, offset, 2, - "%s : PD Message Length, (%u)", - bigbuf, - (value & 0xffc0) >> 6); + other_decode_bitfield_value(bigbuf, value, 0xffc0, 16); + proto_tree_add_text(tree, tvb, offset, 2, + "%s : PD Message Length, (%u)", + bigbuf, + (value & 0xffc0) >> 6); - switch ((value & 0x0030) >> 4) - { - case 0x00: str = "No Regulatory service"; break; - case 0x01: str = "Emergency service"; break; - default: str = "Reserved"; break; - } + switch ((value & 0x0030) >> 4) + { + case 0x00: str = "No Regulatory service"; break; + case 0x01: str = "Emergency service"; break; + default: str = "Reserved"; break; + } - other_decode_bitfield_value(bigbuf, value, 0x0030, 16); - proto_tree_add_text(tree, tvb, offset, 2, - "%s : Regulatory Services Indicator - %s (%u)", - bigbuf, - str, - (value & 0x0030) >> 4); + other_decode_bitfield_value(bigbuf, value, 0x0030, 16); + proto_tree_add_text(tree, tvb, offset, 2, + "%s : Regulatory Services Indicator - %s (%u)", + bigbuf, + str, + (value & 0x0030) >> 4); - num_req = value & 0x000f; + num_req = value & 0x000f; - other_decode_bitfield_value(bigbuf, value, 0x000f, 16); - proto_tree_add_text(tree, tvb, offset, 2, - "%s : Number Requests (%u)", - bigbuf, - num_req); + other_decode_bitfield_value(bigbuf, value, 0x000f, 16); + proto_tree_add_text(tree, tvb, offset, 2, + "%s : Number Requests (%u)", + bigbuf, + num_req); - offset += 2; + offset += 2; - oct = tvb_get_guint8(tvb, offset); + oct = tvb_get_guint8(tvb, offset); - num_rsp = oct & 0xf0; + num_rsp = oct & 0xf0; - other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number Responses (%u)", - bigbuf, - num_rsp); + other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Number Responses (%u)", + bigbuf, + num_rsp); - offset++; + offset++; } else { - oct = tvb_get_guint8(tvb, offset); + oct = tvb_get_guint8(tvb, offset); - num_req = (oct & 0xf0) >> 4; - num_rsp = oct & 0x0f; + num_req = (oct & 0xf0) >> 4; + num_rsp = oct & 0x0f; - other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number Requests (%u)", - bigbuf, - num_req); + other_decode_bitfield_value(bigbuf, oct, 0xf0, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Number Requests (%u)", + bigbuf, + num_req); - other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); - proto_tree_add_text(tree, tvb, offset, 1, - "%s : Number Responses (%u)", - bigbuf, - num_rsp); + other_decode_bitfield_value(bigbuf, oct, 0x0f, 8); + proto_tree_add_text(tree, tvb, offset, 1, + "%s : Number Responses (%u)", + bigbuf, + num_rsp); - offset++; + offset++; } rem_len = tvb_length_remaining(tvb, offset); while ((num_req > 0) && - (rem_len >= 2)) + (rem_len >= 2)) { - rev_request(tvb, tree, &offset, pd_msg_type); + rev_request(tvb, tree, &offset, pd_msg_type); - rem_len = tvb_length_remaining(tvb, offset); - num_req--; + rem_len = tvb_length_remaining(tvb, offset); + num_req--; } if (num_req != 0) { - proto_tree_add_text(tree, tvb, - offset, -1, "Short Data (?)"); - return; + proto_tree_add_text(tree, tvb, + offset, -1, "Short Data (?)"); + return; } while ((num_rsp > 0) && - (rem_len >= 2)) + (rem_len >= 2)) { - rev_response(tvb, tree, &offset); + rev_response(tvb, tree, &offset); - rem_len = tvb_length_remaining(tvb, offset); - num_rsp--; + rem_len = tvb_length_remaining(tvb, offset); + num_rsp--; } if (num_rsp != 0) { - proto_tree_add_text(tree, tvb, - offset, -1, "Short Data (?)"); - return; + proto_tree_add_text(tree, tvb, + offset, -1, "Short Data (?)"); + return; } if (rem_len > 0) { - proto_tree_add_text(tree, tvb, offset, rem_len, - "Extraneous Data"); + proto_tree_add_text(tree, tvb, offset, rem_len, + "Extraneous Data"); } } static void dissect_ansi_801(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { - proto_item *ansi_801_item; - proto_tree *ansi_801_tree = NULL; + proto_item *ansi_801_item; + proto_tree *ansi_801_tree = NULL; g_pinfo = pinfo; @@ -2139,28 +2139,28 @@ dissect_ansi_801(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) */ if (tree) { - g_tree = tree; + g_tree = tree; - /* - * create the ansi_801 protocol tree - */ - ansi_801_item = - proto_tree_add_protocol_format(tree, proto_ansi_801, tvb, 0, -1, - "%s %s Link", - ansi_proto_name, - (pinfo->match_uint == ANSI_801_FORWARD) ? "Forward" : "Reverse"); + /* + * create the ansi_801 protocol tree + */ + ansi_801_item = + proto_tree_add_protocol_format(tree, proto_ansi_801, tvb, 0, -1, + "%s %s Link", + ansi_proto_name, + (pinfo->match_uint == ANSI_801_FORWARD) ? "Forward" : "Reverse"); - ansi_801_tree = - proto_item_add_subtree(ansi_801_item, ett_ansi_801); + ansi_801_tree = + proto_item_add_subtree(ansi_801_item, ett_ansi_801); - if (pinfo->match_uint == ANSI_801_FORWARD) - { - dissect_ansi_801_for_message(tvb, ansi_801_tree); - } - else - { - dissect_ansi_801_rev_message(tvb, ansi_801_tree); - } + if (pinfo->match_uint == ANSI_801_FORWARD) + { + dissect_ansi_801_for_message(tvb, ansi_801_tree); + } + else + { + dissect_ansi_801_rev_message(tvb, ansi_801_tree); + } } } @@ -2169,193 +2169,193 @@ dissect_ansi_801(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) void proto_register_ansi_801(void) { - guint i; - gint last_offset; + guint i; + gint last_offset; /* Setup list of header fields */ static hf_register_info hf[] = - { - { &hf_ansi_801_for_req_type, - { "Forward Request Type", "ansi_801.for_req_type", - FT_UINT8, BASE_DEC, NULL, 0, - NULL, HFILL } - }, - { &hf_ansi_801_for_rsp_type, - { "Forward Response Type", "ansi_801.for_rsp_type", - FT_UINT8, BASE_DEC, NULL, 0, - NULL, HFILL } - }, - { &hf_ansi_801_rev_req_type, - { "Reverse Request Type", "ansi_801.rev_req_type", - FT_UINT8, BASE_DEC, NULL, 0, - NULL, HFILL } - }, - { &hf_ansi_801_rev_rsp_type, - { "Reverse Response Type", "ansi_801.rev_rsp_type", - FT_UINT8, BASE_DEC, NULL, 0, - NULL, HFILL } - }, - { &hf_ansi_801_for_sess_tag, - { "Forward Session Tag", "ansi_801.for_sess_tag", - FT_UINT8, BASE_DEC, NULL, 0, - NULL, HFILL } - }, - { &hf_ansi_801_rev_sess_tag, - { "Reverse Session Tag", "ansi_801.rev_sess_tag", - FT_UINT8, BASE_DEC, NULL, 0, - NULL, HFILL } - }, - { &hf_ansi_801_sess_tag, - { "Session Tag", "ansi_801.sess_tag", - FT_UINT8, BASE_DEC, NULL, 0, - NULL, HFILL } - }, - { &hf_ansi_801_time_ref_cdma, - { "CDMA system time at the time the solution is valid (TIME_REF_CDMA)", "ansi_801.time_ref_cdma", - FT_UINT32, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_lat, - { "Latitude (LAT)", "ansi_801.lat", - FT_FLOAT, BASE_NONE, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_long, - { "Longitude (LONG)", "ansi_801.long", - FT_FLOAT, BASE_NONE, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_loc_uncrtnty_ang, - { "Angle of axis with respect to True North for pos uncertainty (LOC_UNCRTNTY_ANG)", "ansi_801.loc_uncrtnty_ang", - FT_FLOAT, BASE_NONE, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_loc_uncrtnty_a, - { "Std dev of axis along angle specified for pos uncertainty (LOC_UNCRTNTY_A)", "ansi_801.loc_uncrtnty_a", - FT_UINT8, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_loc_uncrtnty_p, - { "Std dev of axis perpendicular to angle specified for pos uncertainty (LOC_UNCRTNTY_P)", "ansi_801.loc_uncrtnty_p", - FT_UINT8, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_fix_type, - { "Fix type (FIX_TYPE)", "ansi_801.fix_type", - FT_BOOLEAN, 8, TFS(&ansi_801_fix_type_vals), 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_velocity_incl, - { "Velocity information included (VELOCITY_INCL)", "ansi_801.velocity_incl", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_velocity_hor, - { "Horizontal velocity magnitude (VELOCITY_HOR)", "ansi_801.velocity_hor", - FT_FLOAT, BASE_NONE, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_heading, - { "Heading (HEADING)", "ansi_801.heading", - FT_FLOAT, BASE_NONE, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_velocity_ver, - { "Vertical velocity (VELOCITY_VER)", "ansi_801.velocity_ver", - FT_FLOAT, BASE_NONE, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_clock_incl, - { "Clock information included (CLOCK_INCL)", "ansi_801.clock_incl", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_clock_bias, - { "Clock bias (CLOCK_BIAS)", "ansi_801.clock_bias", - FT_INT24, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_clock_drift, - { "Clock drift (CLOCK_DRIFT)", "ansi_801.clock_drift", - FT_INT16, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_height_incl, - { "Height information included (HEIGHT_INCL)", "ansi_801.height_incl", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_height, - { "Height (HEIGHT)", "ansi_801.height", - FT_INT16, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_loc_uncrtnty_v, - { "Std dev of vertical error for pos uncertainty (LOC_UNCRTNTY_V)", "ansi_801.loc_uncrtnty_v", - FT_UINT8, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_reserved_bits, - { "Reserved bit(s)","ansi_801.reerved_bits", - FT_UINT8,BASE_DEC, NULL, 0x0, - NULL, HFILL } - }, - { &hf_ansi_801_bad_sv_present, - { "Bad GPS satellites present (BAD_SV_PRESENT)", "ansi_801.bad_sv_present", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_num_bad_sv, - { "Number of bad GPS satellites (NUM_BAD_SV)", "ansi_801.num_bad_sv", - FT_UINT8, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_bad_sv_prn_num, - { "Satellite PRN number (SV_PRN_NUM)", "ansi_801.bad_sv_prn_num", - FT_UINT8, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_dopp_req, - { "Doppler (0th order) term requested (DOPP_REQ)", "ansi_801.dopp_req", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_add_dopp_req, - { "Additional Doppler terms requested (ADD_DOPP_REQ)", "ansi_801.add_dopp_req", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_code_ph_par_req, - { "Code phase parameters requested (CODE_PH_PAR_REQ)", "ansi_801.code_ph_par_req", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_az_el_req, - { "Azimuth and elevation angle requested (AZ_EL_REQ)", "ansi_801.az_el_req", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_pref_resp_qual, - { "Preferred response quality (PREF_RESP_QUAL)", "ansi_801.pref_resp_qual", - FT_UINT8, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_num_fixes, - { "Number of fixes (NUM_FIXES)", "ansi_801.num_fixes", - FT_UINT16, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_t_betw_fixes, - { "Time between fixes (T_BETW_FIXES)", "ansi_801.t_betw_fixes", - FT_UINT8, BASE_DEC, NULL, 0x00, - NULL, HFILL } - }, - { &hf_ansi_801_offset_req, - { "Offset requested (OFFSET_REQ)", "ansi_801.offset_req", - FT_BOOLEAN, 8, NULL, 0x00, - NULL, HFILL } - }, - }; + { + { &hf_ansi_801_for_req_type, + { "Forward Request Type", "ansi_801.for_req_type", + FT_UINT8, BASE_DEC, NULL, 0, + NULL, HFILL } + }, + { &hf_ansi_801_for_rsp_type, + { "Forward Response Type", "ansi_801.for_rsp_type", + FT_UINT8, BASE_DEC, NULL, 0, + NULL, HFILL } + }, + { &hf_ansi_801_rev_req_type, + { "Reverse Request Type", "ansi_801.rev_req_type", + FT_UINT8, BASE_DEC, NULL, 0, + NULL, HFILL } + }, + { &hf_ansi_801_rev_rsp_type, + { "Reverse Response Type", "ansi_801.rev_rsp_type", + FT_UINT8, BASE_DEC, NULL, 0, + NULL, HFILL } + }, + { &hf_ansi_801_for_sess_tag, + { "Forward Session Tag", "ansi_801.for_sess_tag", + FT_UINT8, BASE_DEC, NULL, 0, + NULL, HFILL } + }, + { &hf_ansi_801_rev_sess_tag, + { "Reverse Session Tag", "ansi_801.rev_sess_tag", + FT_UINT8, BASE_DEC, NULL, 0, + NULL, HFILL } + }, + { &hf_ansi_801_sess_tag, + { "Session Tag", "ansi_801.sess_tag", + FT_UINT8, BASE_DEC, NULL, 0, + NULL, HFILL } + }, + { &hf_ansi_801_time_ref_cdma, + { "CDMA system time at the time the solution is valid (TIME_REF_CDMA)", "ansi_801.time_ref_cdma", + FT_UINT32, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_lat, + { "Latitude (LAT)", "ansi_801.lat", + FT_FLOAT, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_long, + { "Longitude (LONG)", "ansi_801.long", + FT_FLOAT, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_loc_uncrtnty_ang, + { "Angle of axis with respect to True North for pos uncertainty (LOC_UNCRTNTY_ANG)", "ansi_801.loc_uncrtnty_ang", + FT_FLOAT, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_loc_uncrtnty_a, + { "Std dev of axis along angle specified for pos uncertainty (LOC_UNCRTNTY_A)", "ansi_801.loc_uncrtnty_a", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_loc_uncrtnty_p, + { "Std dev of axis perpendicular to angle specified for pos uncertainty (LOC_UNCRTNTY_P)", "ansi_801.loc_uncrtnty_p", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_fix_type, + { "Fix type (FIX_TYPE)", "ansi_801.fix_type", + FT_BOOLEAN, 8, TFS(&ansi_801_fix_type_vals), 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_velocity_incl, + { "Velocity information included (VELOCITY_INCL)", "ansi_801.velocity_incl", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_velocity_hor, + { "Horizontal velocity magnitude (VELOCITY_HOR)", "ansi_801.velocity_hor", + FT_FLOAT, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_heading, + { "Heading (HEADING)", "ansi_801.heading", + FT_FLOAT, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_velocity_ver, + { "Vertical velocity (VELOCITY_VER)", "ansi_801.velocity_ver", + FT_FLOAT, BASE_NONE, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_clock_incl, + { "Clock information included (CLOCK_INCL)", "ansi_801.clock_incl", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_clock_bias, + { "Clock bias (CLOCK_BIAS)", "ansi_801.clock_bias", + FT_INT24, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_clock_drift, + { "Clock drift (CLOCK_DRIFT)", "ansi_801.clock_drift", + FT_INT16, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_height_incl, + { "Height information included (HEIGHT_INCL)", "ansi_801.height_incl", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_height, + { "Height (HEIGHT)", "ansi_801.height", + FT_INT16, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_loc_uncrtnty_v, + { "Std dev of vertical error for pos uncertainty (LOC_UNCRTNTY_V)", "ansi_801.loc_uncrtnty_v", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_reserved_bits, + { "Reserved bit(s)","ansi_801.reerved_bits", + FT_UINT8,BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_ansi_801_bad_sv_present, + { "Bad GPS satellites present (BAD_SV_PRESENT)", "ansi_801.bad_sv_present", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_num_bad_sv, + { "Number of bad GPS satellites (NUM_BAD_SV)", "ansi_801.num_bad_sv", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_bad_sv_prn_num, + { "Satellite PRN number (SV_PRN_NUM)", "ansi_801.bad_sv_prn_num", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_dopp_req, + { "Doppler (0th order) term requested (DOPP_REQ)", "ansi_801.dopp_req", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_add_dopp_req, + { "Additional Doppler terms requested (ADD_DOPP_REQ)", "ansi_801.add_dopp_req", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_code_ph_par_req, + { "Code phase parameters requested (CODE_PH_PAR_REQ)", "ansi_801.code_ph_par_req", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_az_el_req, + { "Azimuth and elevation angle requested (AZ_EL_REQ)", "ansi_801.az_el_req", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_pref_resp_qual, + { "Preferred response quality (PREF_RESP_QUAL)", "ansi_801.pref_resp_qual", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_num_fixes, + { "Number of fixes (NUM_FIXES)", "ansi_801.num_fixes", + FT_UINT16, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_t_betw_fixes, + { "Time between fixes (T_BETW_FIXES)", "ansi_801.t_betw_fixes", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_ansi_801_offset_req, + { "Offset requested (OFFSET_REQ)", "ansi_801.offset_req", + FT_BOOLEAN, 8, NULL, 0x00, + NULL, HFILL } + }, + }; /* Setup protocol subtree array */ @@ -2369,30 +2369,30 @@ proto_register_ansi_801(void) for (i=0; i < NUM_FOR_REQ_TYPE; i++, last_offset++) { ett_for_req_type[i] = -1; - ett[last_offset] = &ett_for_req_type[i]; + ett[last_offset] = &ett_for_req_type[i]; } for (i=0; i < NUM_FOR_RSP_TYPE; i++, last_offset++) { ett_for_rsp_type[i] = -1; - ett[last_offset] = &ett_for_rsp_type[i]; + ett[last_offset] = &ett_for_rsp_type[i]; } for (i=0; i < NUM_REV_REQ_TYPE; i++, last_offset++) { ett_rev_req_type[i] = -1; - ett[last_offset] = &ett_rev_req_type[i]; + ett[last_offset] = &ett_rev_req_type[i]; } for (i=0; i < NUM_REV_RSP_TYPE; i++, last_offset++) { ett_rev_rsp_type[i] = -1; - ett[last_offset] = &ett_rev_rsp_type[i]; + ett[last_offset] = &ett_rev_rsp_type[i]; } /* Register the protocol name and description */ proto_ansi_801 = - proto_register_protocol(ansi_proto_name, "ANSI IS-801 (Location Services (PLD))", "ansi_801"); + proto_register_protocol(ansi_proto_name, "ANSI IS-801 (Location Services (PLD))", "ansi_801"); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_ansi_801, hf, array_length(hf)); @@ -2406,14 +2406,14 @@ proto_register_ansi_801(void) void proto_reg_handoff_ansi_801(void) { - dissector_handle_t ansi_801_handle; + dissector_handle_t ansi_801_handle; ansi_801_handle = create_dissector_handle(dissect_ansi_801, proto_ansi_801); dissector_add_uint("ansi_map.pld", ANSI_801_FORWARD, ansi_801_handle); dissector_add_uint("ansi_map.pld", ANSI_801_REVERSE, ansi_801_handle); - dissector_add_uint("ansi_a.pld", ANSI_801_FORWARD, ansi_801_handle); - dissector_add_uint("ansi_a.pld", ANSI_801_REVERSE, ansi_801_handle); + dissector_add_uint("ansi_a.pld", ANSI_801_FORWARD, ansi_801_handle); + dissector_add_uint("ansi_a.pld", ANSI_801_REVERSE, ansi_801_handle); data_handle = find_dissector("data"); } -- cgit v1.2.3