Adding upstream version 4.2.2.upstream/4.2.2

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

1 files changed, 2322 insertions, 0 deletions

diff --git a/epan/dissectors/packet-ansi_801.c b/epan/dissectors/packet-ansi_801.c
new file mode 100644
index 00000000..f8199a89
--- /dev/null
+++ b/epan/dissectors/packet-ansi_801.c
@@ -0,0 +1,2322 @@
+/* packet-ansi_801.c
+ * Routines for ANSI IS-801 (Location Services (PLD)) dissection
+ *
+ *   Location Services (Position Determination Service)
+ *			3GPP2 C.S0022-0 v1.0	IS-801
+ *
+ *   Location Services (Position Determination Service)
+ *			3GPP2 C.S0022-0-1 v1.0	IS-801 Addendum
+ *
+ * Copyright 2004, Michael Lum <mlum [AT] telostech.com>
+ * In association with Telos Technology Inc.
+ * Copyright 2007, Michael Lum <michael.lum [AT] utstar.com>
+ * In association with UTStarcom Inc.
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#include "config.h"
+
+#include <math.h>
+
+#include <epan/packet.h>
+#include <epan/expert.h>
+
+void proto_register_ansi_801(void);
+void proto_reg_handoff_ansi_801(void);
+
+static const char *ansi_proto_name = "ANSI IS-801 (Location Services (PLD))";
+static const char *ansi_proto_name_short = "IS-801";
+
+#define	ANSI_801_FORWARD	0
+#define	ANSI_801_REVERSE	1
+
+
+/* Initialize the subtree pointers */
+static gint ett_ansi_801 = -1;
+static gint ett_gps = -1;
+static gint ett_loc = -1;
+
+/* Initialize the protocol and registered fields */
+static int proto_ansi_801 = -1;
+static int hf_ansi_801_for_req_type = -1;
+static int hf_ansi_801_for_rsp_type = -1;
+static int hf_ansi_801_rev_req_type = -1;
+static int hf_ansi_801_rev_rsp_type = -1;
+static int hf_ansi_801_for_sess_tag = -1;
+static int hf_ansi_801_rev_sess_tag = -1;
+static int hf_ansi_801_sess_tag = -1;
+
+static int hf_ansi_801_time_ref_cdma = -1;
+static int hf_ansi_801_lat = -1;
+static int hf_ansi_801_long = -1;
+static int hf_ansi_801_loc_uncrtnty_ang = -1;
+static int hf_ansi_801_loc_uncrtnty_a = -1;
+static int hf_ansi_801_loc_uncrtnty_p = -1;
+static int hf_ansi_801_fix_type = -1;
+static int hf_ansi_801_velocity_incl = -1;
+static int hf_ansi_801_velocity_hor = -1;
+static int hf_ansi_801_heading = -1;
+static int hf_ansi_801_velocity_ver = -1;
+static int hf_ansi_801_clock_incl = -1;
+static int hf_ansi_801_clock_bias = -1;
+static int hf_ansi_801_clock_drift = -1;
+static int hf_ansi_801_height_incl = -1;
+static int hf_ansi_801_height = -1;
+static int hf_ansi_801_loc_uncrtnty_v = -1;
+static int hf_ansi_801_reserved_bits = -1;
+
+static int hf_ansi_801_bad_sv_present = -1;
+static int hf_ansi_801_num_bad_sv = -1;
+static int hf_ansi_801_bad_sv_prn_num = -1;
+static int hf_ansi_801_dopp_req = -1;
+static int hf_ansi_801_add_dopp_req = -1;
+static int hf_ansi_801_code_ph_par_req = -1;
+static int hf_ansi_801_az_el_req = -1;
+
+static int hf_ansi_801_pref_resp_qual = -1;
+static int hf_ansi_801_num_fixes = -1;
+static int hf_ansi_801_t_betw_fixes = -1;
+static int hf_ansi_801_offset_req = -1;
+
+/* Generated from convert_proto_tree_add_text.pl */
+static int hf_ansi_801_for_message_number_responsesF0 = -1;
+static int hf_ansi_801_apdc_id = -1;
+static int hf_ansi_801_num_sv_p32 = -1;
+static int hf_ansi_801_regulatory_services_indicator = -1;
+static int hf_ansi_801_session_source = -1;
+static int hf_ansi_801_reserved8_E0 = -1;
+static int hf_ansi_801_action_time = -1;
+static int hf_ansi_801_rev_message_number_responsesF0 = -1;
+static int hf_ansi_801_reserved24_3 = -1;
+static int hf_ansi_801_cancellation_type = -1;
+static int hf_ansi_801_gps_navigation_message_bits = -1;
+static int hf_ansi_801_num_dr_p = -1;
+static int hf_ansi_801_rev_message_number_requests8 = -1;
+static int hf_ansi_801_reserved8_F0 = -1;
+static int hf_ansi_801_for_req_loc_clock_correction_for_gps_time = -1;
+static int hf_ansi_801_for_response_length = -1;
+static int hf_ansi_801_session_end = -1;
+static int hf_ansi_801_reserved8_1F = -1;
+static int hf_ansi_801_part_num = -1;
+static int hf_ansi_801_dr_size = -1;
+static int hf_ansi_801_reserved_24_700 = -1;
+static int hf_ansi_801_for_message_number_responses0F = -1;
+static int hf_ansi_801_rev_message_number_requests16 = -1;
+static int hf_ansi_801_lcc_capable_using_location_assistance_spherical = -1;
+static int hf_ansi_801_part_num32 = -1;
+static int hf_ansi_801_part_num16 = -1;
+static int hf_ansi_801_reserved8_07 = -1;
+static int hf_ansi_801_reserved24_1 = -1;
+static int hf_ansi_801_reserved_24_F80000 = -1;
+static int hf_ansi_801_extended_base_station_almanac = -1;
+static int hf_ansi_801_no_outstanding_request_element = -1;
+static int hf_ansi_801_for_request_length = -1;
+static int hf_ansi_801_week_num = -1;
+static int hf_ansi_801_total_parts16 = -1;
+static int hf_ansi_801_pd_message_type = -1;
+static int hf_ansi_801_total_parts32 = -1;
+static int hf_ansi_801_alpha_and_beta_parameters = -1;
+static int hf_ansi_801_lcc_using_gps_ephemeris_assistance = -1;
+static int hf_ansi_801_rev_request_length = -1;
+static int hf_ansi_801_reserved8_7F = -1;
+static int hf_ansi_801_unsolicited_response_indicator = -1;
+static int hf_ansi_801_autonomous_location_calculation_capable = -1;
+static int hf_ansi_801_gps_almanac_correction = -1;
+static int hf_ansi_801_total_parts = -1;
+static int hf_ansi_801_session_start = -1;
+static int hf_ansi_801_ref_bit_num = -1;
+static int hf_ansi_801_aflt_lcc = -1;
+static int hf_ansi_801_reject_reason = -1;
+static int hf_ansi_801_gps_ephemeris = -1;
+static int hf_ansi_801_pre_programmed_location = -1;
+static int hf_ansi_801_rev_response_length = -1;
+static int hf_ansi_801_afltc_id = -1;
+static int hf_ansi_801_rev_req_loc_height_information = -1;
+static int hf_ansi_801_reserved8_01 = -1;
+static int hf_ansi_801_pilot_ph_cap = -1;
+static int hf_ansi_801_gps_acquisition_assistance = -1;
+static int hf_ansi_801_coordinate_type_requested = -1;
+static int hf_ansi_801_gps_almanac = -1;
+static int hf_ansi_801_rev_req_loc_velocity_information = -1;
+static int hf_ansi_801_gps_autonomous_acquisition_capable = -1;
+static int hf_ansi_801_num_sv_p16 = -1;
+static int hf_ansi_801_mob_sys_t_offset = -1;
+static int hf_ansi_801_desired_pilot_phase_resolution = -1;
+static int hf_ansi_801_for_req_loc_velocity_information = -1;
+static int hf_ansi_801_reserved8_0F = -1;
+static int hf_ansi_801_hybrid_gps_and_aflt_lcc = -1;
+static int hf_ansi_801_gps_acq_cap = -1;
+static int hf_ansi_801_gps_sensitivity_assistance = -1;
+static int hf_ansi_801_ms_ls_rev = -1;
+static int hf_ansi_801_reject_request_type = -1;
+static int hf_ansi_801_ms_mode = -1;
+static int hf_ansi_801_bs_ls_rev = -1;
+static int hf_ansi_801_ref_pn = -1;
+static int hf_ansi_801_rev_message_number_responses0F = -1;
+static int hf_ansi_801_for_req_loc_height_information = -1;
+static int hf_ansi_801_gps_capability_indicator = -1;
+static int hf_ansi_801_rev_req_loc_clock_correction_for_gps_time = -1;
+static int hf_ansi_801_data_records = -1;
+static int hf_ansi_801_for_message_number_requests8 = -1;
+static int hf_ansi_801_subframes_4_and_5 = -1;
+static int hf_ansi_801_use_action_time_indicator = -1;
+static int hf_ansi_801_lcc_using_gps_almanac_assistance = -1;
+static int hf_ansi_801_lcc_using_gps_almanac_correction = -1;
+static int hf_ansi_801_pd_message_len = -1;
+static int hf_ansi_801_lcc_using_location_assistance_cartesian = -1;
+static int hf_ansi_801_for_message_number_requests16 = -1;
+static int hf_ansi_801_reserved_24_7 = -1;
+static int hf_ansi_801_loc_calc_cap = -1;
+static int hf_ansi_801_toa = -1;
+static int hf_ansi_801_data = -1;
+static int hf_ansi_801_proprietary_data = -1;
+static int hf_ansi_801_time_ref_ms = -1;
+static int hf_ansi_801_time_of_almanac = -1;
+static int hf_ansi_801_gps_week_number = -1;
+
+
+static expert_field ei_ansi_801_extraneous_data = EI_INIT;
+static expert_field ei_ansi_801_short_data = EI_INIT;
+static expert_field ei_ansi_801_unexpected_length = EI_INIT;
+
+
+static dissector_handle_t ansi_801_handle;
+
+/* PARAM FUNCTIONS */
+
+#define	EXTRANEOUS_DATA_CHECK(edc_len, edc_max_len)			\
+	if ((edc_len) > (edc_max_len))					\
+	{								\
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_extraneous_data, tvb,	\
+				    offset, (edc_len) - (edc_max_len)); \
+	}
+
+#define	SHORT_DATA_CHECK(sdc_len, sdc_min_len)				\
+	if ((sdc_len) < (sdc_min_len))					\
+	{								\
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_short_data, tvb,	\
+				    offset, (sdc_len)); \
+		return;							\
+	}
+
+#define	EXACT_DATA_CHECK(edc_len, edc_eq_len)				\
+	if ((edc_len) != (edc_eq_len))					\
+	{								\
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_unexpected_length, tvb,	\
+				    offset, (edc_len)); \
+		return;							\
+	}
+
+
+/*
+ * Table 3.2-4 for PD_MSG_TYPE = '0000000'
+ */
+static const value_string for_req_type_strings[] = {
+	{ 0,	"Reserved" },
+	{ 1,	"Request Location Response" },
+	{ 2,	"Request MS Information" },
+	{ 3,	"Request Autonomous Measurement Weighting Factors" },
+	{ 4,	"Request Pseudorange Measurement" },
+	{ 5,	"Request Pilot Phase Measurement" },
+	{ 6,	"Request Time Offset Measurement" },
+	{ 7,	"Request Cancellation" },
+	{ 0, NULL },
+};
+#define	NUM_FOR_REQ_TYPE (sizeof(for_req_type_strings)/sizeof(value_string))
+static gint ett_for_req_type[NUM_FOR_REQ_TYPE];
+
+static const value_string for_rsp_type_strings[] = {
+	{ 0,	"Reject" },
+	{ 2,	"Provide BS Capabilities" },
+	{ 4,	"Provide GPS Acquisition Assistance" },
+	{ 6,	"Provide GPS Location Assistance Spherical Coordinates" },
+	{ 7,	"Provide GPS Location Assistance Cartesian Coordinates" },
+	{ 5,	"Provide GPS Sensitivity Assistance" },
+	{ 3,	"Provide Base Station Almanac" },
+	{ 8,	"Provide GPS Almanac" },
+	{ 9,	"Provide GPS Ephemeris" },
+	{ 10,	"Provide GPS Navigation Message Bits" },
+	{ 1,	"Provide Location Response" },
+	{ 11,	"Provide GPS Almanac Correction" },
+	{ 12,	"Provide GPS Satellite Health Information" },
+	{ 0, NULL },
+};
+#define	NUM_FOR_RSP_TYPE (sizeof(for_rsp_type_strings)/sizeof(value_string))
+static gint ett_for_rsp_type[NUM_FOR_RSP_TYPE];
+
+
+static const value_string rev_rsp_type_strings[] = {
+	{ 0,	"Reject" },
+	{ 2,	"Provide MS Information" },
+	{ 3,	"Provide Autonomous Measurement Weighting Factors" },
+	{ 4,	"Provide Pseudorange Measurement" },
+	{ 5,	"Provide Pilot Phase Measurement" },
+	{ 1,	"Provide Location Response" },
+	{ 6,	"Provide Time Offset Measurement" },
+	{ 7,	"Provide Cancellation Acknowledgement" },
+	{ 0, NULL },
+};
+#define	NUM_REV_RSP_TYPE (sizeof(rev_rsp_type_strings)/sizeof(value_string))
+static gint ett_rev_rsp_type[NUM_REV_RSP_TYPE];
+
+/*
+ * Table 2.2-5 for PD_MSG_TYPE = '0000000'
+ */
+static const value_string rev_req_type_strings[] = {
+	{ 0,	"Reserved" },
+	{ 2,	"Request BS Capabilities" },
+	{ 4,	"Request GPS Acquisition Assistance" },
+	{ 6,	"Request GPS Location Assistance" },
+	{ 7,	"Reserved" },
+	{ 5,	"Request GPS Sensitivity Assistance" },
+	{ 3,	"Request Base Station Almanac" },
+	{ 8,	"Request GPS Almanac" },
+	{ 9,	"Request GPS Ephemeris" },
+	{ 10,	"Request GPS Navigation Message Bits" },
+	{ 1,	"Request Location Response" },
+	{ 11,	"Request GPS Almanac Correction" },
+	{ 12,	"Request GPS Satellite Health Information" },
+	{ 0, NULL },
+};
+#define	NUM_REV_REQ_TYPE (sizeof(rev_req_type_strings)/sizeof(value_string))
+static gint ett_rev_req_type[NUM_REV_REQ_TYPE];
+
+static const value_string regulatory_services_indicator_vals[] = {
+	{ 0,	"No Regulatory service" },
+	{ 1,	"Emergency service" },
+	{ 2,	"Reserved" },
+	{ 3,	"Reserved" },
+	{ 0, NULL },
+};
+
+static const true_false_string tfs_desired_pilot_phase_resolution = { "at least 1/8th PN chip resolution", "at least 1 PN chip resolution" };
+static const true_false_string tfs_spherical_cartesian = { "Spherical", "Cartesian" };
+
+static const unit_name_string units_time_of_almanac = { " (in units of 4096 seconds)", NULL };
+static const unit_name_string units_gps_week_number = { " (8 least significant bits)", NULL };
+
+static void
+for_req_pseudo_meas(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset = offset;
+
+	SHORT_DATA_CHECK(len, 3);
+
+	/* PREF_RESP_QUAL */
+	proto_tree_add_item(tree, hf_ansi_801_pref_resp_qual, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_num_fixes, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_t_betw_fixes, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_offset_req, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_reserved_24_7, tvb, offset, 3, ENC_BIG_ENDIAN);
+	offset += 3;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+
+}
+
+static void
+for_req_pilot_ph_meas(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset;
+
+	SHORT_DATA_CHECK(len, 3);
+
+	saved_offset = offset;
+
+	proto_tree_add_item(tree, hf_ansi_801_pref_resp_qual, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_num_fixes, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_t_betw_fixes, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_offset_req, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_desired_pilot_phase_resolution, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_reserved_24_7, tvb, offset, 3, ENC_BIG_ENDIAN);
+	offset += 3;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_req_loc_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset;
+
+	SHORT_DATA_CHECK(len, 3);
+
+	saved_offset = offset;
+
+	proto_tree_add_item(tree, hf_ansi_801_pref_resp_qual, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_num_fixes, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_t_betw_fixes, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_for_req_loc_height_information, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_for_req_loc_clock_correction_for_gps_time, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_for_req_loc_velocity_information, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_reserved24_3, tvb, offset, 3, ENC_BIG_ENDIAN);
+	offset += 3;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_req_time_off_meas(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint8	oct;
+	guint32	saved_offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	saved_offset = offset;
+
+	oct = tvb_get_guint8(tvb, offset);
+
+	proto_tree_add_item(tree, hf_ansi_801_use_action_time_indicator, tvb, offset, 1, ENC_NA);
+
+	if (oct & 0x80)
+	{
+		proto_tree_add_item(tree, hf_ansi_801_action_time, tvb, offset, 1, ENC_BIG_ENDIAN);
+		proto_tree_add_item(tree, hf_ansi_801_reserved8_01, tvb, offset, 1, ENC_BIG_ENDIAN);
+	}
+	else
+	{
+		proto_tree_add_item(tree, hf_ansi_801_reserved8_7F, tvb, offset, 1, ENC_BIG_ENDIAN);
+	}
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_req_cancel(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint8       oct;
+	guint32      saved_offset;
+	const gchar *str = NULL;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	saved_offset = offset;
+
+	oct = tvb_get_guint8(tvb, offset);
+
+	str = val_to_str_const((oct & 0xf0) >> 4, for_req_type_strings, "Reserved");
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_cancellation_type, tvb, offset, 1,
+			    oct, "(%u) %s", (oct & 0xf0) >> 4, str);
+
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_0F, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_reject(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint8       oct;
+	guint32      saved_offset;
+	const gchar *str = NULL;
+
+	saved_offset = offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	oct = tvb_get_guint8(tvb, offset);
+	str = val_to_str_const((oct & 0xf0) >> 4, rev_req_type_strings, "Reserved");
+
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_reject_request_type, tvb, offset, 1, oct,
+			    "(%u) %s", (oct & 0xf0) >> 4, str);
+
+	switch ((oct & 0x0e) >> 1)
+	{
+	case 0x00: str = "Capability not supported by the base station"; break;
+	case 0x01: str = "Capability normally supported by the base station but temporarily not available or not enabled"; break;
+	default: str = "Reserved"; break;
+	}
+
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_reject_reason, tvb, offset, 1, oct, "%s", str);
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_01, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_pr_bs_cap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint8	oct;
+	guint32	saved_offset;
+
+	saved_offset = offset;
+
+	SHORT_DATA_CHECK(len, 2);
+
+	proto_tree_add_item(tree, hf_ansi_801_bs_ls_rev, tvb, offset, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_gps_capability_indicator, tvb, offset, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_afltc_id, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	oct = tvb_get_guint8(tvb, offset);
+	if (oct == 0x00)
+	{
+		proto_tree_add_uint_format(tree, hf_ansi_801_apdc_id, tvb, offset, 1, 0,
+				    "APDC_ID: Autonomous position determination capability indicator: None");
+	}
+	else
+	{
+		proto_tree_add_item(tree, hf_ansi_801_apdc_id, tvb, offset, 1, ENC_BIG_ENDIAN);
+	}
+
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_pr_gps_sense_ass(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset;
+
+	saved_offset = offset;
+
+	SHORT_DATA_CHECK(len, 4);
+
+	proto_tree_add_item(tree, hf_ansi_801_ref_bit_num, tvb, offset, 2, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_num_dr_p, tvb, offset, 2, ENC_BIG_ENDIAN);
+	offset += 2;
+
+	proto_tree_add_item(tree, hf_ansi_801_dr_size, tvb, offset, 3, ENC_BIG_ENDIAN);
+	offset++;
+
+	proto_tree_add_item(tree, hf_ansi_801_part_num, tvb, offset, 2, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_total_parts, tvb, offset, 2, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_data_records, tvb, offset, 2, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_pr_gps_almanac(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset = offset;
+	int * const fields[] = {
+		&hf_ansi_801_num_sv_p32,
+		&hf_ansi_801_week_num,
+		&hf_ansi_801_toa,
+		&hf_ansi_801_part_num32,
+		&hf_ansi_801_total_parts32,
+		NULL
+	};
+
+	SHORT_DATA_CHECK(len, 4);
+
+    proto_tree_add_bitmask_list(tree, tvb, offset, 4, fields, ENC_BIG_ENDIAN);
+	offset += 4;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_pr_gps_nav_msg_bits(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset = offset;
+	int * const fields[] = {
+		&hf_ansi_801_num_sv_p16,
+		&hf_ansi_801_part_num16,
+		&hf_ansi_801_total_parts16,
+		NULL
+	};
+
+	SHORT_DATA_CHECK(len, 2);
+
+    proto_tree_add_bitmask_list(tree, tvb, offset, 2, fields, ENC_BIG_ENDIAN);
+	offset += 2;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+/*
+ * shared for both forward/reverse directions
+ */
+static const true_false_string ansi_801_fix_type_vals = {
+	"3D",
+	"2D"
+};
+
+static void
+pr_loc_response(tvbuff_t *tvb, packet_info *pinfo, 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;
+
+	SHORT_DATA_CHECK(len, 11);
+	saved_offset = offset;
+	bit_offset   = offset << 3;
+
+	/* 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,
+					      ENC_BIG_ENDIAN, "%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, ENC_BIG_ENDIAN,
+					       "%.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, ENC_BIG_ENDIAN,
+					       "%.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,
+					       ENC_BIG_ENDIAN, "%.5f degrees (0x%02x)", fl_value, value);
+	bit_offset += 4;
+
+	/* LOC_UNCRTNTY_A */
+	value = tvb_get_bits8(tvb, bit_offset, 5);
+	switch (value)
+	{
+	case 0x1e: str = "> 12288.00 meters"; break;
+	case 0x1f: str = "Not computable"; break;
+	default:
+		fl_value = (float)(0.5f * (1 << (value >> 1)));
+		if (value & 0x01)
+			fl_value *= 1.5f;
+		str = wmem_strdup_printf(pinfo->pool, "%.2f meters", fl_value);
+	}
+	proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_loc_uncrtnty_a, tvb, bit_offset, 5, value,
+					      ENC_BIG_ENDIAN, "%s (0x%02x)", str, value);
+	bit_offset += 5;
+
+	/* LOC_UNCRTNTY_P */
+	value = tvb_get_bits8(tvb, bit_offset, 5);
+	switch (value)
+	{
+	case 0x1e: str = "> 12288.00 meters"; break;
+	case 0x1f: str = "Not computable"; break;
+	default:
+		fl_value = (float)(0.5f * (1 << (value >> 1)));
+		if (value & 0x01)
+			fl_value *= 1.5f;
+		str = wmem_strdup_printf(pinfo->pool, "%.2f meters", fl_value);
+	}
+	proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_loc_uncrtnty_p, tvb, bit_offset, 5, value,
+					      ENC_BIG_ENDIAN, "%s (0x%02x)", str, value);
+	bit_offset += 5;
+
+	/* FIX_TYPE */
+	proto_tree_add_bits_ret_val(tree, hf_ansi_801_fix_type, tvb, bit_offset++, 1, &fix_type, ENC_BIG_ENDIAN);
+
+	/* VELOCITY_INCL */
+	proto_tree_add_bits_ret_val(tree, hf_ansi_801_velocity_incl, tvb, bit_offset++, 1, &velocity_incl, ENC_BIG_ENDIAN);
+
+
+	if(velocity_incl)
+	{
+		/* VELOCITY_HOR */
+		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,
+						       ENC_BIG_ENDIAN, "%.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,
+						       ENC_BIG_ENDIAN, "%.3f degrees (0x%04x)", fl_value, value);
+		bit_offset += 10;
+
+		if(fix_type)
+		{
+			/* VELOCITY_VER */
+			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,
+							       ENC_BIG_ENDIAN, "%.1f m/s (0x%02x)", fl_value, value);
+			bit_offset += 8;
+		}
+	}
+
+	/* CLOCK_INCL */
+	proto_tree_add_bits_ret_val(tree, hf_ansi_801_clock_incl, tvb, bit_offset++, 1, &clock_incl, ENC_BIG_ENDIAN);
+
+	if(clock_incl)
+	{
+		/* 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,
+						     ENC_BIG_ENDIAN, "%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,
+						     ENC_BIG_ENDIAN, "%d ppb (ns/s) (0x%04x)", (gint16)value, value);
+		bit_offset += 16;
+	}
+
+	/* HEIGHT_INCL */
+	proto_tree_add_bits_ret_val(tree, hf_ansi_801_height_incl, tvb, bit_offset++, 1, &height_incl, ENC_BIG_ENDIAN);
+
+	if(height_incl)
+	{
+		/* 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,
+						     ENC_BIG_ENDIAN, "%d m (0x%04x)", (gint32)value - 500, value);
+		bit_offset += 14;
+
+		/* LOC_UNCRTNTY_V */
+		value = tvb_get_bits8(tvb, bit_offset, 5);
+		switch (value)
+		{
+		case 0x1e: str = "> 12288.00 meters"; break;
+		case 0x1f: str = "Not computable"; break;
+		default:
+			fl_value = (float)(0.5f * (1 << (value >> 1)));
+			if (value & 0x01)
+				fl_value *= 1.5f;
+			str = wmem_strdup_printf(pinfo->pool, "%.2f meters", fl_value);
+		}
+		proto_tree_add_uint_bits_format_value(tree, hf_ansi_801_loc_uncrtnty_v, tvb, bit_offset, 5, value,
+						      ENC_BIG_ENDIAN, "%s (0x%02x)", str, value);
+		bit_offset += 5;
+	}
+
+	if(bit_offset & 0x07)
+	{
+		spare_bits = 8 - (bit_offset & 0x07);
+		proto_tree_add_bits_item(tree, hf_ansi_801_reserved_bits, tvb, bit_offset, spare_bits, ENC_BIG_ENDIAN);
+		bit_offset += spare_bits;
+	}
+
+	offset = bit_offset >> 3;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+for_pr_loc_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	pr_loc_response(tvb, pinfo, tree, len, offset);
+}
+
+static void
+for_pr_gps_sat_health(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	bit_offset, spare_bits;
+	guint32	i;
+	guint32	saved_offset, num_bad_sv, bad_sv_prn_num;
+	guint64	bad_sv_present;
+
+	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);
+
+	if (bad_sv_present)
+	{
+		/* 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,
+						      ENC_BIG_ENDIAN, "%u", num_bad_sv);
+		bit_offset += 4;
+
+		for (i=0; i < num_bad_sv; i++)
+		{
+			/* 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,
+							      ENC_BIG_ENDIAN, "%u", bad_sv_prn_num);
+			bit_offset += 5;
+		}
+	}
+
+	if(bit_offset & 0x07)
+	{
+		spare_bits = 8 - (bit_offset & 0x07);
+		proto_tree_add_bits_item(tree, hf_ansi_801_reserved_bits, tvb, bit_offset, spare_bits, ENC_BIG_ENDIAN);
+		bit_offset += spare_bits;
+	}
+
+	offset = bit_offset >> 3;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_req_gps_acq_ass(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset;
+	guint32	bit_offset;
+
+	SHORT_DATA_CHECK(len, 1);
+	saved_offset = offset;
+	bit_offset   = offset << 3;
+
+	proto_tree_add_bits_item(tree, hf_ansi_801_dopp_req, tvb, bit_offset++, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_bits_item(tree, hf_ansi_801_add_dopp_req, tvb, bit_offset++, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_bits_item(tree, hf_ansi_801_code_ph_par_req, tvb, bit_offset++, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_bits_item(tree, hf_ansi_801_az_el_req, tvb, bit_offset++, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_bits_item(tree, hf_ansi_801_reserved_bits, tvb, bit_offset, 4, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_req_gps_loc_ass(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32 saved_offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	saved_offset = offset;
+
+	proto_tree_add_item(tree, hf_ansi_801_coordinate_type_requested, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_7F, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_req_bs_alm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32 saved_offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	saved_offset = offset;
+
+	proto_tree_add_item(tree, hf_ansi_801_extended_base_station_almanac, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_7F, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_req_gps_ephemeris(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32 saved_offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	saved_offset = offset;
+
+	proto_tree_add_item(tree, hf_ansi_801_alpha_and_beta_parameters, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_7F, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_req_gps_nav_msg_bits(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32 saved_offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	saved_offset = offset;
+
+	proto_tree_add_item(tree, hf_ansi_801_subframes_4_and_5, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_7F, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_req_loc_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32 saved_offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	saved_offset = offset;
+
+	proto_tree_add_item(tree, hf_ansi_801_rev_req_loc_height_information, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_rev_req_loc_clock_correction_for_gps_time, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_rev_req_loc_velocity_information, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_1F, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_req_gps_alm_correction(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset;
+
+	SHORT_DATA_CHECK(len, 2);
+
+	saved_offset = offset;
+
+	proto_tree_add_item(tree, hf_ansi_801_time_of_almanac, tvb, offset, 1, ENC_NA);
+
+	offset++;
+	proto_tree_add_item(tree, hf_ansi_801_gps_week_number, tvb, offset, 1, ENC_NA);
+
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_reject(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint8       oct;
+	guint32      saved_offset;
+	const gchar *str = NULL;
+
+	saved_offset = offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	oct = tvb_get_guint8(tvb, offset);
+
+	str = val_to_str_const((oct & 0xf0) >> 4, for_req_type_strings, "Reserved");
+
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_reject_request_type, tvb, offset, 1, oct,
+			    "(%u) %s", (oct & 0xf0) >> 4, str);
+
+	switch ((oct & 0x0e) >> 1)
+	{
+	case 0x00: str = "Capability not supported by the mobile station"; break;
+	case 0x01: str = "Capability normally supported by the mobile station but temporarily not available or not enabled"; break;
+	default: str = "Reserved"; break;
+	}
+
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_reject_reason, tvb, offset, 1,
+			    oct, "%s", str);
+
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_01, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_pr_ms_information(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32      value;
+	guint32      saved_offset;
+	const gchar *str = NULL;
+	proto_item* ti;
+	proto_tree *gps_tree, *loc_tree;
+
+	saved_offset = offset;
+
+	SHORT_DATA_CHECK(len, 5);
+
+	value = tvb_get_ntohs(tvb, offset);
+
+	proto_tree_add_item(tree, hf_ansi_801_ms_ls_rev, tvb, offset, 2, ENC_BIG_ENDIAN);
+
+	proto_tree_add_item(tree, hf_ansi_801_ms_mode, tvb, offset, 2, ENC_BIG_ENDIAN);
+
+	switch (value & 0x003f)
+	{
+	case 0x00: str = "Full Chip Measurement Capability"; break;
+	case 0x01: str = "Half Chip Measurement Capability"; break;
+	case 0x02: str = "Quarter Chip Measurement Capability"; break;
+	case 0x03: str = "Eighth Chip Measurement Capability"; break;
+	case 0x04: str = "One Sixteenth Chip Measurement Capability"; break;
+	default: str = "Reserved"; break;
+	}
+
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_pilot_ph_cap, tvb, offset, 2,
+			    value, "(%u) %s", value & 0x3f, str);
+	offset += 2;
+
+	ti = proto_tree_add_item(tree, hf_ansi_801_gps_acq_cap, tvb, offset, 3, ENC_BIG_ENDIAN);
+	gps_tree = proto_item_add_subtree(ti, ett_gps);
+
+	proto_tree_add_item(gps_tree, hf_ansi_801_reserved_24_F80000, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(gps_tree, hf_ansi_801_gps_autonomous_acquisition_capable, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(gps_tree, hf_ansi_801_gps_almanac_correction, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(gps_tree, hf_ansi_801_gps_navigation_message_bits, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(gps_tree, hf_ansi_801_gps_ephemeris, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(gps_tree, hf_ansi_801_gps_almanac, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(gps_tree, hf_ansi_801_gps_sensitivity_assistance, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(gps_tree, hf_ansi_801_gps_acquisition_assistance, tvb, offset, 3, ENC_BIG_ENDIAN);
+
+	ti = proto_tree_add_item(tree, hf_ansi_801_loc_calc_cap, tvb, offset, 3, ENC_BIG_ENDIAN);
+	loc_tree = proto_item_add_subtree(ti, ett_loc);
+
+	proto_tree_add_item(loc_tree, hf_ansi_801_pre_programmed_location, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_reserved_24_700, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_hybrid_gps_and_aflt_lcc, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_autonomous_location_calculation_capable, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_lcc_using_gps_almanac_correction, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_lcc_using_gps_ephemeris_assistance, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_lcc_using_gps_almanac_assistance, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_aflt_lcc, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_lcc_using_location_assistance_cartesian, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(loc_tree, hf_ansi_801_lcc_capable_using_location_assistance_spherical, tvb, offset, 3, ENC_BIG_ENDIAN);
+	offset += 3;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_pr_loc_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	pr_loc_response(tvb, pinfo, tree, len, offset);
+}
+
+static void
+rev_pr_time_off_meas(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint32	saved_offset;
+
+	saved_offset = offset;
+
+	SHORT_DATA_CHECK(len, 6);
+
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_time_ref_ms, tvb, offset, 3, tvb_get_ntoh24(tvb, offset),
+			    "The time of validity of the parameters reported in this response element.");
+	offset += 3;
+
+	proto_tree_add_item(tree, hf_ansi_801_ref_pn, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_mob_sys_t_offset, tvb, offset, 3, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_reserved24_1, tvb, offset, 3, ENC_BIG_ENDIAN);
+	offset += 3;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void
+rev_pr_can_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset)
+{
+	guint8       oct;
+	guint32      saved_offset;
+	const gchar *str;
+
+	saved_offset = offset;
+
+	SHORT_DATA_CHECK(len, 1);
+
+	oct = tvb_get_guint8(tvb, offset);
+
+	str = val_to_str_const((oct & 0xf0) >> 4, for_req_type_strings, "Reserved");
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_cancellation_type, tvb, offset, 1, oct,
+			    "(%u) %s", (oct & 0xf0) >> 4, str);
+
+	proto_tree_add_item(tree, hf_ansi_801_no_outstanding_request_element, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_07, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	EXTRANEOUS_DATA_CHECK(len, offset - saved_offset);
+}
+
+static void (*for_req_type_fcn[])(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint len, guint32 offset) = {
+	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 */
+};
+
+static void (*for_rsp_type_fcn[])(tvbuff_t *tvb, packet_info *pinfo, 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 */
+};
+
+static void (*rev_req_type_fcn[])(tvbuff_t *tvb, packet_info *pinfo, 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,	/* 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 */
+	rev_req_gps_nav_msg_bits,	/* Request GPS Navigation Message Bits */
+	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,	/* NONE */
+};
+
+static void (*rev_rsp_type_fcn[])(tvbuff_t *tvb, packet_info *pinfo, 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 */
+};
+
+static void
+for_request(tvbuff_t *tvb, packet_info *pinfo, 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;
+
+	offset = *offset_p;
+	oct    = tvb_get_guint8(tvb, offset);
+
+	if (pd_msg_type == 0x00)
+	{
+		proto_tree_add_item(tree, hf_ansi_801_reserved8_F0, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+		str = try_val_to_str_idx(oct & 0x0f, for_req_type_strings, &idx);
+		if (str == NULL)
+		{
+			return;
+		}
+
+		item = proto_tree_add_uint_format_value(tree, hf_ansi_801_for_req_type, tvb, offset, 1,
+							oct & 0x0f, "%s (%u)", 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;
+	}
+
+	subtree = proto_item_add_subtree(item, ett_for_req_type[idx]);
+
+	offset++;
+	oct = tvb_get_guint8(tvb, offset);
+
+	proto_tree_add_item(subtree, hf_ansi_801_for_request_length, tvb, offset, 1, ENC_BIG_ENDIAN);
+	offset++;
+
+	if (oct > 0)
+	{
+		if (for_req_type_fcn[idx] != NULL)
+		{
+			(*for_req_type_fcn[idx])(tvb, pinfo, subtree, oct, offset);
+		}
+		else
+		{
+			proto_tree_add_item(subtree, hf_ansi_801_data, tvb, offset, oct, ENC_NA);
+		}
+	}
+
+	*offset_p = offset + oct;
+}
+
+static void
+for_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 *offset_p)
+{
+	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);
+
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_E0, tvb, offset, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_unsolicited_response_indicator, tvb, offset, 1, ENC_NA);
+
+	str = try_val_to_str_idx(oct & 0x0f, for_rsp_type_strings, &idx);
+
+	if (str == NULL)
+	{
+		return;
+	}
+
+	item = proto_tree_add_uint_format_value(tree, hf_ansi_801_for_rsp_type, tvb, offset, 1,
+						oct & 0x0f, "%s (%u)", str, oct & 0x0f);
+	subtree = proto_item_add_subtree(item, ett_for_rsp_type[idx]);
+
+	offset++;
+	oct = tvb_get_guint8(tvb, offset);
+
+	proto_tree_add_item(subtree, hf_ansi_801_for_response_length, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+	offset++;
+
+	if (for_rsp_type_fcn[idx] != NULL)
+	{
+		(*for_rsp_type_fcn[idx])(tvb, pinfo, subtree, oct, offset);
+	}
+	else
+	{
+		proto_tree_add_item(subtree, hf_ansi_801_data, tvb, offset, oct, ENC_NA);
+	}
+
+	*offset_p = offset + oct;
+}
+
+static void
+rev_request(tvbuff_t *tvb, packet_info *pinfo, 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;
+
+	offset = *offset_p;
+	oct    = tvb_get_guint8(tvb, offset);
+
+	if (pd_msg_type == 0x00)
+	{
+		proto_tree_add_item(tree, hf_ansi_801_reserved8_F0, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+		str = try_val_to_str_idx(oct & 0x0f, rev_req_type_strings, &idx);
+		if (str == NULL)
+		{
+			return;
+		}
+
+		item = proto_tree_add_uint_format_value(tree, hf_ansi_801_rev_req_type, tvb, offset, 1,
+							oct & 0x0f, "%s (%u)", 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;
+	}
+
+	subtree = proto_item_add_subtree(item, ett_rev_req_type[idx]);
+
+	offset++;
+	oct = tvb_get_guint8(tvb, offset);
+
+	proto_tree_add_item(subtree, hf_ansi_801_rev_request_length, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+	offset++;
+
+	if (rev_req_type_fcn[idx] != NULL)
+	{
+		(*rev_req_type_fcn[idx])(tvb, pinfo, subtree, oct, offset);
+	}
+	else
+	{
+		proto_tree_add_item(subtree, hf_ansi_801_data, tvb, offset, oct, ENC_NA);
+	}
+
+	*offset_p = offset + oct;
+}
+
+static void
+rev_response(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 *offset_p)
+{
+	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);
+
+	proto_tree_add_item(tree, hf_ansi_801_reserved8_E0, tvb, offset, 1, ENC_BIG_ENDIAN);
+	proto_tree_add_item(tree, hf_ansi_801_unsolicited_response_indicator, tvb, offset, 1, ENC_NA);
+
+	str = try_val_to_str_idx(oct & 0x0f, rev_rsp_type_strings, &idx);
+
+	if (str == NULL)
+	{
+		return;
+	}
+
+	item = proto_tree_add_uint_format_value(tree, hf_ansi_801_rev_rsp_type, tvb, offset, 1,
+						oct & 0x0f, "%s (%u)", str, oct & 0x0f);
+	subtree = proto_item_add_subtree(item, ett_rev_rsp_type[idx]);
+	offset++;
+
+	oct = tvb_get_guint8(tvb, offset);
+
+	proto_tree_add_item(subtree, hf_ansi_801_rev_response_length, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+	offset++;
+
+	if (rev_rsp_type_fcn[idx] != NULL)
+	{
+		(*rev_rsp_type_fcn[idx])(tvb, pinfo, subtree, oct, offset);
+	}
+	else
+	{
+		proto_tree_add_item(subtree, hf_ansi_801_data, tvb, offset, oct, ENC_NA);
+	}
+
+	*offset_p = offset + oct;
+}
+
+static void
+dissect_ansi_801_for_message(tvbuff_t *tvb, packet_info *pinfo, 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;
+
+	offset = 0;
+
+	proto_tree_add_item(tree, hf_ansi_801_session_start, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_session_end, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_session_source, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_for_sess_tag, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+	hidden_item = proto_tree_add_item(tree, hf_ansi_801_sess_tag, tvb, offset, 1, ENC_BIG_ENDIAN);
+	proto_item_set_hidden(hidden_item);
+
+	offset++;
+	oct = tvb_get_guint8(tvb, offset);
+	pd_msg_type = oct;
+
+	switch (pd_msg_type)
+	{
+	case 0x00: str = "Position Determination Data Message"; break;
+	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;
+	}
+
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_pd_message_type, tvb, offset, 1, pd_msg_type,
+			    "%s (%u)", str, pd_msg_type);
+
+	offset++;
+
+	if ((pd_msg_type != 0x00) &&
+	    (pd_msg_type != 0x01))
+	{
+		proto_tree_add_item(tree, hf_ansi_801_proprietary_data, tvb, offset, -1, ENC_NA);
+		return;
+	}
+
+	if (pd_msg_type == 0x01)
+	{
+		value = tvb_get_ntohs(tvb, offset);
+
+		proto_tree_add_item(tree, hf_ansi_801_pd_message_len, tvb, offset, 2, ENC_BIG_ENDIAN);
+		proto_tree_add_item(tree, hf_ansi_801_regulatory_services_indicator, tvb, offset, 2, ENC_BIG_ENDIAN);
+
+		num_req = value & 0x000f;
+
+		proto_tree_add_item(tree, hf_ansi_801_for_message_number_requests16, tvb, offset, 2, ENC_BIG_ENDIAN);
+		offset += 2;
+
+		oct = tvb_get_guint8(tvb, offset);
+		num_rsp = oct & 0xf0;
+
+		proto_tree_add_item(tree, hf_ansi_801_for_message_number_responsesF0, tvb, offset, 1, ENC_BIG_ENDIAN);
+		offset++;
+	}
+	else
+	{
+		oct = tvb_get_guint8(tvb, offset);
+
+		num_req = (oct & 0xf0) >> 4;
+		num_rsp = oct & 0x0f;
+
+		proto_tree_add_item(tree, hf_ansi_801_for_message_number_requests8, tvb, offset, 1, ENC_BIG_ENDIAN);
+		proto_tree_add_item(tree, hf_ansi_801_for_message_number_responses0F, tvb, offset, 1, ENC_BIG_ENDIAN);
+	}
+
+	offset++;
+	rem_len = tvb_reported_length_remaining(tvb, offset);
+
+	while ((num_req > 0) &&
+	       (rem_len >= 2))
+	{
+		for_request(tvb, pinfo, tree, &offset, pd_msg_type);
+
+		rem_len = tvb_reported_length_remaining(tvb, offset);
+		num_req--;
+	}
+
+	if (num_req != 0)
+	{
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_short_data, tvb, offset, -1);
+		return;
+	}
+
+	while ((num_rsp > 0) &&
+	       (rem_len >= 2))
+	{
+		for_response(tvb, pinfo, tree, &offset);
+
+		rem_len = tvb_reported_length_remaining(tvb, offset);
+		num_rsp--;
+	}
+
+	if (num_rsp != 0)
+	{
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_short_data, tvb, offset, -1);
+		return;
+	}
+
+	if (rem_len > 0)
+	{
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_extraneous_data, tvb, offset, rem_len);
+	}
+}
+
+static void
+dissect_ansi_801_rev_message(tvbuff_t *tvb, packet_info *pinfo, 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;
+
+	offset = 0;
+
+	proto_tree_add_item(tree, hf_ansi_801_session_start, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_session_end, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_session_source, tvb, offset, 1, ENC_NA);
+	proto_tree_add_item(tree, hf_ansi_801_rev_sess_tag, tvb, offset, 1, ENC_BIG_ENDIAN);
+
+	hidden_item = proto_tree_add_item(tree, hf_ansi_801_sess_tag, tvb, offset, 1, ENC_BIG_ENDIAN);
+	proto_item_set_hidden(hidden_item);
+
+	offset++;
+	oct = tvb_get_guint8(tvb, offset);
+	pd_msg_type = oct;
+
+	switch (pd_msg_type)
+	{
+	case 0x00: str = "Position Determination Data Message"; break;
+	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;
+	}
+
+	proto_tree_add_uint_format_value(tree, hf_ansi_801_pd_message_type, tvb, offset, 1, pd_msg_type,
+			    "%s (%u)", str, pd_msg_type);
+	offset++;
+
+	if ((pd_msg_type != 0x00) &&
+	    (pd_msg_type != 0x01))
+	{
+		proto_tree_add_item(tree, hf_ansi_801_proprietary_data, tvb, offset, -1, ENC_NA);
+		return;
+	}
+
+	if (pd_msg_type == 0x01)
+	{
+		value = tvb_get_ntohs(tvb, offset);
+
+		proto_tree_add_item(tree, hf_ansi_801_pd_message_len, tvb, offset, 2, ENC_BIG_ENDIAN);
+		proto_tree_add_item(tree, hf_ansi_801_regulatory_services_indicator, tvb, offset, 2, ENC_BIG_ENDIAN);
+
+		num_req = value & 0x000f;
+
+		proto_tree_add_item(tree, hf_ansi_801_rev_message_number_requests16, tvb, offset, 2, ENC_BIG_ENDIAN);
+		offset += 2;
+
+		oct = tvb_get_guint8(tvb, offset);
+		num_rsp = oct & 0xf0;
+
+		proto_tree_add_item(tree, hf_ansi_801_rev_message_number_responsesF0, tvb, offset, 1, ENC_BIG_ENDIAN);
+		offset++;
+	}
+	else
+	{
+		oct = tvb_get_guint8(tvb, offset);
+
+		num_req = (oct & 0xf0) >> 4;
+		num_rsp = oct & 0x0f;
+
+		proto_tree_add_item(tree, hf_ansi_801_rev_message_number_requests8, tvb, offset, 1, ENC_BIG_ENDIAN);
+		proto_tree_add_item(tree, hf_ansi_801_rev_message_number_responses0F, tvb, offset, 1, ENC_BIG_ENDIAN);
+		offset++;
+	}
+
+	rem_len = tvb_reported_length_remaining(tvb, offset);
+
+	while ((num_req > 0) &&
+	       (rem_len >= 2))
+	{
+		rev_request(tvb, pinfo, tree, &offset, pd_msg_type);
+
+		rem_len = tvb_reported_length_remaining(tvb, offset);
+		num_req--;
+	}
+
+	if (num_req != 0)
+	{
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_short_data, tvb, offset, -1);
+		return;
+	}
+
+	while ((num_rsp > 0) &&
+	       (rem_len >= 2))
+	{
+		rev_response(tvb, pinfo, tree, &offset);
+
+		rem_len = tvb_reported_length_remaining(tvb, offset);
+		num_rsp--;
+	}
+
+	if (num_rsp != 0)
+	{
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_short_data, tvb, offset, -1);
+		return;
+	}
+
+	if (rem_len > 0)
+	{
+		proto_tree_add_expert(tree, pinfo, &ei_ansi_801_extraneous_data, tvb, offset, rem_len);
+	}
+}
+
+static int
+dissect_ansi_801(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+{
+	proto_item *ansi_801_item;
+	proto_tree *ansi_801_tree = NULL;
+
+	col_set_str(pinfo->cinfo, COL_PROTOCOL, ansi_proto_name_short);
+
+	/* In the interest of speed, if "tree" is NULL, don't do any work not
+	 * necessary to generate protocol tree items.
+	 */
+	if (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");
+
+		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, pinfo, ansi_801_tree);
+		}
+		else
+		{
+			dissect_ansi_801_rev_message(tvb, pinfo, ansi_801_tree);
+		}
+	}
+	return tvb_captured_length(tvb);
+}
+
+
+/* Register the protocol with Wireshark */
+void
+proto_register_ansi_801(void)
+{
+	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, 0x1f,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_sess_tag,
+		  { "Reverse Session Tag", "ansi_801.rev_sess_tag",
+		    FT_UINT8, BASE_DEC, NULL, 0x1f,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_sess_tag,
+		  { "Session Tag", "ansi_801.sess_tag",
+		    FT_UINT8, BASE_DEC, NULL, 0x1f,
+		    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, BASE_NONE, 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, BASE_NONE, 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, BASE_NONE, 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, BASE_NONE, 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.reserved_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, BASE_NONE, 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, BASE_NONE, NULL, 0x00,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_add_dopp_req,
+		  { "Additional Doppler terms requested (ADD_DOPP_REQ)", "ansi_801.add_dopp_req",
+		    FT_BOOLEAN, BASE_NONE, 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, BASE_NONE, 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, BASE_NONE, NULL, 0x00,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_pref_resp_qual,
+		  { "Preferred response quality (PREF_RESP_QUAL)", "ansi_801.pref_resp_qual",
+		    FT_UINT24, BASE_DEC, NULL, 0xe00000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_num_fixes,
+		  { "Number of fixes (NUM_FIXES)", "ansi_801.num_fixes",
+		    FT_UINT24, BASE_DEC, NULL, 0x1fe000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_t_betw_fixes,
+		  { "Time between fixes (T_BETW_FIXES) (in seconds)", "ansi_801.t_betw_fixes",
+		    FT_UINT24, BASE_DEC, NULL, 0x001fe0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_offset_req,
+		  { "Offset requested (OFFSET_REQ)", "ansi_801.offset_req",
+		    FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x000010,
+		    NULL, HFILL }
+		},
+
+		/* Generated from convert_proto_tree_add_text.pl */
+		{ &hf_ansi_801_desired_pilot_phase_resolution,
+		  { "Desired pilot phase resolution", "ansi_801.desired_pilot_phase_resolution",
+		    FT_BOOLEAN, 24, TFS(&tfs_desired_pilot_phase_resolution), 0x000008,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved_24_7,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT24, BASE_HEX, NULL, 0x07,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_req_loc_height_information,
+		  { "Height information", "ansi_801.height_incl",
+		    FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x000010,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_req_loc_clock_correction_for_gps_time,
+		  { "Clock correction for GPS time", "ansi_801.clock_correction_for_gps_time",
+		    FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x000008,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_req_loc_velocity_information,
+		  { "Velocity information", "ansi_801.velocity_information",
+		    FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x000004,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved24_3,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT24, BASE_HEX, NULL, 0x000003,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_use_action_time_indicator,
+		  { "Use action time indicator", "ansi_801.use_action_time_indicator",
+		    FT_BOOLEAN, 8, NULL, 0x80,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_action_time,
+		  { "Action time", "ansi_801.action_time",
+		    FT_UINT8, BASE_DEC, NULL, 0x7E,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved8_7F,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT8, BASE_HEX, NULL, 0x7F,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_cancellation_type,
+		  { "Cancellation Type", "ansi_801.cancellation_type",
+		    FT_UINT8, BASE_DEC, VALS(for_req_type_strings), 0xF0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved8_0F,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT8, BASE_HEX, NULL, 0x0F,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reject_request_type,
+		  { "Reject request type", "ansi_801.reject_request_type",
+		    FT_UINT8, BASE_DEC, VALS(rev_req_type_strings), 0xF0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reject_reason,
+		  { "Reject reason", "ansi_801.reject_reason",
+		    FT_UINT8, BASE_DEC, NULL, 0x0E,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved8_01,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT8, BASE_HEX, NULL, 0x01,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_bs_ls_rev,
+		  { "BS_LS_REV", "ansi_801.bs_ls_rev",
+		    FT_UINT8, BASE_HEX, NULL, 0xfc,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_capability_indicator,
+		  { "GPSC_ID: GPS capability indicator", "ansi_801.gps_capability_indicator",
+		    FT_UINT8, BASE_DEC, NULL, 0x02,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_afltc_id,
+		  { "AFLTC_ID: Advanced forward link trilateration capability indicator", "ansi_801.afltc_id",
+		    FT_UINT8, BASE_DEC, NULL, 0x01,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_apdc_id,
+		  { "APDC_ID: Autonomous position determination capability indicator: Autonomous Location Technology Identifier", "ansi_801.apdc_id",
+		    FT_UINT8, BASE_DEC, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_ref_bit_num,
+		  { "REF_BIT_NUM", "ansi_801.ref_bit_num",
+		    FT_UINT16, BASE_DEC, NULL, 0xffe0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_num_dr_p,
+		  { "NUM_DR_P: Number of data records in this part", "ansi_801.num_dr_p",
+		    FT_UINT16, BASE_DEC, NULL, 0x001e,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_dr_size,
+		  { "DR_SIZE: Data record size", "ansi_801.dr_size",
+		    FT_UINT24, BASE_DEC, NULL, 0x0001FE,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_part_num,
+		  { "PART_NUM: The part number", "ansi_801.part_num",
+		    FT_UINT16, BASE_DEC, NULL, 0x01c0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_total_parts,
+		  { "TOTAL_PARTS: Total number of parts", "ansi_801.total_parts",
+		    FT_UINT16, BASE_DEC, NULL, 0x38,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_data_records,
+		  { "Data records", "ansi_801.data_records",
+		    FT_UINT16, BASE_DEC, NULL, 0x07,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_num_sv_p32,
+		  { "NUM_SV_P: Number of satellites in this part", "ansi_801.num_sv_p",
+		    FT_UINT32, BASE_DEC, NULL, 0xfc000000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_week_num,
+		  { "WEEK_NUM: The GPS week number of the almanac", "ansi_801.week_num",
+		    FT_UINT32, BASE_DEC, NULL, 0x03fc0000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_toa,
+		  { "TOA: The reference time of the almanac", "ansi_801.toa",
+		    FT_UINT32, BASE_DEC, NULL, 0x0003fc00,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_part_num32,
+		  { "PART_NUM: The part number", "ansi_801.part_num",
+		    FT_UINT32, BASE_DEC, NULL, 0x000003e0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_total_parts32,
+		  { "TOTAL_PARTS: The total number of parts", "ansi_801.total_parts",
+		    FT_UINT32, BASE_DEC, NULL, 0x0000001f,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_num_sv_p16,
+		  { "NUM_SV_P: Number of satellites in this part", "ansi_801.num_sv_p",
+		    FT_UINT16, BASE_DEC, NULL, 0xfc00,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_part_num16,
+		  { "PART_NUM: The part number", "ansi_801.part_num",
+		    FT_UINT16, BASE_DEC, NULL, 0x03e0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_total_parts16,
+		  { "TOTAL_PARTS: The total number of parts", "ansi_801.total_parts",
+		    FT_UINT16, BASE_DEC, NULL, 0x001f,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_coordinate_type_requested,
+		  { "Coordinate type requested", "ansi_801.coordinate_type_requested",
+		    FT_BOOLEAN, 8, TFS(&tfs_spherical_cartesian), 0x80,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_extended_base_station_almanac,
+		  { "Extended base station almanac", "ansi_801.extended_base_station_almanac",
+		    FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), 0x80,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_alpha_and_beta_parameters,
+		  { "Alpha and Beta parameters", "ansi_801.alpha_and_beta_parameters",
+		    FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), 0x80,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_subframes_4_and_5,
+		  { "Subframes 4 and 5", "ansi_801.subframes_4_and_5",
+		    FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), 0x80,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_req_loc_height_information,
+		  { "Height information", "ansi_801.height_information",
+		    FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), 0x80,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_req_loc_clock_correction_for_gps_time,
+		  { "Clock correction for GPS time", "ansi_801.clock_correction_for_gps_time",
+		    FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), 0x40,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_req_loc_velocity_information,
+		  { "Velocity information", "ansi_801.velocity_information",
+		    FT_BOOLEAN, 8, TFS(&tfs_requested_not_requested), 0x20,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved8_1F,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT8, BASE_HEX, NULL, 0x1F,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_ms_ls_rev,
+		  { "MS_LS_REV", "ansi_801.ms_ls_rev",
+		    FT_UINT16, BASE_DEC, NULL, 0xfc00,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_ms_mode,
+		  { "MS_MODE", "ansi_801.ms_mode",
+		    FT_UINT16, BASE_DEC, NULL, 0x03c0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_pilot_ph_cap,
+		  { "PILOT_PH_CAP", "ansi_801.pilot_ph_cap",
+		    FT_UINT16, BASE_DEC, NULL, 0x003f,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_acq_cap,
+		  { "GPS_ACQ_CAP", "ansi_801.gps_acq_cap",
+		    FT_UINT24, BASE_HEX, NULL, 0x000FFF,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved_24_F80000,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT24, BASE_HEX, NULL, 0xf80000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_autonomous_acquisition_capable,
+		  { "GPS Autonomous Acquisition Capable", "ansi_801.gps_autonomous_acquisition_capable",
+		    FT_BOOLEAN, 24, NULL, 0x040000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_almanac_correction,
+		  { "GPS Almanac Correction", "ansi_801.gps_almanac_correction",
+		    FT_BOOLEAN, 24, NULL, 0x020000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_navigation_message_bits,
+		  { "GPS Navigation Message Bits", "ansi_801.gps_navigation_message_bits",
+		    FT_BOOLEAN, 24, NULL, 0x010000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_ephemeris,
+		  { "GPS Ephemeris", "ansi_801.gps_ephemeris",
+		    FT_BOOLEAN, 24, NULL, 0x008000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_almanac,
+		  { "GPS Almanac", "ansi_801.gps_almanac",
+		    FT_BOOLEAN, 24, NULL, 0x004000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_sensitivity_assistance,
+		  { "GPS Sensitivity Assistance", "ansi_801.gps_sensitivity_assistance",
+		    FT_BOOLEAN, 24, NULL, 0x002000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_acquisition_assistance,
+		  { "GPS Acquisition Assistance", "ansi_801.gps_acquisition_assistance",
+		    FT_BOOLEAN, 24, NULL, 0x001000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_loc_calc_cap,
+		  { "LOC_CALC_CAP", "ansi_801.loc_calc_cap",
+		    FT_UINT24, BASE_HEX, NULL, 0x000FFF,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_pre_programmed_location,
+		  { "Pre-programmed Location", "ansi_801.pre_programmed_location",
+		    FT_BOOLEAN, 24, NULL, 0x000800,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved_24_700,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT24, BASE_HEX, NULL, 0x000700,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_hybrid_gps_and_aflt_lcc,
+		  { "Hybrid GPS and AFLT Location Calculation Capable", "ansi_801.hybrid_gps_and_aflt_lcc",
+		    FT_BOOLEAN, 24, NULL, 0x000080,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_autonomous_location_calculation_capable,
+		  { "Autonomous Location Calculation Capable", "ansi_801.autonomous_lcc",
+		    FT_BOOLEAN, 24, NULL, 0x000040,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_lcc_using_gps_almanac_correction,
+		  { "Location Calculation Capable using GPS Almanac Correction", "ansi_801.lcc_using_gps_almanac_correction",
+		    FT_BOOLEAN, 24, NULL, 0x000020,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_lcc_using_gps_ephemeris_assistance,
+		  { "Location Calculation Capable using GPS Ephemeris Assistance", "ansi_801.lcc_using_gps_ephemeris_assistance",
+		    FT_BOOLEAN, 24, NULL, 0x000010,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_lcc_using_gps_almanac_assistance,
+		  { "Location Calculation Capable using GPS Almanac Assistance", "ansi_801.lcc_using_gps_almanac_assistance",
+		    FT_BOOLEAN, 24, NULL, 0x000008,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_aflt_lcc,
+		  { "Advanced Forward Link Trilateration (AFLT) Location Calculation Capable", "ansi_801.aflt_lcc",
+		    FT_BOOLEAN, 24, NULL, 0x000004,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_lcc_using_location_assistance_cartesian,
+		  { "Location Calculation Capable using Location Assistance - Cartesian", "ansi_801.lcc_using_location_assistance.cartesian",
+		    FT_BOOLEAN, 24, NULL, 0x000002,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_lcc_capable_using_location_assistance_spherical,
+		  { "Location Calculation Capable using Location Assistance - Spherical", "ansi_801.lcc_using_location_assistance.spherical",
+		    FT_BOOLEAN, 24, NULL, 0x000001,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_ref_pn,
+		  { "REF_PN", "ansi_801.ref_pn",
+		    FT_UINT24, BASE_DEC, NULL, 0xff8000,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_mob_sys_t_offset,
+		  { "MOB_SYS_T_OFFSET", "ansi_801.mob_sys_t_offset",
+		    FT_UINT24, BASE_DEC, NULL, 0x007ffe,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved24_1,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT24, BASE_HEX, NULL, 0x000001,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_no_outstanding_request_element,
+		  { "No outstanding request element", "ansi_801.no_outstanding_request_element",
+		    FT_BOOLEAN, 8, NULL, 0x08,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved8_07,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT8, BASE_HEX, NULL, 0x07,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved8_F0,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT8, BASE_HEX, NULL, 0xF0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_request_length,
+		  { "Length", "ansi_801.for_request_length",
+		    FT_UINT8, BASE_DEC, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_reserved8_E0,
+		  { "Reserved", "ansi_801.reserved",
+		    FT_UINT8, BASE_HEX, NULL, 0xE0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_unsolicited_response_indicator,
+		  { "Unsolicited response indicator", "ansi_801.unsolicited_response_indicator",
+		    FT_BOOLEAN, 8, NULL, 0x10,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_response_length,
+		  { "Length", "ansi_801.for_response_length",
+		    FT_UINT8, BASE_DEC, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_request_length,
+		  { "Length", "ansi_801.rev_request_length",
+		    FT_UINT8, BASE_DEC, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_response_length,
+		  { "Length", "ansi_801.rev_response_length",
+		    FT_UINT8, BASE_DEC, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_session_start,
+		  { "Session Start", "ansi_801.session_start",
+		    FT_BOOLEAN, 8, NULL, 0x80,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_session_end,
+		  { "Session End", "ansi_801.session_end",
+		    FT_BOOLEAN, 8, NULL, 0x40,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_session_source,
+		  { "Session Source", "ansi_801.session_source",
+		    FT_BOOLEAN, 8, NULL, 0x20,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_pd_message_type,
+		  { "PD Message Type", "ansi_801.pd_message_type",
+		    FT_UINT8, BASE_DEC, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_pd_message_len,
+		  { "PD Message Length", "ansi_801.pd_message_len",
+		    FT_UINT16, BASE_DEC, NULL, 0xffc0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_regulatory_services_indicator,
+		  { "Regulatory Services Indicator", "ansi_801.regulatory_services_indicator",
+		    FT_UINT16, BASE_DEC, VALS(regulatory_services_indicator_vals), 0x0030,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_message_number_requests16,
+		  { "Number Requests", "ansi_801.for_message_number_requests",
+		    FT_UINT16, BASE_DEC, NULL, 0x0F,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_message_number_responsesF0,
+		  { "Number Responses", "ansi_801.for_message_number_responses",
+		    FT_UINT8, BASE_DEC, NULL, 0xF0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_message_number_requests8,
+		  { "Number Requests", "ansi_801.for_message_number_requests",
+		    FT_UINT8, BASE_DEC, NULL, 0xF0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_for_message_number_responses0F,
+		  { "Number Responses", "ansi_801.for_message_number_responses",
+		    FT_UINT8, BASE_DEC, NULL, 0x0F,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_message_number_requests16,
+		  { "Number Requests", "ansi_801.rev_message_number_requests",
+		    FT_UINT16, BASE_DEC, NULL, 0x0F,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_message_number_responsesF0,
+		  { "Number Responses", "ansi_801.rev_message_number_responses",
+		    FT_UINT8, BASE_DEC, NULL, 0xF0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_message_number_requests8,
+		  { "Number Requests", "ansi_801.rev_message_number_requests",
+		    FT_UINT8, BASE_DEC, NULL, 0xF0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_rev_message_number_responses0F,
+		  { "Number Responses", "ansi_801.rev_message_number_responses",
+		    FT_UINT8, BASE_DEC, NULL, 0x0F,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_data,
+		  { "Data", "ansi_801.data",
+		    FT_BYTES, BASE_NONE, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_proprietary_data,
+		  { "Reserved/Proprietary/Future Data", "ansi_801.proprietary_data",
+		    FT_BYTES, BASE_NONE, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_time_ref_ms,
+		  { "TIME_REF_MS", "ansi_801.time_ref_ms",
+		    FT_UINT24, BASE_DEC, NULL, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_time_of_almanac,
+		  { "Time of almanac", "ansi_801.time_of_almanac",
+		    FT_UINT8, BASE_DEC|BASE_UNIT_STRING, &units_time_of_almanac, 0x0,
+		    NULL, HFILL }
+		},
+		{ &hf_ansi_801_gps_week_number,
+		  { "GPS week number", "ansi_801.gps_week_number",
+		    FT_UINT8, BASE_DEC|BASE_UNIT_STRING, &units_gps_week_number, 0x0,
+		    NULL, HFILL }
+		},
+	};
+
+	/* Setup protocol subtree array */
+#define	NUM_INDIVIDUAL_PARAMS	3
+	gint *ett[NUM_INDIVIDUAL_PARAMS+NUM_FOR_REQ_TYPE+NUM_FOR_RSP_TYPE+NUM_REV_REQ_TYPE+NUM_REV_RSP_TYPE];
+
+
+	static ei_register_info ei[] = {
+		{ &ei_ansi_801_extraneous_data, { "ansi_801.extraneous_data", PI_PROTOCOL, PI_NOTE, "Extraneous Data, dissector bug or later version spec(report to wireshark.org)", EXPFILL }},
+		{ &ei_ansi_801_short_data, { "ansi_801.short_data", PI_PROTOCOL, PI_NOTE, "Short Data (?) - try checking decoder variant preference or dissector bug/later version spec (report to wireshark.org)", EXPFILL }},
+		{ &ei_ansi_801_unexpected_length, { "ansi_801.unexpected_length", PI_PROTOCOL, PI_WARN, "Unexpected Data Length - try checking decoder variant preference or dissector bug/later version spec (report to wireshark.org)", EXPFILL }},
+	};
+
+	expert_module_t* expert_ansi_801;
+
+	ett[0] = &ett_ansi_801;
+	ett[1] = &ett_gps;
+	ett[2] = &ett_loc;
+
+	last_offset = NUM_INDIVIDUAL_PARAMS;
+
+	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];
+	}
+
+	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];
+	}
+
+	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];
+	}
+
+	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];
+	}
+
+	/* Register the protocol name and description */
+	proto_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));
+	proto_register_subtree_array(ett, array_length(ett));
+	expert_ansi_801 = expert_register_protocol(proto_ansi_801);
+	expert_register_field_array(expert_ansi_801, ei, array_length(ei));
+
+	/* subdissector code */
+	ansi_801_handle = register_dissector("ansi_801", dissect_ansi_801, proto_ansi_801);
+}
+
+
+void
+proto_reg_handoff_ansi_801(void)
+{
+	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);
+}
+
+/*
+ * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 8
+ * tab-width: 8
+ * indent-tabs-mode: t
+ * End:
+ *
+ * vi: set shiftwidth=8 tabstop=8 noexpandtab:
+ * :indentSize=8:tabSize=8:noTabs=false:
+ */