From 3ffb8e29b9600cae716049dc2c1e7b0c1e53ec3f Mon Sep 17 00:00:00 2001 From: Michael Mann Date: Sun, 18 Aug 2013 02:11:36 +0000 Subject: HCI: Full dissection of EIR/AD and little improve filtering, bug 9050 (https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=9050) From Michal Labedzki. From me: 1. Have boolean filters use tfs_true_false instead of NULL (because it appears previous functionality had "TRUE" and "FALSE"). Perhaps other tfs_ values could be used, but tfs_true_false makes a good placeholder. 2. Add FT_ETHER field as a proto_tree_add_item. svn path=/trunk/; revision=51410 --- epan/dissectors/packet-bthci_evt.c | 473 ++++++++++++++++++++++++++----------- 1 file changed, 334 insertions(+), 139 deletions(-) (limited to 'epan/dissectors/packet-bthci_evt.c') diff --git a/epan/dissectors/packet-bthci_evt.c b/epan/dissectors/packet-bthci_evt.c index abb6157743..3194b59849 100644 --- a/epan/dissectors/packet-bthci_evt.c +++ b/epan/dissectors/packet-bthci_evt.c @@ -41,6 +41,7 @@ #include #include "packet-bluetooth-hci.h" +#include "packet-sdp.h" static dissector_handle_t bthci_com_handle; @@ -349,10 +350,11 @@ static int hf_bthci_evt_flags_general_disc_mode = -1; static int hf_bthci_evt_flags_bredr_not_support = -1; static int hf_bthci_evt_flags_le_bredr_support_ctrl = -1; static int hf_bthci_evt_flags_le_bredr_support_host = -1; -static int hf_bthci_evt_flags_le_oob_data_present = -1; -static int hf_bthci_evt_flags_le_oob_le_supported_host = -1; -static int hf_bthci_evt_flags_le_oob_le_bredr_support = -1; -static int hf_bthci_evt_flags_le_oob_address_type = -1; +static int hf_bthci_evt_flags_reserved = -1; +static int hf_bthci_evt_oob_flags_oob_data_present = -1; +static int hf_bthci_evt_oob_flags_le_supported_host = -1; +static int hf_bthci_evt_oob_flags_simultaneous_le_and_br_edr_host = -1; +static int hf_bthci_evt_oob_flags_address_type = -1; static int hf_bthci_evt_le_states_00 = -1; static int hf_bthci_evt_le_states_01 = -1; static int hf_bthci_evt_le_states_02 = -1; @@ -382,6 +384,29 @@ static int hf_bthci_evt_le_states_31 = -1; static int hf_bthci_evt_le_states_32 = -1; static int hf_bthci_evt_le_states_33 = -1; static int hf_bthci_evt_le_states_34 = -1; +static int hf_bthci_evt_eir_ad_ssp_oob_length = -1; +static int hf_bthci_evt_eir_ad_advertising_interval = -1; +static int hf_bthci_evt_eir_ad_company_id = -1; +static int hf_3ds_association_notification = -1; +static int hf_3ds_battery_level_reporting = -1; +static int hf_3ds_send_battery_level_report_on_startup = -1; +static int hf_3ds_reserved = -1; +static int hf_3ds_factory_test_mode = -1; +static int hf_3ds_path_loss_threshold = -1; +static int hf_3ds_legacy_fixed = -1; +static int hf_3ds_legacy_3d_capable_tv = -1; +static int hf_3ds_legacy_ignored_1_3 = -1; +static int hf_3ds_legacy_fixed_4 = -1; +static int hf_3ds_legacy_ignored_5 = -1; +static int hf_3ds_legacy_fixed_6 = -1; +static int hf_3ds_legacy_test_mode = -1; +static int hf_3ds_legacy_path_loss_threshold = -1; +static int hf_did_vendor_id = -1; +static int hf_did_vendor_id_bluetooth_sig = -1; +static int hf_did_vendor_id_usb_forum = -1; +static int hf_did_product_id = -1; +static int hf_did_version = -1; +static int hf_did_vendor_id_source = -1; static expert_field ei_eir_undecoded = EI_INIT; static expert_field ei_eir_unknown = EI_INIT; @@ -398,6 +423,10 @@ static gint ett_eir_subtree = -1; static gint ett_eir_struct_subtree = -1; static gint ett_le_state_subtree = -1; +extern value_string_ext ext_usb_vendors_vals; +extern value_string_ext ext_usb_products_vals; +extern value_string_ext did_vendor_id_source_vals_ext; + static const value_string evt_code_vals[] = { {0x01, "Inquiry Complete"}, {0x02, "Inquiry Result"}, @@ -796,12 +825,6 @@ static const value_string evt_power_level_types[] = { {0, NULL } }; -static const value_string evt_boolean[] = { - {0x0 , "False" }, - {0x1 , "True" }, - {0, NULL } -}; - static const value_string evt_pin_types[] = { {0x00, "Variable PIN" }, {0x01, "Fixed PIN" }, @@ -948,21 +971,20 @@ static int dissect_bthci_evt_bd_addr(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, guint8 *bdaddr) { - guint8 i, bd_addr[6]; - proto_item *handle_item; + guint8 bd_addr[6]; - for(i=6; i; i--) - bd_addr[6-i] = tvb_get_guint8(tvb, offset+i-1); + bd_addr[5] = tvb_get_guint8(tvb, offset); + bd_addr[4] = tvb_get_guint8(tvb, offset + 1); + bd_addr[3] = tvb_get_guint8(tvb, offset + 2); + bd_addr[2] = tvb_get_guint8(tvb, offset + 3); + bd_addr[1] = tvb_get_guint8(tvb, offset + 4); + bd_addr[0] = tvb_get_guint8(tvb, offset + 5); if (bdaddr) memcpy(bdaddr, bd_addr, 6); - handle_item = proto_tree_add_item(tree, hf_bthci_evt_bd_addr, tvb, offset, 6, ENC_NA); - proto_item_append_text(handle_item, "%02x%02x:%02x:%02x%02x%02x (%s)", - bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5], - get_ether_name(bd_addr)); - - offset+=6; + proto_tree_add_item(tree, hf_bthci_evt_bd_addr, tvb, offset, 6, ENC_NA); + offset += 6; return offset; } @@ -1747,12 +1769,12 @@ static int dissect_bthci_evt_eir_ad_data(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, guint8 size, guint8 *bd_addr) { - guint16 i, j; - guint8 length, type; - proto_item *ti_eir = NULL; - proto_item *ti_eir_subtree = NULL; + guint16 i, j; + guint8 length, type; + proto_item *ti_eir = NULL; + proto_item *ti_eir_subtree = NULL; proto_item *sub_item; - hci_data_t *hci_data = (hci_data_t *) pinfo->private_data; + hci_data_t *hci_data = (hci_data_t *) pinfo->private_data; if(tree){ if(size == 240 ) { /* EIR data */ @@ -1791,6 +1813,8 @@ dissect_bthci_evt_eir_ad_data(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_flags_bredr_not_support, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_flags_le_bredr_support_ctrl, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_flags_le_bredr_support_host, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_flags_reserved, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); + } break; case 0x02: /* 16-bit Service Class UUIDs, incomplete list */ @@ -1860,15 +1884,13 @@ dissect_bthci_evt_eir_ad_data(tvbuff_t *tvb, int offset, packet_info *pinfo, case 0x0A: /* Tx Power Level */ proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_transmit_power_level, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); break; - case 0x0B: /* OOB Optional Data Length */ -/* TODO */ - sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, length - 1, ENC_NA); - expert_add_info(pinfo, sub_item, &ei_eir_undecoded); + case 0x0B: /* Secure Simple Pairing OOB Length */ + /* From CSS v3.pdf */ + proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_eir_ad_ssp_oob_length, tvb, offset + i + 2, 2, ENC_LITTLE_ENDIAN); break; case 0x0C: /* BD_ADDR */ -/* TODO */ - sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, length - 1, ENC_NA); - expert_add_info(pinfo, sub_item, &ei_eir_undecoded); + /* From CSS v3.pdf */ + dissect_bthci_evt_bd_addr(tvb, offset + i + 2, pinfo, tree, NULL); break; case 0x0D: /* Class of Device */ dissect_bthci_evt_cod(tvb, offset+i+2, pinfo, ti_eir_struct_subtree); @@ -1879,28 +1901,59 @@ dissect_bthci_evt_eir_ad_data(tvbuff_t *tvb, int offset, packet_info *pinfo, case 0x0F: /* Simple Pairing Randomizer R */ proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_randomizer_r, tvb, offset+i+2, 16, ENC_NA); break; - case 0x10: /* Device ID/Security Manager TK Value */ -/* TODO */ - sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, length - 1, ENC_NA); - expert_add_info(pinfo, sub_item, &ei_eir_undecoded); + case 0x10: /* Device ID / Security Manager TK Value */ +#if 0 +/* XXX: Need to know how to check (or is it possible) that is le_physical_channel or not */ + if (le_physical_channel) { /* Security Manager TK Value - Value as used in pairing over LE Physical channel. */ + sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, 16, ENC_NA); + expert_add_info(pinfo, sub_item, &ei_eir_undecoded); + } + break; +#endif + { + /* DID */ + guint16 vendor_id_source; + guint16 vendor_id; + guint16 product_id; + const gchar *str_val; + + proto_tree_add_item(ti_eir_struct_subtree, hf_did_vendor_id_source, tvb, offset + i + 2, 2, ENC_LITTLE_ENDIAN); + vendor_id_source = tvb_get_letohs(tvb, offset + i + 2); + + if (vendor_id_source == DID_VENDOR_ID_SOURCE_BLUETOOTH_SIG) { + proto_tree_add_item(ti_eir_struct_subtree, hf_did_vendor_id_bluetooth_sig, tvb, offset + i + 2 + 2, 2, ENC_LITTLE_ENDIAN); + } else if (vendor_id_source == DID_VENDOR_ID_SOURCE_USB_FORUM) { + proto_tree_add_item(ti_eir_struct_subtree, hf_did_vendor_id_usb_forum, tvb, offset + i + 2 + 2, 2, ENC_LITTLE_ENDIAN); + } else { + proto_tree_add_item(ti_eir_struct_subtree, hf_did_vendor_id, tvb, offset + i + 2 + 2, 2, ENC_LITTLE_ENDIAN); + } + vendor_id = tvb_get_letohs(tvb, offset + i + 2 + 2); + + sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_did_product_id, tvb, offset + i + 2 + 4, 2, ENC_LITTLE_ENDIAN); + product_id = tvb_get_letohs(tvb, offset + i + 2 + 4); + + if (vendor_id_source == DID_VENDOR_ID_SOURCE_USB_FORUM) { + str_val = val_to_str_ext_const(vendor_id << 16 | product_id, &ext_usb_products_vals, "Unknown"); + proto_item_append_text(sub_item, " (%s)", str_val); + } + + proto_tree_add_item(ti_eir_struct_subtree, hf_did_version, tvb, offset + i + 2 + 6, 2, ENC_LITTLE_ENDIAN); + } break; case 0x11: /* Security Manager OOB Flags */ - proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_flags_le_oob_data_present, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); - proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_flags_le_oob_le_supported_host, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); - proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_flags_le_oob_le_bredr_support, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); - proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_flags_le_oob_address_type, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_oob_flags_oob_data_present, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_oob_flags_le_supported_host, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_oob_flags_simultaneous_le_and_br_edr_host, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_oob_flags_address_type, tvb, offset+i+2, 1, ENC_LITTLE_ENDIAN); break; case 0x12: /* Slave Connection Interval Range */ - { - proto_item *item; + sub_item = proto_tree_add_item(tree, hf_bthci_evt_le_con_interval, tvb, offset+i+2, 2, ENC_LITTLE_ENDIAN); + proto_item_append_text(sub_item, " Min (%g msec)", tvb_get_letohs(tvb, offset+i+2)*1.25); - item = proto_tree_add_item(tree, hf_bthci_evt_le_con_interval, tvb, offset+i+2, 2, ENC_LITTLE_ENDIAN); - proto_item_append_text(item, " Min (%g msec)", tvb_get_letohs(tvb, offset+i+2)*1.25); - item = proto_tree_add_item(tree, hf_bthci_evt_le_con_interval, tvb, offset+i+4, 2, ENC_LITTLE_ENDIAN); - proto_item_append_text(item, " Max (%g msec)", tvb_get_letohs(tvb, offset+i+4)*1.25); + sub_item = proto_tree_add_item(tree, hf_bthci_evt_le_con_interval, tvb, offset+i+4, 2, ENC_LITTLE_ENDIAN); + proto_item_append_text(sub_item, " Max (%g msec)", tvb_get_letohs(tvb, offset+i+4)*1.25); proto_item_append_text(ti_eir_struct,": %g - %g msec", tvb_get_letohs(tvb, offset+i+2)*1.25, tvb_get_letohs(tvb, offset+i+4)*1.25); break; - } case 0x16: /* Service Data */ proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_sc_uuid16, tvb, offset+i+2, 2, ENC_LITTLE_ENDIAN); proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 4, length - 3, ENC_NA); @@ -1924,19 +1977,41 @@ dissect_bthci_evt_eir_ad_data(tvbuff_t *tvb, int offset, packet_info *pinfo, break; } case 0x1A: /* Advertising Interval */ -/* TODO */ - sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, length - 1, ENC_NA); - expert_add_info(pinfo, sub_item, &ei_eir_undecoded); + /* From CSS v3.pdf */ + sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_eir_ad_advertising_interval, tvb, offset + i + 2, 2, ENC_LITTLE_ENDIAN); + proto_item_append_text(sub_item, " (%g msec)", tvb_get_letohs(tvb, offset + i + 2) * 0.625); break; case 0x3D: /* 3D Information Data */ -/* TODO */ - sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, length - 1, ENC_NA); - expert_add_info(pinfo, sub_item, &ei_eir_undecoded); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_factory_test_mode, tvb, offset + i + 2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_reserved, tvb, offset + i + 2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_send_battery_level_report_on_startup, tvb, offset + i + 2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_battery_level_reporting, tvb, offset + i + 2, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_association_notification, tvb, offset + i + 2, 1, ENC_LITTLE_ENDIAN); + + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_path_loss_threshold, tvb, offset + i + 2 + 1, 1, ENC_LITTLE_ENDIAN); + break; - case 0xFF: /* Manufacturer Specific */ -/* TODO: decode 3DS profile for Legacy Devices */ - sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, length - 1, ENC_NA); - expert_add_info(pinfo, sub_item, &ei_eir_undecoded); + case 0xFF: /* Manufacturer Specific */ { + guint16 company_id; + + proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_eir_ad_company_id, tvb, offset + i + 2, 2, ENC_LITTLE_ENDIAN); + company_id = tvb_get_letohs(tvb, offset + i + 2); + if (company_id == 0x000F && tvb_get_guint8(tvb, offset + i + 2 + 2) == 0) { /* 3DS profile Legacy Devices */ + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_legacy_fixed, tvb, offset + i + 2 + 2, 1, ENC_LITTLE_ENDIAN); + + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_legacy_3d_capable_tv, tvb, offset + i + 2 + 3, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_legacy_ignored_1_3, tvb, offset + i + 2 + 3, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_legacy_fixed_4, tvb, offset + i + 2 + 3, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_legacy_ignored_5, tvb, offset + i + 2 + 3, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_legacy_fixed_6, tvb, offset + i + 2 + 3, 1, ENC_LITTLE_ENDIAN); + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_legacy_test_mode, tvb, offset + i + 2 + 3, 1, ENC_LITTLE_ENDIAN); + + proto_tree_add_item(ti_eir_struct_subtree, hf_3ds_legacy_path_loss_threshold, tvb, offset + i + 2 + 4, 1, ENC_LITTLE_ENDIAN); + } else { + sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, length - 1, ENC_NA); + expert_add_info(pinfo, sub_item, &ei_eir_undecoded); + } + } break; default: sub_item = proto_tree_add_item(ti_eir_struct_subtree, hf_bthci_evt_data, tvb, offset + i + 2, length - 1, ENC_NA); @@ -1949,7 +2024,7 @@ dissect_bthci_evt_eir_ad_data(tvbuff_t *tvb, int offset, packet_info *pinfo, } } - return offset+size; + return offset + size; } static int @@ -4019,8 +4094,8 @@ proto_register_bthci_evt(void) NULL, HFILL } }, { &hf_bthci_evt_bd_addr, - { "BD_ADDR:", "bthci_evt.bd_addr", - FT_NONE, BASE_NONE, NULL, 0x0, + { "BD_ADDR", "bthci_evt.bd_addr", + FT_ETHER, BASE_NONE, NULL, 0x0, "Bluetooth Device Address", HFILL} }, { &hf_bthci_evt_class_of_device, @@ -4310,77 +4385,77 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_link_type_2dh1, { "ACL Link Type 2-DH1", "bthci_evt.link_type_2dh1", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0002, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0002, NULL, HFILL } }, { &hf_bthci_evt_link_type_3dh1, { "ACL Link Type 3-DH1", "bthci_evt.link_type_3dh1", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0004, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0004, NULL, HFILL } }, { &hf_bthci_evt_link_type_dm1, { "ACL Link Type DM1", "bthci_evt.link_type_dm1", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0008, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0008, NULL, HFILL } }, { &hf_bthci_evt_link_type_dh1, { "ACL Link Type DH1", "bthci_evt.link_type_dh1", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0010, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0010, NULL, HFILL } }, { &hf_bthci_evt_link_type_2dh3, { "ACL Link Type 2-DH3", "bthci_evt.link_type_2dh3", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0100, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0100, NULL, HFILL } }, { &hf_bthci_evt_link_type_3dh3, { "ACL Link Type 3-DH3", "bthci_evt.link_type_3dh3", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0200, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0200, NULL, HFILL } }, { &hf_bthci_evt_link_type_dm3, { "ACL Link Type DM3", "bthci_evt.link_type_dm3", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0400, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0400, NULL, HFILL } }, { &hf_bthci_evt_link_type_dh3, { "ACL Link Type DH3", "bthci_evt.link_type_dh3", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0800, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0800, NULL, HFILL } }, { &hf_bthci_evt_link_type_2dh5, { "ACL Link Type 2-DH5", "bthci_evt.link_type_2dh5", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x1000, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x1000, NULL, HFILL } }, { &hf_bthci_evt_link_type_3dh5, { "ACL Link Type 3-DH5", "bthci_evt.link_type_3dh5", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x2000, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x2000, NULL, HFILL } }, { &hf_bthci_evt_link_type_dm5, { "ACL Link Type DM5", "bthci_evt.link_type_dm5", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x4000, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x4000, NULL, HFILL } }, { &hf_bthci_evt_link_type_dh5, { "ACL Link Type DH5", "bthci_evt.link_type_dh5", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x8000, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x8000, NULL, HFILL } }, { &hf_bthci_evt_link_type_hv1, { "SCO Link Type HV1", "bthci_evt.link_type_hv1", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0020, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0020, NULL, HFILL } }, { &hf_bthci_evt_link_type_hv2, { "SCO Link Type HV2", "bthci_evt.link_type_hv2", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0040, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0040, NULL, HFILL } }, { &hf_bthci_evt_link_type_hv3, { "SCO Link Type HV3", "bthci_evt.link_type_hv3", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0080, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0080, NULL, HFILL } }, { &hf_lmp_features, @@ -4740,22 +4815,22 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_link_policy_setting_switch, { "Enable Master Slave Switch", "bthci_evt.link_policy_switch", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0001, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0001, NULL, HFILL } }, { &hf_bthci_evt_link_policy_setting_hold, { "Enable Hold Mode", "bthci_evt.link_policy_hold", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0002, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0002, NULL, HFILL } }, { &hf_bthci_evt_link_policy_setting_sniff, { "Enable Sniff Mode", "bthci_evt.link_policy_sniff", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0004, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0004, NULL, HFILL } }, { &hf_bthci_evt_link_policy_setting_park, { "Enable Park Mode", "bthci_evt.link_policy_park", - FT_UINT16, BASE_DEC, VALS(evt_boolean), 0x0008, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0008, NULL, HFILL } }, { &hf_bthci_evt_curr_role, @@ -4820,17 +4895,17 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_hold_mode_act_page, { "Suspend Page Scan", "bthci_evt.hold_mode_page", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x1, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x1, "Device can enter low power state", HFILL } }, { &hf_bthci_evt_hold_mode_act_inquiry, { "Suspend Inquiry Scan", "bthci_evt.hold_mode_inquiry", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x2, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x2, "Device can enter low power state", HFILL } }, { &hf_bthci_evt_hold_mode_act_periodic, { "Suspend Periodic Inquiries", "bthci_evt.hold_mode_periodic", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x4, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x4, "Device can enter low power state", HFILL } }, { &hf_bthci_evt_transmit_power_level, @@ -4915,7 +4990,7 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_fec_required, {"FEC Required", "bthci_evt.fec_required", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x0, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x0, NULL, HFILL} }, { &hf_bthci_evt_err_data_reporting, @@ -5115,7 +5190,7 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_location_domain_aware, { "Location Domain Aware", "bthci_evt.location_domain_aware", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x0, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x0, NULL, HFILL } }, { &hf_bthci_evt_location_domain, @@ -5215,7 +5290,7 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_pal_capabilities_00, { "Guaranteed Service", "bthci_evt.pal_capabilities", - FT_UINT16, BASE_HEX, VALS(evt_boolean), 0x0001, + FT_BOOLEAN, 16, TFS(&tfs_true_false), 0x0001, NULL, HFILL } }, { &hf_bthci_evt_max_amp_assoc_length, @@ -5280,7 +5355,7 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_short_range_mode_state, { "Short Range Mode State", "bthci_evt.short_range_mode_state", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x0, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x0, NULL, HFILL } }, { &hf_bthci_evt_transmit_power_level_gfsk, @@ -5305,12 +5380,12 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_le_supported_host, { "LE Supported Host", "bthci_evt.le_supported_host", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x0, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x0, NULL, HFILL } }, { &hf_bthci_evt_le_simultaneous_host, { "Simultaneous LE Host", "bthci_evt.le_simlutaneous_host", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x0, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x0, "Support for both LE and BR/EDR to same device", HFILL } }, { &hf_bthci_evt_le_acl_data_pkt_len, @@ -5325,7 +5400,7 @@ proto_register_bthci_evt(void) }, { &hf_bthci_evt_le_feature_00, { "LE Encryption", "bthci_evt.le_feature", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x01, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, NULL, HFILL } }, { &hf_bthci_evt_white_list_size, @@ -5404,195 +5479,315 @@ proto_register_bthci_evt(void) NULL, HFILL } }, { &hf_bthci_evt_flags_limited_disc_mode, - { "LE Limited Discoverable Mode", "bthci_evt.le_flags_limit_disc_mode", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x01, + { "LE Limited Discoverable Mode", "bthci_evt.le_flags.limit_disc_mode", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, NULL, HFILL } }, { &hf_bthci_evt_flags_general_disc_mode, - { "LE General Discoverable Mode", "bthci_evt.le_flags_general_disc_mode", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x02, + { "LE General Discoverable Mode", "bthci_evt.le_flags.general_disc_mode", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x02, NULL, HFILL } }, { &hf_bthci_evt_flags_bredr_not_support, - { "BR/EDR Not Supported", "bthci_evt.le_flags_bredr_not_supported", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x04, + { "BR/EDR Not Supported", "bthci_evt.le_flags.bredr_not_supported", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x04, NULL, HFILL } }, { &hf_bthci_evt_flags_le_bredr_support_ctrl, - { "Simultaneous LE and BR/EDR to Same Device Capable (Controller)", "bthci_evt.le_flags_bredr_support_ctrl", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x08, + { "Simultaneous LE and BR/EDR to Same Device Capable (Controller)", "bthci_evt.le_flags.bredr_support_ctrl", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x08, NULL, HFILL } }, { &hf_bthci_evt_flags_le_bredr_support_host, - { "Simultaneous LE and BR/EDR to Same Device Capable (Host)", "bthci_evt.le_flags_bredr_support_host", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x10, + { "Simultaneous LE and BR/EDR to Same Device Capable (Host)", "bthci_evt.le_flags.bredr_support_host", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x10, NULL, HFILL } }, - { &hf_bthci_evt_flags_le_oob_data_present, - { "OOB Data Present", "bthci_evt.le_flags_le_oob_data_present", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x01, + { &hf_bthci_evt_flags_reserved, + { "Reserved", "bthci_evt.le_flags.reserved", + FT_BOOLEAN, 8, NULL, 0xE0, NULL, HFILL } }, - { &hf_bthci_evt_flags_le_oob_le_supported_host, - { "LE Supported By Host", "bthci_evt.le_flags_le_oob_le_supported_host", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x02, + { &hf_bthci_evt_oob_flags_oob_data_present, + { "OOB Data Present", "bthci_evt.oob_flags.oob_data_present", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, NULL, HFILL } }, - { &hf_bthci_evt_flags_le_oob_le_bredr_support, - { "Simultaneous LE and BR/EDR to Same Device Capable (Host)", "bthci_evt.le_flags_le_oob_le_bredr_support", - FT_UINT8, BASE_HEX, VALS(evt_boolean), 0x04, + { &hf_bthci_evt_oob_flags_le_supported_host, + { "LE Supported By Host", "bthci_evt.oob_flags.le_supported_host", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x02, NULL, HFILL } }, - { &hf_bthci_evt_flags_le_oob_address_type, - { "Address Type", "bthci_evt.le_flags_le_oob_address_type", + { &hf_bthci_evt_oob_flags_simultaneous_le_and_br_edr_host, + { "Simultaneous LE and BR/EDR to Same Device Capable (Host)", "bthci_evt.oob_flags.simultaneous_le_and_br_edr_host", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x04, + NULL, HFILL } + }, + { &hf_bthci_evt_oob_flags_address_type, + { "Address Type", "bthci_evt.oob_flags.address_type", FT_UINT8, BASE_HEX, VALS(bthci_cmd_address_types_vals), 0x08, NULL, HFILL } }, { &hf_bthci_evt_le_states_00, { "Non-connectable Advertising State", "bthci_evt.le_states_00", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x01, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, NULL, HFILL } }, { &hf_bthci_evt_le_states_01, { "Scannable Advertising State", "bthci_evt.le_states_01", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x02, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x02, NULL, HFILL } }, { &hf_bthci_evt_le_states_02, { "Connectable Advertising State", "bthci_evt.le_states_02", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x04, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x04, NULL, HFILL } }, { &hf_bthci_evt_le_states_03, { "Directed Advertising State", "bthci_evt.le_states_03", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x08, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x08, NULL, HFILL } }, { &hf_bthci_evt_le_states_04, { "Passive Scanning State", "bthci_evt.le_states_04", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x10, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x10, NULL, HFILL } }, { &hf_bthci_evt_le_states_05, { "Active Scanning State", "bthci_evt.le_states_05", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x20, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x20, NULL, HFILL } }, { &hf_bthci_evt_le_states_06, { "Initiating State. Connection State in Master Role", "bthci_evt.le_states_06", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x40, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x40, NULL, HFILL } }, { &hf_bthci_evt_le_states_07, { "Connection State in Slave Role", "bthci_evt.le_states_07", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x80, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x80, NULL, HFILL } }, { &hf_bthci_evt_le_states_10, { "Non-connectable Advertising State and Passive Scanning State combination", "bthci_evt.le_states_10", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x01, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, NULL, HFILL } }, { &hf_bthci_evt_le_states_11, { "Scannable Advertising State and Passive Scanning State combination", "bthci_evt.le_states_11", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x02, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x02, NULL, HFILL } }, { &hf_bthci_evt_le_states_12, { "Connectable Advertising State and Passive Scanning State combination", "bthci_evt.le_states_12", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x04, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x04, NULL, HFILL } }, { &hf_bthci_evt_le_states_13, { "Directed Advertising State and Passive Scanning State combination", "bthci_evt.le_states_13", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x08, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x08, NULL, HFILL } }, { &hf_bthci_evt_le_states_14, { "Non-connectable Advertising State and Active Scanning State combination", "bthci_evt.le_states_14", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x10, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x10, NULL, HFILL } }, { &hf_bthci_evt_le_states_15, { "Scannable Advertising State and Active Scanning State combination", "bthci_evt.le_states_15", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x20, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x20, NULL, HFILL } }, { &hf_bthci_evt_le_states_16, { "Connectable Advertising State and Active Scanning State combination", "bthci_evt.le_states_16", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x40, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x40, NULL, HFILL } }, { &hf_bthci_evt_le_states_17, { "Directed Advertising State and Active Scanning State combination", "bthci_evt.le_states_17", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x80, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x80, NULL, HFILL } }, { &hf_bthci_evt_le_states_20, { "Non-connectable Advertising State and Initiating State combination", "bthci_evt.le_states_20", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x01, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, NULL, HFILL } }, { &hf_bthci_evt_le_states_21, { "Scannable Advertising State and Initiating State combination", "bthci_evt.le_states_21", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x02, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x02, NULL, HFILL } }, { &hf_bthci_evt_le_states_22, { "Non-connectable Advertising State and Master Role combination", "bthci_evt.le_states_22", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x04, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x04, NULL, HFILL } }, { &hf_bthci_evt_le_states_23, { "Scannable Advertising State and Master Role combination", "bthci_evt.le_states_23", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x08, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x08, NULL, HFILL } }, { &hf_bthci_evt_le_states_24, { "Non-connectable Advertising State and Slave Role combination", "bthci_evt.le_states_24", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x10, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x10, NULL, HFILL } }, { &hf_bthci_evt_le_states_25, { "Scannable Advertising State and Slave Role combination", "bthci_evt.le_states_25", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x20, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x20, NULL, HFILL } }, { &hf_bthci_evt_le_states_26, { "Passive Scanning State and Initiating State combination", "bthci_evt.le_states_26", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x40, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x40, NULL, HFILL } }, { &hf_bthci_evt_le_states_27, { "Active Scanning State and Initiating State combination", "bthci_evt.le_states_27", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x80, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x80, NULL, HFILL } }, { &hf_bthci_evt_le_states_30, { "Passive Scanning State and Master Role combination", "bthci_evt.le_states_30", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x01, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, NULL, HFILL } }, { &hf_bthci_evt_le_states_31, { "Active Scanning State and Master Role combination", "bthci_evt.le_states_31", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x02, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x02, NULL, HFILL } }, { &hf_bthci_evt_le_states_32, { "Passive Scanning state and Slave Role combination", "bthci_evt.le_states_32", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x04, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x04, NULL, HFILL } }, { &hf_bthci_evt_le_states_33, { "Active Scanning state and Slave Role combination", "bthci_evt.le_states_33", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x08, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x08, NULL, HFILL } }, { &hf_bthci_evt_le_states_34, { "Initiating State and Master Role combination. Master Role and Master Role combination", "bthci_evt.le_states_34", - FT_UINT8, BASE_DEC, VALS(evt_boolean), 0x10, + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x10, + NULL, HFILL } + }, + { &hf_bthci_evt_eir_ad_ssp_oob_length, + { "SSP OOB Length", "bthci_evt.eir_ad.ssp_oob_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_bthci_evt_eir_ad_advertising_interval, + { "Advertising Interval", "bthci_evt.eir_ad.advertising_interval", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_bthci_evt_eir_ad_company_id, + { "Company ID", "bthci_evt.eir_ad.company_id", + FT_UINT16, BASE_HEX | BASE_EXT_STRING, &bthci_evt_comp_id_ext, 0x0, + NULL, HFILL } + }, + { &hf_3ds_association_notification, + { "3DS Association Notification", "bthci_evt.eir_ad.3ds.association_notification", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, + NULL, HFILL } + }, + { &hf_3ds_battery_level_reporting, + { "3DS Battery Level Reporting", "bthci_evt.eir_ad.3ds.battery_level_reporting", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x02, + NULL, HFILL } + }, + { &hf_3ds_send_battery_level_report_on_startup, + { "3DS Send Battery Level Report on Startup", "bthci_evt.eir_ad.3ds.send_battery_level_report_on_startup", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x04, + NULL, HFILL } + }, + { &hf_3ds_reserved, + { "Reserved", "bthci_evt.eir_ad.3ds.reserved", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x78, + NULL, HFILL } + }, + { &hf_3ds_factory_test_mode, + { "3DS Factory Test Mode", "bthci_evt.eir_ad.3ds.factory_test_mode", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x80, + NULL, HFILL } + }, + { &hf_3ds_path_loss_threshold, + { "3DS Path Loss Threshold", "bthci_evt.eir_ad.3ds.path_loss_threshold", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_3ds_legacy_fixed, + { "3DS Legacy Fixed", "bthci_evt.eir_ad.3ds_legacy.fixed_byte", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_3ds_legacy_3d_capable_tv, + { "3DS Legacy Capable TV", "bthci_evt.eir_ad.3ds_legacy.capable_tv", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x01, + NULL, HFILL } + }, + { &hf_3ds_legacy_ignored_1_3, + { "3DS Legacy Ignored", "bthci_evt.eir_ad.3ds_legacy.ignored.1_3", + FT_BOOLEAN, 8, NULL, 0x0E, + NULL, HFILL } + }, + { &hf_3ds_legacy_fixed_4, + { "3DS Legacy Fixed", "bthci_evt.eir_ad.3ds_legacy.fixed.4", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x10, NULL, HFILL } }, + { &hf_3ds_legacy_ignored_5, + { "3DS Legacy Ignored", "bthci_evt.eir_ad.3ds_legacy.ignored.5", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x20, + NULL, HFILL } + }, + { &hf_3ds_legacy_fixed_6, + { "3DS Legacy Fixed", "bthci_evt.eir_ad.3ds_legacy.fixed.4", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x40, + NULL, HFILL } + }, + { &hf_3ds_legacy_test_mode, + { "3DS Legacy Test Mode", "bthci_evt.eir_ad.3ds_legacy.test_mode", + FT_BOOLEAN, 8, TFS(&tfs_true_false), 0x80, + NULL, HFILL } + }, + { &hf_3ds_legacy_path_loss_threshold, + { "3DS Legacy Path Loss Threshold", "bthci_evt.eir_ad.3ds_legacy.path_loss_threshold", + FT_UINT8, BASE_DEC, NULL, 0x00, + NULL, HFILL } + }, + { &hf_did_vendor_id_source, + { "Vendor ID Source", "bthci_evt.eir_ad.did.vendor_id_source", + FT_UINT16, BASE_HEX | BASE_EXT_STRING, &did_vendor_id_source_vals_ext, 0, + NULL, HFILL } + }, + { &hf_did_vendor_id, + { "Vendor ID", "bthci_evt.eir_ad.did.vendor_id", + FT_UINT16, BASE_HEX, NULL, 0, + NULL, HFILL } + }, + { &hf_did_vendor_id_bluetooth_sig, + { "Vendor ID", "bthci_evt.eir_ad.did.vendor_id", + FT_UINT16, BASE_HEX | BASE_EXT_STRING, &bthci_evt_comp_id_ext, 0, + NULL, HFILL } + }, + { &hf_did_vendor_id_usb_forum, + { "Vendor ID", "bthci_evt.eir_ad.did.vendor_id", + FT_UINT16, BASE_HEX | BASE_EXT_STRING, &ext_usb_vendors_vals, 0, + NULL, HFILL } + }, + { &hf_did_product_id, + { "Product ID", "bthci_evt.eir_ad.did.product_id", + FT_UINT16, BASE_HEX, NULL, 0, + NULL, HFILL } + }, + { &hf_did_version, + { "Version", "bthci_evt.eir_ad.did.version", + FT_UINT16, BASE_HEX, NULL, 0, + NULL, HFILL } + } }; static ei_register_info ei[] = { -- cgit v1.2.3