void register_follow_stream(const int proto_id, const char* tap_listener,
follow_conv_filter_func conv_filter, follow_index_filter_func index_filter, follow_address_filter_func address_filter,
follow_port_to_display_func port_to_display, tap_packet_cb tap_handler)
{
register_follow_t *follower;
DISSECTOR_ASSERT(tap_listener);
DISSECTOR_ASSERT(conv_filter);
DISSECTOR_ASSERT(index_filter);
DISSECTOR_ASSERT(address_filter);
DISSECTOR_ASSERT(port_to_display);
DISSECTOR_ASSERT(tap_handler);
follower = wmem_new(wmem_epan_scope(), register_follow_t);
follower->proto_id = proto_id;
follower->tap_listen_str = tap_listener;
follower->conv_filter = conv_filter;
follower->index_filter = index_filter;
follower->address_filter = address_filter;
follower->port_to_display = port_to_display;
follower->tap_handler = tap_handler;
if (registered_followers == NULL)
registered_followers = wmem_tree_new(wmem_epan_scope());
wmem_tree_insert_string(registered_followers, proto_get_protocol_short_name(find_protocol_by_id(proto_id)), follower, 0);
}
static oid_info_t* add_oid(const char* name, oid_kind_t kind, const oid_value_type_t* type, oid_key_t* key, guint oid_len, guint32 *subids) {
guint i = 0;
oid_info_t* c = &oid_root;
prepopulate_oids();
oid_len--;
do {
oid_info_t* n = (oid_info_t *)wmem_tree_lookup32(c->children,subids[i]);
if(n) {
if (i == oid_len) {
if (n->name) {
if (!g_str_equal(n->name,name)) {
D(2,("Renaming Oid from: %s -> %s, this means the same oid is registered more than once",n->name,name));
}
wmem_free(wmem_epan_scope(), n->name);
}
n->name = wmem_strdup(wmem_epan_scope(), name);
if (! n->value_type) {
n->value_type = type;
}
return n;
}
} else {
n = wmem_new(wmem_epan_scope(), oid_info_t);
n->subid = subids[i];
n->kind = kind;
n->children = wmem_tree_new(wmem_epan_scope());
n->value_hfid = -2;
n->key = key;
n->parent = c;
n->bits = NULL;
wmem_tree_insert32(c->children,n->subid,n);
if (i == oid_len) {
n->name = wmem_strdup(wmem_epan_scope(), name);
n->value_type = type;
n->kind = kind;
return n;
} else {
n->name = NULL;
n->value_type = NULL;
n->kind = OID_KIND_UNKNOWN;
}
}
c = n;
} while(++i);
g_assert_not_reached();
return NULL;
}
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 register_stat_tap_table_ui(stat_tap_table_ui *ui)
{
if (registered_stat_tables == NULL)
registered_stat_tables = wmem_tree_new(wmem_epan_scope());
wmem_tree_insert_string(registered_stat_tables, ui->cli_string, ui, 0);
}
static void hpfeeds_stats_tree_init(stats_tree* st)
{
st_node_channels_payload = stats_tree_create_node(st, st_str_channels_payload, 0, TRUE);
st_node_opcodes = stats_tree_create_pivot(st, st_str_opcodes, 0);
channels_list = wmem_list_new(wmem_epan_scope());
}
int
register_export_object(const int proto_id, tap_packet_cb export_packet_func, export_object_gui_reset_cb reset_cb)
{
register_eo_t *table;
DISSECTOR_ASSERT(export_packet_func);
table = wmem_new(wmem_epan_scope(), register_eo_t);
table->proto_id = proto_id;
table->tap_listen_str = wmem_strdup_printf(wmem_epan_scope(), "%s_eo", proto_get_protocol_filter_name(proto_id));
table->eo_func = export_packet_func;
table->reset_cb = reset_cb;
if (registered_eo_tables == NULL)
registered_eo_tables = wmem_tree_new(wmem_epan_scope());
wmem_tree_insert_string(registered_eo_tables, proto_get_protocol_filter_name(proto_id), table, 0);
return register_tap(table->tap_listen_str);
}
void
register_stat_tap_ui(stat_tap_ui *ui, void *userdata)
{
stat_cmd_arg *newsca;
if (stat_cmd_arg_list == NULL)
stat_cmd_arg_list = wmem_list_new(wmem_epan_scope());
/* Key is already present */
if (wmem_list_find_custom(stat_cmd_arg_list, ui->cli_string, search_duplicate))
return;
newsca = wmem_new(wmem_epan_scope(), stat_cmd_arg);
newsca->cmd= wmem_strdup(wmem_epan_scope(), ui->cli_string);
newsca->func=ui->tap_init_cb;
newsca->userdata=userdata;
wmem_list_insert_sorted(stat_cmd_arg_list, newsca, sort_by_name);
}
/*
* Add an entry for a new OUI.
*/
void
llc_add_oui(guint32 oui, const char *table_name, const char *table_ui_name,
hf_register_info *hf_item, const int proto)
{
oui_info_t *new_info;
new_info = wmem_new(wmem_epan_scope(), oui_info_t);
new_info->table = register_dissector_table(table_name,
table_ui_name, proto, FT_UINT16, BASE_HEX);
new_info->field_info = hf_item;
/*
* Create the hash table for OUI information, if it doesn't
* already exist.
*/
if (oui_info_table == NULL) {
oui_info_table = wmem_map_new(wmem_epan_scope(), g_direct_hash,
g_direct_equal);
}
wmem_map_insert(oui_info_table, GUINT_TO_POINTER(oui), new_info);
}
expert_module_t *expert_register_protocol(int id)
{
expert_module_t *module;
protocol_t *protocol;
protocol = find_protocol_by_id(id);
module = wmem_new(wmem_epan_scope(), expert_module_t);
module->proto_id = id;
module->proto_name = proto_get_protocol_short_name(protocol);
return module;
}
void
register_seq_analysis(const char* name, const char* ui_name, const int proto_id, const char* tap_listener, guint tap_flags, tap_packet_cb tap_func)
{
register_analysis_t* analysis;
DISSECTOR_ASSERT(tap_func);
analysis = wmem_new0(wmem_epan_scope(), register_analysis_t);
analysis->name = name;
analysis->ui_name = ui_name;
analysis->proto_id = proto_id;
if (tap_listener != NULL)
analysis->tap_listen_str = tap_listener;
else
analysis->tap_listen_str = proto_get_protocol_filter_name(proto_id);
analysis->tap_flags = tap_flags;
analysis->analysis_func = tap_func;
if (registered_seq_analysis == NULL)
registered_seq_analysis = wmem_tree_new(wmem_epan_scope());
wmem_tree_insert_string(registered_seq_analysis, name, analysis, 0);
}
static void
gbl_symbols_free(void)
{
wmem_free(wmem_epan_scope(), gbl_symbols_vs_ext);
gbl_symbols_vs_ext = NULL;
if (gbl_symbols_array != NULL) {
value_string *vs_p;
guint i;
vs_p = (value_string *)(void *)gbl_symbols_array->data;
for (i=0; i<gbl_symbols_array->len; i++) {
g_free((gchar *)vs_p[i].strptr);
}
g_array_free(gbl_symbols_array, TRUE);
gbl_symbols_array = NULL;
}
}
static void prepopulate_oids(void) {
if (!oid_root.children) {
char* debug_env = getenv("WIRESHARK_DEBUG_MIBS");
guint32 subid;
debuglevel = debug_env ? (int)strtoul(debug_env,NULL,10) : 0;
oid_root.children = wmem_tree_new(wmem_epan_scope());
/*
* make sure we got strings at least in the three root-children oids
* that way oid_resolved() will always have a string to print
*/
subid = 0; oid_add("itu-t",1,&subid);
subid = 1; oid_add("iso",1,&subid);
subid = 2; oid_add("joint-iso-itu-t",1,&subid);
}
}
/* Create a value_string_ext given a ptr to a value_string array and the total
* number of entries. Note that the total number of entries should include the
* required {0, NULL} terminating entry of the array.
* Returns a pointer to an epan-scoped'd and initialized value_string_ext
* struct. */
value_string_ext *
value_string_ext_new(const value_string *vs, guint vs_tot_num_entries,
const gchar *vs_name)
{
value_string_ext *vse;
DISSECTOR_ASSERT (vs_name != NULL);
DISSECTOR_ASSERT (vs_tot_num_entries > 0);
/* Null-terminated value-string ? */
DISSECTOR_ASSERT (vs[vs_tot_num_entries-1].strptr == NULL);
vse = wmem_new(wmem_epan_scope(), value_string_ext);
vse->_vs_p = vs;
vse->_vs_num_entries = vs_tot_num_entries - 1;
/* We set our 'match' function to the init function, which finishes by
* setting the match function properly and then calling it. This is a
* simple way to do lazy initialization of extended value strings.
* The init function also sets up _vs_first_value for us. */
vse->_vs_first_value = 0;
vse->_vs_match2 = _try_val_to_str_ext_init;
vse->_vs_name = vs_name;
return vse;
}
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_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
dissect_fw1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
/* Set up structures needed to add the protocol subtree and manage it */
proto_item *ti;
proto_tree *volatile fh_tree = NULL;
char direction;
char chain;
char *interface_name;
guint32 iface_len = 10;
wmem_strbuf_t *header;
int i;
gboolean found;
static const char fw1_header[] = "FW1 Monitor";
ethertype_data_t ethertype_data;
header = wmem_strbuf_new_label(wmem_epan_scope());
wmem_strbuf_append(header, fw1_header);
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FW1");
col_clear(pinfo->cinfo, COL_INFO);
/* g_snprintf(header, sizeof(header), fw1_header); */
/* fetch info to local variable */
direction = tvb_get_guint8(tvb, 0);
if (!fw1_iflist_with_chain)
chain = ' ';
else
chain = tvb_get_guint8(tvb, 1);
if (fw1_with_uuid)
iface_len = 6;
interface_name=(char *)wmem_alloc(wmem_packet_scope(), iface_len+1);
tvb_get_nstringz0(tvb, 2, iface_len+1, interface_name);
/* Known interface name - if not, remember it */
found=FALSE;
for (i=0; i<interface_anzahl; i++) {
if ( strcmp(p_interfaces[i], interface_name) == 0 ) {
found=TRUE;
break;
}
}
if (!found && interface_anzahl < MAX_INTERFACES) {
p_interfaces[interface_anzahl] = wmem_strdup(wmem_file_scope(), interface_name);
interface_anzahl++;
}
/* display all interfaces always in the same order */
for (i=0; i<interface_anzahl; i++) {
if ( strcmp(p_interfaces[i], interface_name) == 0 ) {
wmem_strbuf_append_printf(header, " %c%c %s %c%c",
direction == 'i' ? 'i' : (direction == 'O' ? 'O' : ' '),
(direction == 'i' || direction == 'O') ? chain : ' ',
p_interfaces[i],
direction == 'I' ? 'I' : (direction == 'o' ? 'o' : ' '),
(direction == 'I' || direction == 'o') ? chain : ' '
);
} else {
wmem_strbuf_append_printf(header, " %s ", p_interfaces[i]);
}
}
col_add_str(pinfo->cinfo, COL_IF_DIR, wmem_strbuf_get_str(header) + sizeof(fw1_header) + 1);
if (tree) {
if (!fw1_summary_in_tree)
/* Do not show the summary in Protocol Tree */
ti = proto_tree_add_protocol_format(tree, proto_fw1, tvb, 0, ETH_HEADER_SIZE, "%s", fw1_header);
else
ti = proto_tree_add_protocol_format(tree, proto_fw1, tvb, 0, ETH_HEADER_SIZE, "%s", wmem_strbuf_get_str(header));
/* create display subtree for the protocol */
fh_tree = proto_item_add_subtree(ti, ett_fw1);
proto_tree_add_item(fh_tree, hf_fw1_direction, tvb, 0, 1, ENC_ASCII|ENC_NA);
if (fw1_iflist_with_chain)
proto_tree_add_item(fh_tree, hf_fw1_chain, tvb, 1, 1, ENC_ASCII|ENC_NA);
proto_tree_add_item(fh_tree, hf_fw1_interface, tvb, 2, iface_len, ENC_ASCII|ENC_NA);
if (fw1_with_uuid)
proto_tree_add_item(fh_tree, hf_fw1_uuid, tvb, 8, 4, ENC_BIG_ENDIAN);
}
ethertype_data.etype = tvb_get_ntohs(tvb, 12);
ethertype_data.offset_after_ethertype = ETH_HEADER_SIZE;
ethertype_data.fh_tree = fh_tree;
ethertype_data.etype_id = hf_fw1_type;
ethertype_data.trailer_id = hf_fw1_trailer;
ethertype_data.fcs_len = 0;
call_dissector_with_data(ethertype_handle, tvb, pinfo, tree, ðertype_data);
}
void
guids_init(void)
{
guid_to_name_tree=wmem_tree_new(wmem_epan_scope());
/* XXX here is a good place to read a config file with wellknown guids */
}
void lbm_topic_init(void)
{
lbm_topic_table = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
}
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
expert_deregister_protocol (expert_module_t *module)
{
wmem_free(wmem_epan_scope(), module);
}
dissect_fw1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
/* Set up structures needed to add the protocol subtree and manage it */
proto_item *ti;
proto_tree *fh_tree = NULL;
char direction;
char chain;
char *interface_name;
guint32 iface_len = 10;
wmem_strbuf_t *header;
int i;
gboolean found;
static const char fw1_header[] = "FW1 Monitor";
ethertype_data_t ethertype_data;
header = wmem_strbuf_new_label(wmem_epan_scope());
wmem_strbuf_append(header, fw1_header);
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FW1");
col_clear(pinfo->cinfo, COL_INFO);
/* g_snprintf(header, sizeof(header), fw1_header); */
/* fetch info to local variable */
direction = tvb_get_guint8(tvb, 0);
if (!fw1_iflist_with_chain)
chain = ' ';
else
void
value_string_ext_free(const value_string_ext *vse)
{
wmem_free(wmem_epan_scope(), (void *)vse);
}
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
value_string_ext_free(value_string_ext *vse)
{
wmem_free(wmem_epan_scope(), vse);
}
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.");
}