void gcp_init(void) {
static gboolean gcp_initialized = FALSE;
if (gcp_initialized)
return;
msgs = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
trxs = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
ctxs_by_trx = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
ctxs = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
gcp_initialized = TRUE;
}
void
proto_register_hci_mon(void)
{
module_t *module;
expert_module_t *expert_module;
static hf_register_info hf[] = {
{ &hf_adapter_id,
{ "Adapter ID", "hci_mon.adapter_id",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_opcode,
{ "Opcode", "hci_mon.opcode",
FT_UINT16, BASE_HEX | BASE_EXT_STRING, &hci_mon_opcode_vals_ext, 0x00,
NULL, HFILL }
},
{ &hf_type,
{ "Type", "hci_mon.type",
FT_UINT8, BASE_HEX | BASE_EXT_STRING, &type_vals_ext, 0x00,
NULL, HFILL }
},
{ &hf_bus,
{ "Bus", "hci_mon.bus",
FT_UINT8, BASE_HEX | BASE_EXT_STRING, &bus_vals_ext, 0x00,
NULL, HFILL }
},
{ &hf_bd_addr,
{ "BD_ADDR", "hci_mon.bd_addr",
FT_ETHER, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{ &hf_name,
{ "Adapter Name", "hci_mon.adapter_name",
FT_STRING, BASE_NONE, NULL, 0x0,
NULL, HFILL}
}
};
static ei_register_info ei[] = {
{ &ei_unknown_data, { "hci_mon.unknown_data", PI_PROTOCOL, PI_WARN, "Unknown data", EXPFILL }},
};
static gint *ett[] = {
&ett_hci_mon,
};
proto_hci_mon = proto_register_protocol("Bluetooth Linux Monitor Transport", "HCI_MON", "hci_mon");
proto_register_field_array(proto_hci_mon, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
hci_mon_handle = register_dissector("hci_mon", dissect_hci_mon, proto_hci_mon);
expert_module = expert_register_protocol(proto_hci_mon);
expert_register_field_array(expert_module, ei, array_length(ei));
adapter_to_disconnect_in_frame = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
module = prefs_register_protocol(proto_hci_mon, NULL);
prefs_register_static_text_preference(module, "bthci_mon.version",
"Bluetooth Linux Monitor Transport introduced in BlueZ 5.x",
"Version of protocol supported by this dissector.");
}
void
proto_register_hci_usb(void)
{
module_t *module;
static hf_register_info hf[] = {
{ &hf_msg_fragments,
{ "Message fragments", "hci_usb.msg.fragments",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment,
{ "Message fragment", "hci_usb.msg.fragment",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_overlap,
{ "Message fragment overlap", "hci_usb.msg.fragment.overlap",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_overlap_conflicts,
{ "Message fragment overlapping with conflicting data", "hci_usb.msg.fragment.overlap.conflicts",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_multiple_tails,
{ "Message has multiple tail fragments", "hci_usb.msg.fragment.multiple_tails",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_too_long_fragment,
{ "Message fragment too long", "hci_usb.msg.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_error,
{ "Message defragmentation error", "hci_usb.msg.fragment.error",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_count,
{ "Message fragment count", "hci_usb.msg.fragment.count",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_reassembled_in,
{ "Reassembled in", "hci_usb.msg.reassembled.in",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_reassembled_length,
{ "Reassembled MP2T length", "hci_usb.msg.reassembled.length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_fragment,
{ "Packet Fragment", "hci_usb.packet.fragment",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_complete,
{ "Packet Complete", "hci_usb.packet.complete",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_unknown_fragment,
{ "Unknown Packet Fragment", "hci_usb.packet.unknown_fragment",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_data,
{ "Unknown Data", "hci_usb.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
}
};
static gint *ett[] = {
&ett_hci_usb,
&ett_hci_usb_msg_fragment,
&ett_hci_usb_msg_fragments,
};
reassembly_table_init(&hci_usb_reassembly_table,
&addresses_reassembly_table_functions);
fragment_info_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
chandle_to_bdaddr_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); /* adapter, chandle: bdaddr */
bdaddr_to_name_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); /* bdaddr: name */
localhost_bdaddr = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); /* adaper, frame: bdaddr */
localhost_name = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope()); /* adaper, frame: name */
proto_hci_usb = proto_register_protocol("Bluetooth HCI USB Transport", "HCI_USB", "hci_usb");
proto_register_field_array(proto_hci_usb, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
new_register_dissector("hci_usb", dissect_hci_usb, proto_hci_usb);
module = prefs_register_protocol(proto_hci_usb, NULL);
prefs_register_static_text_preference(module, "bthci_usb.version",
"Bluetooth HCI USB Transport from Core 4.0",
"Version of protocol supported by this dissector.");
}
void
proto_register_adb(void)
{
module_t *module;
expert_module_t *expert_module;
static hf_register_info hf[] = {
{ &hf_command,
{ "Command", "adb.command",
FT_UINT32, BASE_HEX, VALS(command_vals), 0x00,
NULL, HFILL }
},
{ &hf_argument_0,
{ "Argument 0", "adb.argument.0",
FT_UINT32, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_argument_1,
{ "Argument 0", "adb.argument.1",
FT_UINT32, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_data_length,
{ "Data Length", "adb.data_length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_data_crc32,
{ "Data CRC32", "adb.data_crc32",
FT_UINT32, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_magic,
{ "Magic", "adb.magic",
FT_UINT32, BASE_HEX, VALS(magic_vals), 0x00,
NULL, HFILL }
},
{ &hf_version,
{ "Version", "adb.version",
FT_UINT32, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_max_data,
{ "Max Data", "adb.max_data",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_auth_type,
{ "Type", "adb.auth_type",
FT_UINT32, BASE_HEX, VALS(auth_type_vals), 0x00,
NULL, HFILL }
},
{ &hf_online,
{ "Online", "adb.online",
FT_BOOLEAN, 32, TFS(&tfs_no_yes), 0x00,
NULL, HFILL }
},
{ &hf_sequence,
{ "Sequence", "adb.sequence",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_zero,
{ "Zero", "adb.zero",
FT_UINT32, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_local_id,
{ "Local ID", "adb.local_id",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_remote_id,
{ "Remote ID", "adb.remote_id",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_data,
{ "Data", "adb.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_service,
{ "Service", "adb.service",
FT_STRING, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_data_fragment,
{ "Data Fragment", "adb.data_fragment",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_service_start_in_frame,
{ "Service Start in Frame", "adb.service_start_in_frame",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_close_local_in_frame,
{ "Local Service Close in Frame", "adb.close_local_in_frame",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_close_remote_in_frame,
{ "Remote Service Close in Frame", "adb.close_remote_in_frame",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_command_in_frame,
{ "Command in Frame", "adb.command_in_frame",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_completed_in_frame,
{ "Completed in Frame", "adb.completed_in_frame",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_connection_info,
{ "Info", "adb.connection_info",
FT_STRINGZ, STR_ASCII, NULL, 0x00,
NULL, HFILL }
}
};
static gint *ett[] = {
&ett_adb,
&ett_adb_arg0,
&ett_adb_arg1,
&ett_adb_crc,
&ett_adb_magic
};
static ei_register_info ei[] = {
{ &ei_invalid_magic, { "adb.expert.invalid_magic", PI_PROTOCOL, PI_WARN, "Invalid Magic", EXPFILL }},
{ &ei_invalid_crc, { "adb.expert.crc_error", PI_PROTOCOL, PI_ERROR, "CRC32 Error", EXPFILL }},
};
command_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
service_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
proto_adb = proto_register_protocol("Android Debug Bridge", "ADB", "adb");
adb_handle = new_register_dissector("adb", dissect_adb, proto_adb);
proto_register_field_array(proto_adb, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_module = expert_register_protocol(proto_adb);
expert_register_field_array(expert_module, ei, array_length(ei));
module = prefs_register_protocol(proto_adb, NULL);
prefs_register_static_text_preference(module, "version",
"ADB protocol version is compatibile pior to: adb 1.0.31",
"Version of protocol supported by this dissector.");
}
static void
wmem_test_tree(void)
{
wmem_allocator_t *allocator, *extra_allocator;
wmem_tree_t *tree;
guint32 i;
int seen_values = 0;
int j;
gchar *str_key;
#define WMEM_TREE_MAX_KEY_COUNT 8
#define WMEM_TREE_MAX_KEY_LEN 4
int key_count;
wmem_tree_key_t keys[WMEM_TREE_MAX_KEY_COUNT];
allocator = wmem_allocator_new(WMEM_ALLOCATOR_STRICT);
extra_allocator = wmem_allocator_new(WMEM_ALLOCATOR_STRICT);
tree = wmem_tree_new(allocator);
g_assert(tree);
g_assert(wmem_tree_is_empty(tree));
/* test basic 32-bit key operations */
for (i=0; i<CONTAINER_ITERS; i++) {
g_assert(wmem_tree_lookup32(tree, i) == NULL);
if (i > 0) {
g_assert(wmem_tree_lookup32_le(tree, i) == GINT_TO_POINTER(i-1));
}
wmem_tree_insert32(tree, i, GINT_TO_POINTER(i));
g_assert(wmem_tree_lookup32(tree, i) == GINT_TO_POINTER(i));
g_assert(!wmem_tree_is_empty(tree));
}
wmem_free_all(allocator);
tree = wmem_tree_new(allocator);
for (i=0; i<CONTAINER_ITERS; i++) {
guint32 rand_int = g_test_rand_int();
wmem_tree_insert32(tree, rand_int, GINT_TO_POINTER(i));
g_assert(wmem_tree_lookup32(tree, rand_int) == GINT_TO_POINTER(i));
}
wmem_free_all(allocator);
/* test auto-reset functionality */
tree = wmem_tree_new_autoreset(allocator, extra_allocator);
for (i=0; i<CONTAINER_ITERS; i++) {
g_assert(wmem_tree_lookup32(tree, i) == NULL);
wmem_tree_insert32(tree, i, GINT_TO_POINTER(i));
g_assert(wmem_tree_lookup32(tree, i) == GINT_TO_POINTER(i));
}
wmem_free_all(extra_allocator);
for (i=0; i<CONTAINER_ITERS; i++) {
g_assert(wmem_tree_lookup32(tree, i) == NULL);
g_assert(wmem_tree_lookup32_le(tree, i) == NULL);
}
wmem_free_all(allocator);
/* test array key functionality */
tree = wmem_tree_new(allocator);
key_count = g_random_int_range(1, WMEM_TREE_MAX_KEY_COUNT);
for (j=0; j<key_count; j++) {
keys[j].length = g_random_int_range(1, WMEM_TREE_MAX_KEY_LEN);
}
keys[key_count].length = 0;
for (i=0; i<CONTAINER_ITERS; i++) {
for (j=0; j<key_count; j++) {
keys[j].key = (guint32*)wmem_test_rand_string(allocator,
(keys[j].length*4), (keys[j].length*4)+1);
}
wmem_tree_insert32_array(tree, keys, GINT_TO_POINTER(i));
g_assert(wmem_tree_lookup32_array(tree, keys) == GINT_TO_POINTER(i));
}
wmem_free_all(allocator);
tree = wmem_tree_new(allocator);
keys[0].length = 1;
keys[0].key = wmem_new(allocator, guint32);
*(keys[0].key) = 0;
keys[1].length = 0;
for (i=0; i<CONTAINER_ITERS; i++) {
wmem_tree_insert32_array(tree, keys, GINT_TO_POINTER(i));
*(keys[0].key) += 4;
}
*(keys[0].key) = 0;
for (i=0; i<CONTAINER_ITERS; i++) {
g_assert(wmem_tree_lookup32_array(tree, keys) == GINT_TO_POINTER(i));
for (j=0; j<3; j++) {
(*(keys[0].key)) += 1;
g_assert(wmem_tree_lookup32_array_le(tree, keys) ==
GINT_TO_POINTER(i));
}
*(keys[0].key) += 1;
}
wmem_free_all(allocator);
/* test string key functionality */
tree = wmem_tree_new(allocator);
for (i=0; i<CONTAINER_ITERS; i++) {
str_key = wmem_test_rand_string(allocator, 1, 64);
wmem_tree_insert_string(tree, str_key, GINT_TO_POINTER(i), 0);
g_assert(wmem_tree_lookup_string(tree, str_key, 0) ==
GINT_TO_POINTER(i));
}
wmem_free_all(allocator);
tree = wmem_tree_new(allocator);
for (i=0; i<CONTAINER_ITERS; i++) {
str_key = wmem_test_rand_string(allocator, 1, 64);
wmem_tree_insert_string(tree, str_key, GINT_TO_POINTER(i),
WMEM_TREE_STRING_NOCASE);
g_assert(wmem_tree_lookup_string(tree, str_key,
WMEM_TREE_STRING_NOCASE) == GINT_TO_POINTER(i));
}
wmem_free_all(allocator);
/* test for-each functionality */
tree = wmem_tree_new(allocator);
expected_user_data = GINT_TO_POINTER(g_test_rand_int());
for (i=0; i<CONTAINER_ITERS; i++) {
gint tmp;
do {
tmp = g_test_rand_int();
} while (wmem_tree_lookup32(tree, tmp));
value_seen[i] = FALSE;
wmem_tree_insert32(tree, tmp, GINT_TO_POINTER(i));
}
cb_called_count = 0;
cb_continue_count = CONTAINER_ITERS;
wmem_tree_foreach(tree, wmem_test_foreach_cb, expected_user_data);
g_assert(cb_called_count == CONTAINER_ITERS);
g_assert(cb_continue_count == 0);
for (i=0; i<CONTAINER_ITERS; i++) {
g_assert(value_seen[i]);
value_seen[i] = FALSE;
}
cb_called_count = 0;
cb_continue_count = 10;
wmem_tree_foreach(tree, wmem_test_foreach_cb, expected_user_data);
g_assert(cb_called_count == 10);
g_assert(cb_continue_count == 0);
for (i=0; i<CONTAINER_ITERS; i++) {
if (value_seen[i]) {
seen_values++;
}
}
g_assert(seen_values == 10);
wmem_destroy_allocator(extra_allocator);
wmem_destroy_allocator(allocator);
}
void
proto_register_acr122(void)
{
module_t *module;
expert_module_t *expert_module;
static hf_register_info hf[] = {
{ &hf_class,
{ "Class", "acr122.class",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_ins,
{ "Ins", "acr122.ins",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_p1,
{ "P1", "acr122.p1",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_p2,
{ "P2", "acr122.p2",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_length,
{ "Length", "acr122.length",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_status_word,
{ "Status Word", "acr122.status_word",
FT_UINT16, BASE_HEX | BASE_RANGE_STRING, RVALS(status_word_rvals), 0x00,
NULL, HFILL }
},
{ &hf_status_word_sw1,
{ "SW1", "acr122.status_word.sw1",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_status_word_sw2,
{ "SW2", "acr122.status_word.sw2",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_command,
{ "Command", "acr122.command",
FT_UINT8, BASE_HEX, VALS(command_vals), 0x00,
NULL, HFILL }
},
{ &hf_response,
{ "Response", "acr122.response",
FT_UINT8, BASE_HEX, VALS(command_vals), 0x00,
NULL, HFILL }
},
{ &hf_response_for,
{ "Response for", "acr122.response_for",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_picc_operating_auto_picc_polling,
{ "Auto PICC Polling", "acr122.picc_operating.auto_picc_polling",
FT_BOOLEAN, 8, NULL, 0x80,
NULL, HFILL }
},
{ &hf_picc_operating_auto_ats_generation,
{ "ATS Generation", "acr122.picc_operating.ats_generation",
FT_BOOLEAN, 8, NULL, 0x40,
NULL, HFILL }
},
{ &hf_picc_operating_polling_interval,
{ "Polling Interval", "acr122.picc_operating.polling_interval",
FT_BOOLEAN, 8, NULL, 0x20,
NULL, HFILL }
},
{ &hf_picc_operating_felica_424k,
{ "FeliCa 424k", "acr122.picc_operating.felica_424k",
FT_BOOLEAN, 8, NULL, 0x10,
NULL, HFILL }
},
{ &hf_picc_operating_felica_212k,
{ "FeliCa 212k", "acr122.picc_operating.felica_212k",
FT_BOOLEAN, 8, NULL, 0x08,
NULL, HFILL }
},
{ &hf_picc_operating_topaz,
{ "Topaz", "acr122.picc_operating.topaz",
FT_BOOLEAN, 8, NULL, 0x04,
NULL, HFILL }
},
{ &hf_picc_operating_iso_14443_type_b,
{ "ISO 14443 Type B", "acr122.picc_operating.iso_14443_type_b",
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL }
},
{ &hf_picc_operating_iso_14443_type_a,
{ "ISO 14443 Type A", "acr122.picc_operating.iso_14443_type_a",
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL }
},
{ &hf_firmware_version,
{ "Firmware Version", "acr122.firmware_version",
FT_STRING, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_led_green_blinking_state,
{ "Green LED Blinking", "acr122.led.green.blinking",
FT_BOOLEAN, 8, NULL, 0x80,
NULL, HFILL }
},
{ &hf_led_red_blinking_state,
{ "Red LED Blinking", "acr122.led.red.blinking",
FT_BOOLEAN, 8, NULL, 0x40,
NULL, HFILL }
},
{ &hf_led_green_mask,
{ "Green LED Mask", "acr122.led.green.mask",
FT_BOOLEAN, 8, NULL, 0x20,
NULL, HFILL }
},
{ &hf_led_red_mask,
{ "Red LED Mask", "acr122.led.red.mask",
FT_BOOLEAN, 8, NULL, 0x10,
NULL, HFILL }
},
{ &hf_led_initial_green_blinking_state,
{ "Initial Green LED Blinking", "acr122.led.green.initial",
FT_BOOLEAN, 8, NULL, 0x08,
NULL, HFILL }
},
{ &hf_led_initial_red_blinking_state,
{ "Initial Red LED Blinking", "acr122.led.red.initial",
FT_BOOLEAN, 8, NULL, 0x04,
NULL, HFILL }
},
{ &hf_led_final_green_state,
{ "Final Green LED", "acr122.led.green.final",
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL }
},
{ &hf_led_final_red_state,
{ "Final Red LED", "acr122.led.red.final",
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL }
},
{ &hf_led_t1_duration,
{ "T1 Duration", "acr122.led.t1_duration",
FT_UINT8, BASE_CUSTOM, duration_base, 0x00,
"Initial Blinking State", HFILL }
},
{ &hf_led_t2_duration,
{ "T2 Duration", "acr122.led.t2_duration",
FT_UINT8, BASE_CUSTOM, duration_base, 0x00,
"Toggle Blinking State", HFILL }
},
{ &hf_led_number_of_repetition,
{ "Number of Repetition", "acr122.led.number_of_repetition",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_led_link_to_buzzer,
{ "Link to Buzzer", "acr122.led.link_to_buzzer",
FT_UINT8, BASE_HEX, VALS(link_to_buzzer_vals), 0x00,
NULL, HFILL }
},
{ &hf_poll_buzzer_status,
{ "Poll Buzzer Status", "acr122.poll_buzzer_status",
FT_UINT8, BASE_HEX, VALS(poll_buzzer_status_vals), 0x00,
NULL, HFILL }
},
{ &hf_timeout,
{ "Timeout", "acr122.timeout",
FT_UINT8, BASE_CUSTOM, timeout_base, 0x00,
NULL, HFILL }
},
{ &hf_status_word_led_reserved,
{ "Reserved", "acr122.status_word.sw2.reserved",
FT_UINT8, BASE_HEX, NULL, 0xFC,
NULL, HFILL }
},
{ &hf_status_word_led_green,
{ "Current Green LED", "acr122.status_word.sw2.led.green",
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL }
},
{ &hf_status_word_led_red,
{ "Current Red LED", "acr122.status_word.sw2.led.red",
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL }
},
{ &hf_key,
{ "Key", "acr122.key",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_key_structure,
{ "Key Structure", "acr122.key_structure",
FT_UINT8, BASE_HEX, VALS(key_structure_vals), 0x00,
NULL, HFILL }
},
{ &hf_key_number,
{ "Key Number", "acr122.key_number",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_key_type,
{ "Key Type", "acr122.key_type",
FT_UINT8, BASE_HEX, VALS(key_type_vals), 0x00,
NULL, HFILL }
},
{ &hf_block_number,
{ "Block Number", "acr122.block_number",
FT_UINT8, BASE_DEC_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_source_block_number,
{ "Source Block Number", "acr122.source_block_number",
FT_UINT8, BASE_DEC_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_target_block_number,
{ "Target Block Number", "acr122.target_block_number",
FT_UINT8, BASE_DEC_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_static_byte,
{ "Static Byte", "acr122.static_byte",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_vb_op,
{ "VB Op", "acr122.vb_op",
FT_UINT8, BASE_HEX, VALS(vb_op_vals), 0x00,
NULL, HFILL }
},
{ &hf_version,
{ "Version", "acr122.version",
FT_UINT16, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_value,
{ "Value", "acr122.value",
FT_INT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_uid,
{ "UID", "acr122.uid",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_ats,
{ "ATS", "acr122.ats",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_data,
{ "Data", "acr122.data",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_acr122,
&ett_p1_item,
&ett_p2_item,
&ett_status_word,
&ett_status_word_sw2
};
static ei_register_info ei[] = {
{ &ei_unknown_command_or_invalid_parameters, { "acr122.expert.unknown_command", PI_PROTOCOL, PI_NOTE, "Unknown command or invalid parameters", EXPFILL }},
};
command_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
proto_acr122 = proto_register_protocol("Advanced Card Systems ACR122", "ACR 122", "acr122");
new_register_dissector("acr122", dissect_acr122, proto_acr122);
proto_register_field_array(proto_acr122, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_module = expert_register_protocol(proto_acr122);
expert_register_field_array(expert_module, ei, array_length(ei));
module = prefs_register_protocol(proto_acr122, NULL);
prefs_register_static_text_preference(module, "version",
"ACR122U USB NFC Reader - Application Programming Interface V2.02",
"Version of protocol supported by this dissector.");
}
void
proto_register_adb_service(void)
{
module_t *module;
expert_module_t *expert_module;
static hf_register_info hf[] = {
{ &hf_service,
{ "Service", "adb_service.service",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_fragment,
{ "Fragment", "adb_service.fragment",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_data,
{ "Data", "adb_service.data",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_hex_ascii_length,
{ "Hex ASCII String Length", "adb_service.hex_ascii_length",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_length,
{ "Length", "adb_service.length",
FT_UINT32, BASE_DEC_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_version,
{ "Version", "adb_service.framebuffer.version",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_hex_ascii_version,
{ "Hex ASCII String Version", "adb_service.hex_ascii_version",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_version,
{ "Version", "adb_service.version",
FT_UINT32, BASE_DEC_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_depth,
{ "Depth", "adb_service.framebuffer.depth",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_size,
{ "Size", "adb_service.framebuffer.size",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_width,
{ "Width", "adb_service.framebuffer.width",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_height,
{ "Height", "adb_service.framebuffer.height",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_red_offset,
{ "Red Offset", "adb_service.framebuffer.red_offset",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_red_length,
{ "Red Length", "adb_service.framebuffer.red_length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_blue_offset,
{ "Blue Offset", "adb_service.framebuffer.blue_offset",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_blue_length,
{ "Blue Length", "adb_service.framebuffer.blue_length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_green_offset,
{ "Green Offset", "adb_service.framebuffer.green_offset",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_green_length,
{ "Green Length", "adb_service.framebuffer.green_length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_alpha_offset,
{ "Alpha Offset", "adb_service.framebuffer.alpha_offset",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_alpha_length,
{ "Alpha Length", "adb_service.framebuffer.alpha_length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_pixel,
{ "Pixel", "adb_service.framebuffer.pixel",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_blue_5,
{ "Blue", "adb_service.framebuffer.pixel.blue",
FT_UINT16, BASE_DEC, NULL, 0xF800,
NULL, HFILL }
},
{ &hf_framebuffer_green_6,
{ "Green", "adb_service.framebuffer.pixel.green",
FT_UINT16, BASE_DEC, NULL, 0x07E0,
NULL, HFILL }
},
{ &hf_framebuffer_red_5,
{ "Red", "adb_service.framebuffer.pixel.red",
FT_UINT16, BASE_DEC, NULL, 0x001F,
NULL, HFILL }
},
{ &hf_framebuffer_blue,
{ "Blue", "adb_service.framebuffer.pixel.blue",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_green,
{ "Green", "adb_service.framebuffer.pixel.green",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_red,
{ "Red", "adb_service.framebuffer.pixel.red",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_alpha,
{ "Alpha", "adb_service.framebuffer.pixel.alpha",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_framebuffer_unused,
{ "Unused", "adb_service.framebuffer.pixel.unused",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_devices,
{ "Devices", "adb_service.devices",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_stdin,
{ "Stdin", "adb_service.stdin",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_stdout,
{ "Stdout", "adb_service.stdout",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_result,
{ "Result", "adb_service.result",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_pids,
{ "PIDs", "adb_service.pids",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sync_id,
{ "Id", "adb_service.sync.id",
FT_STRING, STR_ASCII, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sync_length,
{ "Length", "adb_service.sync.length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sync_mode,
{ "Mode", "adb_service.sync.mode",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sync_size,
{ "Size", "adb_service.sync.size",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sync_time,
{ "Last Modification Time", "adb_service.sync.time",
FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sync_unused,
{ "Unused", "adb_service.sync.unused",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sync_data,
{ "Sync Data", "adb_service.sync.data",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_adb_service,
&ett_length,
&ett_version,
&ett_pixel,
&ett_data
};
static ei_register_info ei[] = {
{ &ei_incomplete_message, { "adb_service.expert.incomplete_message", PI_PROTOCOL, PI_WARN, "Incomplete message", EXPFILL }},
};
fragments = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
framebuffer_infos = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
continuation_infos = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
proto_adb_service = proto_register_protocol("Android Debug Bridge Service", "ADB Service", "adb_service");
adb_service_handle = register_dissector("adb_service", dissect_adb_service, proto_adb_service);
proto_register_field_array(proto_adb_service, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_module = expert_register_protocol(proto_adb_service);
expert_register_field_array(expert_module, ei, array_length(ei));
module = prefs_register_protocol(proto_adb_service, NULL);
prefs_register_static_text_preference(module, "version",
"ADB Service protocol version is compatible prior to: adb 1.0.31",
"Version of protocol supported by this dissector.");
prefs_register_bool_preference(module, "framebuffer_more_details",
"Dissect more detail for framebuffer service",
"Dissect more detail for framebuffer service",
&pref_dissect_more_detail_framebuffer);
}
void lbm_topic_init(void)
{
lbm_topic_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
}
void
proto_register_hci_usb(void)
{
module_t *module;
static hf_register_info hf[] = {
{ &hf_msg_fragments,
{ "Message fragments", "hci_usb.msg.fragments",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment,
{ "Message fragment", "hci_usb.msg.fragment",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_overlap,
{ "Message fragment overlap", "hci_usb.msg.fragment.overlap",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_overlap_conflicts,
{ "Message fragment overlapping with conflicting data", "hci_usb.msg.fragment.overlap.conflicts",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_multiple_tails,
{ "Message has multiple tail fragments", "hci_usb.msg.fragment.multiple_tails",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_too_long_fragment,
{ "Message fragment too long", "hci_usb.msg.fragment.too_long_fragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_error,
{ "Message defragmentation error", "hci_usb.msg.fragment.error",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_fragment_count,
{ "Message fragment count", "hci_usb.msg.fragment.count",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_reassembled_in,
{ "Reassembled in", "hci_usb.msg.reassembled.in",
FT_FRAMENUM, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_msg_reassembled_length,
{ "Reassembled MP2T length", "hci_usb.msg.reassembled.length",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_fragment,
{ "Packet Fragment", "hci_usb.packet.fragment",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_complete,
{ "Packet Complete", "hci_usb.packet.complete",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_packet_unknown_fragment,
{ "Unknown Packet Fragment", "hci_usb.packet.unknown_fragment",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthci_usb_setup_request,
{ "bRequest", "hci_usb.setup.bRequest",
FT_UINT8, BASE_DEC | BASE_EXT_STRING, &request_vals_ext, 0x0,
NULL, HFILL }},
{ &hf_bthci_usb_setup_value,
{ "wValue", "hci_usb.setup.wValue",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_bthci_usb_setup_adapter_id,
{ "Adapter ID", "hci_usb.setup.adapter_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_bthci_usb_setup_length,
{ "wLength", "hci_usb.setup.wLength",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_bthci_usb_data,
{ "Unknown Data", "hci_usb.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
}
};
static gint *ett[] = {
&ett_hci_usb,
&ett_hci_usb_msg_fragment,
&ett_hci_usb_msg_fragments,
};
reassembly_table_register(&hci_usb_reassembly_table,
&addresses_reassembly_table_functions);
fragment_info_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
proto_hci_usb = proto_register_protocol("Bluetooth HCI USB Transport", "HCI_USB", "hci_usb");
proto_register_field_array(proto_hci_usb, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
hci_usb_handle = register_dissector("hci_usb", dissect_hci_usb, proto_hci_usb);
module = prefs_register_protocol_subtree("Bluetooth", proto_hci_usb, NULL);
prefs_register_static_text_preference(module, "bthci_usb.version",
"Bluetooth HCI USB Transport from Core 4.0",
"Version of protocol supported by this dissector.");
}
void
proto_register_usb_dfu(void)
{
module_t *module;
expert_module_t *expert_module;
static hf_register_info hf[] = {
{ &hf_setup_command,
{ "Command", "usbdfu.command",
FT_UINT8, BASE_DEC | BASE_EXT_STRING, &command_vals_ext, 0x0,
NULL, HFILL }
},
{ &hf_response,
{ "Response", "usbdfu.response",
FT_UINT8, BASE_DEC | BASE_EXT_STRING, &command_vals_ext, 0x0,
NULL, HFILL }
},
{ &hf_command_in_frame,
{ "Command Frame", "usbdfu.command_frame",
FT_FRAMENUM, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
{ &hf_setup_unused,
{ "Unused", "usbdfu.unused",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_setup_interface,
{ "Interface", "usbdfu.interface",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_setup_length,
{ "Length", "usbdfu.length",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_setup_block_number,
{ "Block Number", "usbdfu.block_number",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_setup_timeout,
{ "Timeout", "usbdfu.timeout",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_state,
{ "State", "usbdfu.state",
FT_UINT8, BASE_DEC | BASE_EXT_STRING, &state_vals_ext, 0x0,
NULL, HFILL }
},
{ &hf_status,
{ "Status", "usbdfu.status",
FT_UINT8, BASE_HEX | BASE_EXT_STRING, &status_vals_ext, 0x0,
NULL, HFILL }
},
{ &hf_iString,
{ "iString", "usbdfu.iString",
FT_INT8, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_poll_timeout,
{ "Poll Timeout", "usbdfu.poll_timeout",
FT_UINT24, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_data,
{ "Data", "usbdfu.data",
FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor,
{ "DFU Descriptor", "usbdfu.descriptor",
FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor_bmAttributes_reserved,
{ "Reserved", "usbdfu.descriptor.bmAttributes.reserved",
FT_UINT8, BASE_HEX, NULL, 0xF0,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor_bmAttributes_WillDetach,
{ "Will Detach", "usbdfu.descriptor.bmAttributes.WillDetach",
FT_BOOLEAN, 8, NULL, 0x08,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor_bmAttributes_ManifestationTolerant,
{ "Manifestation Tolerant", "usbdfu.descriptor.bmAttributes.ManifestationTolerant",
FT_BOOLEAN, 8, NULL, 0x04,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor_bmAttributes_CanUpload,
{ "Can Upload", "usbdfu.descriptor.bmAttributes.CanUpload",
FT_BOOLEAN, 8, NULL, 0x02,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor_bmAttributes_CanDownload,
{ "Can Download", "usbdfu.descriptor.bmAttributes.CanDownload",
FT_BOOLEAN, 8, NULL, 0x01,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor_wDetachTimeOut,
{ "wDetachTimeOut", "usbdfu.descriptor.wDetachTimeOut",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor_wTransferSize,
{ "wTransferSize", "usbdfu.descriptor.wTransferSize",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }
},
{ &hf_usb_dfu_descriptor_bcdDFUVersion,
{ "bcdDFUVersion", "usbdfu.descriptor.bcdDFUVersion",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }
}
};
static ei_register_info ei[] = {
{ &ei_unexpected_response, { "usb_dfu.unexpected_response", PI_PROTOCOL, PI_ERROR, "Unexpected response for this command", EXPFILL }},
{ &ei_unknown_data, { "usb_dfu.unknown_data", PI_PROTOCOL, PI_NOTE, "Unknown data", EXPFILL }},
{ &ei_unexpected_data, { "usb_dfu.unexpected_data", PI_PROTOCOL, PI_WARN, "Unexpected data", EXPFILL }},
{ &ei_invalid_command_for_request_type, { "usb_dfu.invalid_command_for_request_type", PI_PROTOCOL, PI_WARN, "Invalid command for this Request Type", EXPFILL }},
{ &ei_descriptor_invalid_length, { "usb_dfu.descriptor.invalid_length", PI_PROTOCOL, PI_WARN, "Invalid Length", EXPFILL }},
};
static gint *ett[] = {
&ett_usb_dfu,
&ett_usb_dfu_descriptor,
&ett_command
};
command_info = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
proto_usb_dfu = proto_register_protocol("USB Device Firmware Upgrade ", "USB DFU", "usbdfu");
proto_register_field_array(proto_usb_dfu, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
usb_dfu_handle = new_register_dissector("usb_dfu", dissect_usb_dfu, proto_usb_dfu);
expert_module = expert_register_protocol(proto_usb_dfu);
expert_register_field_array(expert_module, ei, array_length(ei));
module = prefs_register_protocol(proto_usb_dfu, NULL);
prefs_register_static_text_preference(module, "version",
"USB DFU Specification 1.1",
"Version of protocol supported by this dissector.");
}
