/*--- proto_register_dap -------------------------------------------*/
void proto_register_dap(void) {
/* List of fields */
static hf_register_info hf[] =
{
#include "packet-dap-hfarr.c"
};
/* List of subtrees */
static gint *ett[] = {
&ett_dap,
#include "packet-dap-ettarr.c"
};
static ei_register_info ei[] = {
{ &ei_dap_anonymous, { "dap.anonymous", PI_PROTOCOL, PI_NOTE, "Anonymous", EXPFILL }},
};
module_t *dap_module;
expert_module_t* expert_dap;
/* Register protocol */
proto_dap = proto_register_protocol(PNAME, PSNAME, PFNAME);
/* Register fields and subtrees */
proto_register_field_array(proto_dap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_dap = expert_register_protocol(proto_dap);
expert_register_field_array(expert_dap, ei, array_length(ei));
/* Register our configuration options for DAP, particularly our port */
dap_module = prefs_register_protocol_subtree("OSI/X.500", proto_dap, NULL);
prefs_register_obsolete_preference(dap_module, "tcp.port");
prefs_register_static_text_preference(dap_module, "tcp_port_info",
"The TCP ports used by the DAP protocol should be added to the TPKT preference \"TPKT TCP ports\", or the IDMP preference \"IDMP TCP Port\", or by selecting \"TPKT\" as the \"Transport\" protocol in the \"Decode As\" dialog.",
"DAP TCP Port preference moved information");
}
void
proto_register_eth(void)
{
static hf_register_info hf[] = {
{ &hf_eth_dst,
{ "Destination", "eth.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Hardware Address", HFILL }},
{ &hf_eth_src,
{ "Source", "eth.src", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source Hardware Address", HFILL }},
{ &hf_eth_len,
{ "Length", "eth.len", FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
/* registered here but handled in packet-ethertype.c */
{ &hf_eth_type,
{ "Type", "eth.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
NULL, HFILL }},
{ &hf_eth_invalid_lentype,
{ "Invalid length/type", "eth.invalid_lentype", FT_UINT16, BASE_HEX_DEC,
NULL, 0x0, NULL, HFILL }},
{ &hf_eth_addr,
{ "Address", "eth.addr", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source or Destination Hardware Address", HFILL }},
{ &hf_eth_padding,
{ "Padding", "eth.padding", FT_BYTES, BASE_NONE, NULL, 0x0,
"Ethernet Padding", HFILL }},
{ &hf_eth_trailer,
{ "Trailer", "eth.trailer", FT_BYTES, BASE_NONE, NULL, 0x0,
"Ethernet Trailer or Checksum", HFILL }},
{ &hf_eth_fcs,
{ "Frame check sequence", "eth.fcs", FT_UINT32, BASE_HEX, NULL, 0x0,
"Ethernet checksum", HFILL }},
{ &hf_eth_fcs_good,
{ "FCS Good", "eth.fcs_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum matches packet content; False: doesn't match content or not checked", HFILL }},
{ &hf_eth_fcs_bad,
{ "FCS Bad", "eth.fcs_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True: checksum doesn't matche packet content; False: does match content or not checked", HFILL }},
{ &hf_eth_lg,
{ "LG bit", "eth.lg", FT_BOOLEAN, 24,
TFS(&lg_tfs), 0x020000,
"Specifies if this is a locally administered or globally unique (IEEE assigned) address", HFILL }},
{ &hf_eth_ig,
{ "IG bit", "eth.ig", FT_BOOLEAN, 24,
TFS(&ig_tfs), 0x010000,
"Specifies if this is an individual (unicast) or group (broadcast/multicast) address", HFILL }}
};
static gint *ett[] = {
&ett_ieee8023,
&ett_ether2,
&ett_ether,
&ett_addr,
&ett_eth_fcs
};
module_t *eth_module;
proto_eth = proto_register_protocol("Ethernet", "Ethernet", "eth");
proto_register_field_array(proto_eth, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
/* subdissector code */
register_heur_dissector_list("eth", &heur_subdissector_list);
register_heur_dissector_list("eth.trailer", ð_trailer_subdissector_list);
/* Register configuration preferences */
eth_module = prefs_register_protocol(proto_eth, NULL);
prefs_register_bool_preference(eth_module, "assume_padding",
"Assume short frames which include a trailer contain padding",
"Some devices add trailing data to frames. When this setting is checked "
"the Ethernet dissector will assume there has been added padding to the "
"frame before the trailer was added. Uncheck if a device added a trailer "
"before the frame was padded.",
ð_assume_padding);
prefs_register_bool_preference(eth_module, "assume_fcs",
"Assume packets have FCS",
"Some Ethernet adapters and drivers include the FCS at the end of a packet, others do not. "
"The Ethernet dissector attempts to guess whether a captured packet has an FCS, "
"but it cannot always guess correctly.",
ð_assume_fcs);
prefs_register_bool_preference(eth_module, "check_fcs",
"Validate the Ethernet checksum if possible",
"Whether to validate the Frame Check Sequence",
ð_check_fcs);
prefs_register_bool_preference(eth_module, "interpret_as_fw1_monitor",
"Attempt to interpret as FireWall-1 monitor file",
"Whether packets should be interpreted as coming from CheckPoint FireWall-1 monitor file if they look as if they do",
ð_interpret_as_fw1_monitor);
prefs_register_static_text_preference(eth_module, "ccsds_heuristic",
"These are the conditions to match a payload against in order to determine if this\n"
"is a CCSDS (Consultative Committee for Space Data Systems) packet within\n"
"an 802.3 packet. A packet is considered as a possible CCSDS packet only if\n"
"one or more of the conditions are checked.",
"Describe the conditions that must be true for the CCSDS dissector to be called");
prefs_register_bool_preference(eth_module, "ccsds_heuristic_length",
"CCSDS Length in header matches payload size",
"Set the condition that must be true for the CCSDS dissector to be called",
&ccsds_heuristic_length);
prefs_register_bool_preference(eth_module, "ccsds_heuristic_version",
"CCSDS Version # is zero",
"Set the condition that must be true for the CCSDS dissector to be called",
&ccsds_heuristic_version);
prefs_register_bool_preference(eth_module, "ccsds_heuristic_header",
"CCSDS Secondary Header Flag is set",
"Set the condition that must be true for the CCSDS dissector to be called",
&ccsds_heuristic_header);
prefs_register_bool_preference(eth_module, "ccsds_heuristic_bit",
"CCSDS Spare bit is cleared",
"Set the condition that must be true for the CCSDS dissector to be called",
&ccsds_heuristic_bit);
register_dissector("eth_withoutfcs", dissect_eth_withoutfcs, proto_eth);
register_dissector("eth_withfcs", dissect_eth_withfcs, proto_eth);
register_dissector("eth", dissect_eth_maybefcs, proto_eth);
eth_tap = register_tap("eth");
}
void
proto_register_bthcrp(void)
{
module_t *module;
static hf_register_info hf[] = {
{ &hf_bthcrp_control_pdu_id,
{ "Control PDU ID", "bthcrp.control.pdu_id",
FT_UINT16, BASE_HEX, VALS(control_pdu_id_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_transaction_id,
{ "Transaction ID", "bthcrp.control.transaction_id",
FT_UINT16, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_parameter_length,
{ "Parameter Length", "bthcrp.control.parameter_length",
FT_UINT16, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_status,
{ "Status", "bthcrp.control.status",
FT_UINT16, BASE_HEX, VALS(status_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_notification_pdu_id,
{ "Notification PDU ID", "bthcrp.notification.pdu_id",
FT_UINT16, BASE_HEX, VALS(notification_pdu_id_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_callback_context_id,
{ "Callback Context ID", "bthcrp.callback.context_id",
FT_UINT32, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_callback_timeout,
{ "Callback Timeout", "bthcrp.callback.timeout",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_timeout,
{ "Timeout", "bthcrp.timeout",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_register,
{ "Register", "bthcrp.register",
FT_UINT8, BASE_HEX, VALS(register_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_1284_id,
{ "1284 ID", "bthcrp.1284_id",
FT_STRING, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_start_byte,
{ "Start Byte", "bthcrp.start_byte",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_number_of_bytes,
{ "Number Of Bytes", "bthcrp.number_of_bytes",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_granted,
{ "Client Credit Granted", "bthcrp.client_credit_granted",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_granted,
{ "Server Credit Granted", "bthcrp.server_credit_granted",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_return,
{ "Client Credit Return", "bthcrp.client_credit_return",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_return,
{ "Server Credit Return", "bthcrp.server_credit_return",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_query,
{ "Client Credit Query", "bthcrp.client_credit_query",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_query,
{ "Server Credit Query", "bthcrp.server_credit_query",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_reserved_76,
{ "Reserved", "bthcrp.status.reserved76",
FT_UINT8, BASE_DEC, NULL, 0xC0,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_paper_empty,
{ "Paper Empty", "bthcrp.status.paper_empty",
FT_BOOLEAN, 8, NULL, 0x20,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_select,
{ "Select", "bthcrp.status.select",
FT_BOOLEAN, 8, NULL, 0x10,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_not_error,
{ "Not Error", "bthcrp.status.not_error",
FT_BOOLEAN, 8, NULL, 0x08,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_reserved_20,
{ "Reserved", "bthcrp.status.reserved210",
FT_UINT8, BASE_HEX, NULL, 0x07,
NULL, HFILL }
},
{ &hf_bthcrp_data,
{ "Data", "bthcrp.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
}
};
static gint *ett[] = {
&ett_bthcrp
};
proto_bthcrp = proto_register_protocol("Bluetooth HCRP Profile", "BT HCRP", "bthcrp");
register_dissector("bthcrp", dissect_bthcrp, proto_bthcrp);
proto_register_field_array(proto_bthcrp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
module = prefs_register_protocol(proto_bthcrp, NULL);
prefs_register_static_text_preference(module, "hcrp.version",
"Bluetooth Profile HCRP version: 1.2",
"Version of profile supported by this dissector.");
prefs_register_bool_preference(module, "hcrp.is_client", "Client Source?",
"If \"true\" logs should be treat as from Client side, otherwise as from Server side",
&is_client);
prefs_register_uint_preference(module, "hcrp.control.psm", "L2CAP PSM for Control",
"L2CAP PSM for Control",
10, &psm_control);
prefs_register_uint_preference(module, "hcrp.data.psm", "L2CAP PSM for Data",
"L2CAP PSM for Data",
10, &psm_data_stream);
prefs_register_uint_preference(module, "hcrp.notification.psm", "L2CAP PSM for Notification",
"L2CAP PSM for Notification",
10, &psm_notification);
}
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.");
}
void
proto_register_btatt(void)
{
module_t *module;
static hf_register_info hf[] = {
{&hf_btatt_opcode,
{"Opcode", "btatt.opcode",
FT_UINT8, BASE_HEX, VALS(opcode_vals), 0x0,
NULL, HFILL}
},
{&hf_btatt_handle,
{"Handle", "btatt.handle",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_starting_handle,
{"Starting Handle", "btatt.starting_handle",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_ending_handle,
{"Ending Handle", "btatt.ending_handle",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_group_end_handle,
{"Group End Handle", "btatt.group_end_handle",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_value,
{"Value", "btatt.value",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_req_opcode_in_error,
{"Request Opcode in Error", "btatt.req_opcode_in_error",
FT_UINT8, BASE_HEX, VALS(opcode_vals), 0x0,
NULL, HFILL}
},
{&hf_btatt_handle_in_error,
{"Handle in Error", "btatt.handle_in_error",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_error_code,
{"Error Code", "btatt.error_code",
FT_UINT8, BASE_HEX, VALS(error_vals), 0x0,
NULL, HFILL}
},
{&hf_btatt_uuid16,
{"UUID", "btatt.uuid16",
FT_UINT16, BASE_HEX |BASE_EXT_STRING, &uuid_vals_ext, 0x0,
NULL, HFILL}
},
{&hf_btatt_uuid128,
{"UUID", "btatt.uuid128",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_client_rx_mtu,
{"Client Rx MTU", "btatt.client_rx_mtu",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_server_rx_mtu,
{"Server Rx MTU", "btatt.server_rx_mtu",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_uuid_format,
{"UUID Format", "btatt.uuid_format",
FT_UINT8, BASE_HEX, VALS(uuid_format_vals), 0x0,
NULL, HFILL}
},
{&hf_btatt_length,
{"Length", "btatt.length",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Length of Handle/Value Pair", HFILL}
},
{&hf_btatt_offset,
{"Offset", "btatt.offset",
FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_flags,
{"Flags", "btatt.flags",
FT_UINT8, BASE_HEX, VALS(flags_vals), 0x0,
NULL, HFILL}
},
{&hf_btatt_sign_counter,
{"Sign Counter", "btatt.sign_counter",
FT_UINT32, BASE_DEC, NULL, 0x0,
NULL, HFILL}
},
{&hf_btatt_signature,
{"Signature", "btatt.signature",
FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL}
}
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_btatt,
&ett_btatt_list
};
/* Register the protocol name and description */
proto_btatt = proto_register_protocol("Bluetooth Attribute Protocol", "BT ATT", "btatt");
register_dissector("btatt", dissect_btatt, proto_btatt);
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_btatt, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
module = prefs_register_protocol(proto_btatt, NULL);
prefs_register_static_text_preference(module, "att.version",
"Bluetooth Protocol ATT version from Core 4.0",
"Version of protocol supported by this dissector.");
}
void
proto_register_sbc(void)
{
module_t *module;
expert_module_t* expert_sbc;
static hf_register_info hf[] = {
{ &hf_sbc_fragmented,
{ "Fragmented", "sbc.fragmented",
FT_BOOLEAN, 8, NULL, 0x80,
NULL, HFILL }
},
{ &hf_sbc_starting_packet,
{ "Starting Packet", "sbc.starting_packet",
FT_BOOLEAN, 8, NULL, 0x40,
NULL, HFILL }
},
{ &hf_sbc_last_packet,
{ "Last Packet", "sbc.last_packet",
FT_BOOLEAN, 8, NULL, 0x20,
NULL, HFILL }
},
{ &hf_sbc_rfa,
{ "RFA", "sbc.rfa",
FT_BOOLEAN, 8, NULL, 0x10,
NULL, HFILL }
},
{ &hf_sbc_number_of_frames,
{ "Number of Frames", "sbc.number_of_frames",
FT_UINT8, BASE_DEC, NULL, 0x0F,
NULL, HFILL }
},
{ &hf_sbc_syncword,
{ "Sync Word", "sbc.syncword",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_sampling_frequency,
{ "Sampling Frequency", "sbc.sampling_frequency",
FT_UINT8, BASE_HEX, VALS(sampling_frequency_vals), 0xC0,
NULL, HFILL }
},
{ &hf_sbc_blocks,
{ "Blocks", "sbc.blocks",
FT_UINT8, BASE_HEX, VALS(blocks_vals), 0x30,
NULL, HFILL }
},
{ &hf_sbc_channel_mode,
{ "Channel Mode", "sbc.channel_mode",
FT_UINT8, BASE_HEX, VALS(channel_mode_vals), 0x0C,
NULL, HFILL }
},
{ &hf_sbc_allocation_method,
{ "Allocation Method", "sbc.allocation_method",
FT_UINT8, BASE_HEX, VALS(allocation_method_vals), 0x02,
NULL, HFILL }
},
{ &hf_sbc_subbands,
{ "Subbands", "sbc.subbands",
FT_UINT8, BASE_HEX, VALS(subbands_vals), 0x01,
NULL, HFILL }
},
{ &hf_sbc_bitpool,
{ "Bitpool", "sbc.bitpool",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_crc_check,
{ "CRC Check", "sbc.crc_check",
FT_UINT8, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_expected_data_speed,
{ "Expected data speed", "sbc.expected_speed_data",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_frame_duration,
{ "Frame Duration", "sbc.frame_duration",
FT_DOUBLE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_cummulative_frame_duration,
{ "Cummulative Frame Duration", "sbc.cummulative_frame_duration",
FT_DOUBLE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_delta_time,
{ "Delta time", "sbc.delta_time",
FT_DOUBLE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_delta_time_from_the_beginning,
{ "Delta time from the beginning", "sbc.delta_time_from_the_beginning",
FT_DOUBLE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_cummulative_duration,
{ "Cummulative Music Duration", "sbc.cummulative_music_duration",
FT_DOUBLE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_diff,
{ "Diff", "sbc.diff",
FT_DOUBLE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_sbc_data,
{ "Frame Data", "sbc.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_sbc,
&ett_sbc_list,
};
static ei_register_info ei[] = {
{ &ei_sbc_syncword, { "sbc.syncword.unexpected", PI_PROTOCOL, PI_WARN, "Unexpected syncword", EXPFILL }},
};
proto_sbc = proto_register_protocol("Bluetooth SBC Codec", "SBC", "sbc");
proto_register_field_array(proto_sbc, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_sbc = expert_register_protocol(proto_sbc);
expert_register_field_array(expert_sbc, ei, array_length(ei));
new_register_dissector("sbc", dissect_sbc, proto_sbc);
module = prefs_register_protocol(proto_sbc, NULL);
prefs_register_static_text_preference(module, "a2dp.version",
"Bluetooth Audio Codec SBC version based on A2DP 1.3",
"Version of codec supported by this dissector.");
}
void
proto_register_bthcrp(void)
{
module_t *module;
expert_module_t* expert_bthcrp;
static hf_register_info hf[] = {
{ &hf_bthcrp_control_pdu_id,
{ "Control PDU ID", "bthcrp.control.pdu_id",
FT_UINT16, BASE_HEX, VALS(control_pdu_id_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_transaction_id,
{ "Transaction ID", "bthcrp.control.transaction_id",
FT_UINT16, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_parameter_length,
{ "Parameter Length", "bthcrp.control.parameter_length",
FT_UINT16, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_status,
{ "Status", "bthcrp.control.status",
FT_UINT16, BASE_HEX, VALS(status_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_notification_pdu_id,
{ "Notification PDU ID", "bthcrp.notification.pdu_id",
FT_UINT16, BASE_HEX, VALS(notification_pdu_id_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_callback_context_id,
{ "Callback Context ID", "bthcrp.callback.context_id",
FT_UINT32, BASE_HEX, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_callback_timeout,
{ "Callback Timeout", "bthcrp.callback.timeout",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_timeout,
{ "Timeout", "bthcrp.timeout",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_register,
{ "Register", "bthcrp.register",
FT_UINT8, BASE_HEX, VALS(register_vals), 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_1284_id,
{ "1284 ID", "bthcrp.1284_id",
FT_STRING, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_start_byte,
{ "Start Byte", "bthcrp.start_byte",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_number_of_bytes,
{ "Number Of Bytes", "bthcrp.number_of_bytes",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_granted,
{ "Client Credit Granted", "bthcrp.client_credit_granted",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_granted,
{ "Server Credit Granted", "bthcrp.server_credit_granted",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_return,
{ "Client Credit Return", "bthcrp.client_credit_return",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_return,
{ "Server Credit Return", "bthcrp.server_credit_return",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_client_credit_query,
{ "Client Credit Query", "bthcrp.client_credit_query",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_server_credit_query,
{ "Server Credit Query", "bthcrp.server_credit_query",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_reserved_76,
{ "Reserved", "bthcrp.status.reserved76",
FT_UINT8, BASE_DEC, NULL, 0xC0,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_paper_empty,
{ "Paper Empty", "bthcrp.status.paper_empty",
FT_BOOLEAN, 8, NULL, 0x20,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_select,
{ "Select", "bthcrp.status.select",
FT_BOOLEAN, 8, NULL, 0x10,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_not_error,
{ "Not Error", "bthcrp.status.not_error",
FT_BOOLEAN, 8, NULL, 0x08,
NULL, HFILL }
},
{ &hf_bthcrp_control_status_reserved_20,
{ "Reserved", "bthcrp.status.reserved210",
FT_UINT8, BASE_HEX, NULL, 0x07,
NULL, HFILL }
},
{ &hf_bthcrp_data,
{ "Data", "bthcrp.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
}
};
static gint *ett[] = {
&ett_bthcrp
};
static ei_register_info ei[] = {
{ &ei_bthcrp_control_parameter_length, { "bthcrp.control_parameter_length.bad", PI_PROTOCOL, PI_WARN, "Length bad", EXPFILL }},
{ &ei_bthcrp_unexpected_data, { "bthcrp.unexpected_data", PI_PROTOCOL, PI_WARN, "Unexpected data", EXPFILL }},
};
proto_bthcrp = proto_register_protocol("Bluetooth HCRP Profile", "BT HCRP", "bthcrp");
bthcrp_handle = register_dissector("bthcrp", dissect_bthcrp, proto_bthcrp);
proto_register_field_array(proto_bthcrp, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
expert_bthcrp = expert_register_protocol(proto_bthcrp);
expert_register_field_array(expert_bthcrp, ei, array_length(ei));
module = prefs_register_protocol(proto_bthcrp, NULL);
prefs_register_static_text_preference(module, "hcrp.version",
"Bluetooth Profile HCRP version: 1.2",
"Version of profile supported by this dissector.");
prefs_register_obsolete_preference(module, "hcrp.is_client");
prefs_register_enum_preference(module, "hcrp.force_client", "Force Client",
"If \"yes\" localhost will be treat as Client, \"no\" as Server",
&force_client, force_client_enum, FALSE);
prefs_register_uint_preference(module, "hcrp.control.psm", "L2CAP PSM for Control",
"L2CAP PSM for Control",
10, &psm_control);
prefs_register_uint_preference(module, "hcrp.data.psm", "L2CAP PSM for Data",
"L2CAP PSM for Data",
10, &psm_data_stream);
prefs_register_uint_preference(module, "hcrp.notification.psm", "L2CAP PSM for Notification",
"L2CAP PSM for Notification",
10, &psm_notification);
}
void
proto_register_btmcap(void)
{
module_t *module;
static hf_register_info hf[] = {
{ &hf_btmcap_op_code,
{ "Op Code", "btmcap.op_code",
FT_UINT8, BASE_HEX, VALS(op_code_vals), 0x0,
NULL, HFILL }
},
{ &hf_btmcap_response_code,
{ "Response Code", "btmcap.response_code",
FT_UINT8, BASE_HEX, VALS(response_code_vals), 0x0,
NULL, HFILL }
},
{ &hf_btmcap_mdl_id,
{ "MDL ID", "btmcap.mdl_id",
FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_btmcap_mdep_id,
{ "MDEP ID", "btmcap.mdep_id",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_btmcap_configuration,
{ "Configuration", "btmcap.configuration",
FT_UINT8, BASE_HEX, NULL, 0x0,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_required_accuracy,
{ "Timestamp Required Accuracy", "btmcap.timestamp_required_accuracy",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_update_information,
{ "Timestamp Update Information", "btmcap.timestamp_update_information",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_bluetooth_clock_sync_time,
{ "Bluetooth Clock Sync Time", "btmcap.bluetooth_clock_sync_time",
FT_UINT32, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_sync_time,
{ "Timestamp Sync Time", "btmcap.timestamp_sync_time",
FT_UINT64, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_sample_accuracy,
{ "Timestamp Sample Accuracy", "btmcap.timestamp_sample_accuracy",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_bluetooth_clock_access_resolution,
{ "Bluetooth Clock Access Resolution","btmcap.bluetooth_clock_access_resolution",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_sync_lead_time,
{ "Sync Lead Time", "btmcap.sync_lead_time",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_native_resolution,
{ "Timestamp Native Resolution", "btmcap.timestamp_native_resolution",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_timestamp_native_accuracy,
{ "Timestamp Native Accuracy", "btmcap.timestamp_native_accuracy",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_response_parameters,
{ "Response Parameters", "btmcap.response_parameters",
FT_BYTES, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btmcap_data,
{ "Data", "btmcap.data",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
};
static gint *ett[] = {
&ett_btmcap
};
proto_btmcap = proto_register_protocol("Bluetooth MCAP Protocol", "BT MCAP", "btmcap");
register_dissector("btmcap", dissect_btmcap, proto_btmcap);
proto_register_field_array(proto_btmcap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
module = prefs_register_protocol(proto_btmcap, NULL);
prefs_register_static_text_preference(module, "mcap.version",
"Bluetooth Protocol MCAP version: 1.0",
"Version of protocol supported by this dissector.");
}
void proto_register_ismacryp (void)
{
/* A header field is something you can search/filter on.
*
* We create a structure to register our fields. It consists of an
* array of hf_register_info structures, each of which are of the format
* {&(field id), {name, abbrev, type, display, strings, bitmask, blurb, HFILL}}.
*/
static hf_register_info hf[] = {
#if 0
{ &hf_ismacryp,
{ "Data", "ismacryp.data", FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
#endif
#if 0
{ &hf_ismacryp_length,
{ "Total Length", "ismacryp.len", FT_UINT16, BASE_DEC, NULL, 0x0, /* length 2 bytes, print as decimal value */
NULL, HFILL }},
#endif
{ &hf_ismacryp_header,
{ "AU Header", "ismacryp.header", FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
#if 0
{ &hf_ismacryp_header_length,
{ "Header Length", "ismacryp.header.length", FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
#endif
{ &hf_ismacryp_au_headers_length,
{ "AU Headers Length", "ismacryp.au_headers.length", FT_UINT16, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_header_byte,
{ "Header Byte", "ismacryp.header.byte", FT_NONE, BASE_NONE, NULL, 0x0, /* 1 byte */
NULL, HFILL }},
#if 0
{ &hf_ismacryp_version,
{ "Version", "ismacryp.version", FT_UINT8, BASE_HEX, NULL, 0x0, /* version 1 byte */
NULL, HFILL }},
#endif
{ &hf_ismacryp_message,
{ "Message", "ismacryp.message", FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
#if 0
{ &hf_ismacryp_message_length,
{ "Message Length", "ismacryp.message.len", FT_UINT16, BASE_DEC, NULL, 0x0, /* length 2 bytes, print as decimal value */
NULL, HFILL }},
#endif
#if 0
{ &hf_ismacryp_parameter,
{ "Parameter", "ismacryp.parameter", FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
#endif
#if 0
{ &hf_ismacryp_parameter_length,
{ "Parameter Length", "ismacryp.parameter.len", FT_UINT16, BASE_DEC, NULL, 0x0, /* length 2 bytes, print as decimal value */
NULL, HFILL }},
#endif
{ &hf_ismacryp_iv,
{ "IV", "ismacryp.iv", FT_BYTES, BASE_NONE, NULL, 0x0, /* variable length */
NULL, HFILL }},
{ &hf_ismacryp_delta_iv,
{ "Delta IV", "ismacryp.delta_iv", FT_BYTES, BASE_NONE, NULL, 0x0, /* variable length */
NULL, HFILL }},
{ &hf_ismacryp_key_indicator,
{ "Key Indicator", "ismacryp.key_indicator", FT_BYTES, BASE_NONE, NULL, 0x0, /* variable length */
NULL, HFILL }},
#if 0
{ &hf_ismacryp_parameter_value,
{ "Parameter Value", "ismacryp.parameter.value", FT_NONE, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
#endif
{ &hf_ismacryp_au_size,
{ "AU size", "ismacryp.au.size", FT_UINT64, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_au_index,
{ "AU index", "ismacryp.au.index", FT_UINT64, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_au_index_delta,
{ "AU index delta", "ismacryp.au.index_delta", FT_UINT64, BASE_DEC, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_cts_delta,
{ "CTS delta", "ismacryp.cts_delta", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_cts_flag,
{ "CTS flag", "ismacryp.cts_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_dts_delta,
{ "DTS delta", "ismacryp.dts_delta", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_dts_flag,
{ "DTS flag", "ismacryp.dts_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_rap_flag,
{ "RAP flag", "ismacryp.rap_flag", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_stream_state,
{ "Stream state", "ismacryp.stream_state", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_au_is_encrypted,
{ "AU_is_encrypted flag", "ismacryp.au_is_encrypted", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_slice_start,
{ "Slice_start flag", "ismacryp.slice_start", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_slice_end,
{ "Slice_end flag", "ismacryp.slice_end", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_padding_bitcount,
{ "Padding_bitcount bits", "ismacryp.padding_bitcount", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_padding,
{ "Padding bits", "ismacryp.padding", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_reserved_bits,
{ "Reserved bits", "ismacryp.reserved", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_ismacryp_unused_bits,
{ "Unused bits", "ismacryp.unused", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
NULL, HFILL }}
};
static gint *ett[] =
{
&ett_ismacryp,
&ett_ismacryp_header,
&ett_ismacryp_header_byte,
&ett_ismacryp_message
};
static const enum_val_t version_types[] = {
{PROTO_TAG_ISMACRYP_11, "ISMACryp v1.1", V11},
{PROTO_TAG_ISMACRYP_20, "ISMACryp v2.0", V20},
{NULL, NULL, -1}
};
static const enum_val_t mode_types[] = {
{"aac-hbr", "aac-hbr", AAC_HBR_MODE},
{"mpeg4-video", "mpeg4-video", MPEG4_VIDEO_MODE},
{"avc-video", "avc-video", AVC_VIDEO_MODE},
{NULL, NULL, -1}
};
module_t *ismacryp_module;
proto_ismacryp = proto_register_protocol ("ISMACryp Protocol", "ISMACRYP", "ismacryp");
proto_register_field_array (proto_ismacryp, hf, array_length (hf));
proto_register_subtree_array (ett, array_length (ett));
/* Register our configuration options for ismacryp */
/* this registers our preferences, function proto_reg_handoff_ismacryp is called when preferences are applied */
ismacryp_module = prefs_register_protocol(proto_ismacryp, proto_reg_handoff_ismacryp);
prefs_register_uint_preference(ismacryp_module, "dynamic.payload.type",
"ISMACryp dynamic payload type",
"The dynamic payload type which will be interpreted as ISMACryp",
10,
&pref_dynamic_payload_type);
prefs_register_enum_preference(ismacryp_module, "version",
"ISMACryp version",
"ISMACryp version",
&version_type, version_types, TRUE);
prefs_register_static_text_preference(ismacryp_module, "text_override",
"The following option allows the version to be set manually"
" and to override the version if detected from RTP payload type:",
"The following option allows the version to be set manually"
" and to override the version if detected from RTP payload type:");
prefs_register_bool_preference(ismacryp_module,
"override_rtp_pt","Override RTP payload type for version",
"Indicates whether or not the ISMACryp version deduced"
" from RTP payload type, if present, is used or whether the"
" version above is used",
&override_flag);
/* ISMACryp v11 parameters */
prefs_register_static_text_preference(ismacryp_module,
"v11_parameters",
"ISMACryp v1.1 parameters:",
"ISMACryp v1.1 parameters declared in SDP");
prefs_register_uint_preference(ismacryp_module,
"iv_length","ISMACrypIVLength (bytes)",
"Set the length of the IV in the ISMACryp AU Header in bytes",
10, &iv_length);
prefs_register_uint_preference(ismacryp_module,
"delta_iv_length","ISMACrypDeltaIVLength (bytes)",
"Set the length of the Delta IV in the ISMACryp AU Header in bytes",
10, &delta_iv_length);
prefs_register_uint_preference(ismacryp_module,
"key_indicator_length","ISMACrypKeyIndicatorLength (bytes)",
"Set the length of the Key Indicator in the ISMACryp AU Header in bytes",
10, &key_indicator_length);
prefs_register_bool_preference(ismacryp_module,
"key_indicator_per_au_flag","ISMACrypKeyIndicatorPerAU (T/F)",
"Indicates whether or not the Key Indicator is present in all AU Headers (T/F)",
&key_indicator_per_au_flag);
prefs_register_bool_preference(ismacryp_module,
"selective_encryption","ISMACrypSelectiveEncryption (T/F)",
"Indicates whether or not selective encryption is enabled (T/F)",
&selective_encryption);
/* ISMACryp v20 parameters */
prefs_register_static_text_preference(ismacryp_module,
"v20_parameters",
"ISMACryp v2.0 parameters:",
"ISMACryp v2.0 parameters declared in SDP");
prefs_register_bool_preference(ismacryp_module,
"slice_indication","ISMACrypSliceIndication (T/F)",
"Indicates whether or not slice start / end is present (T/F)",
&slice_indication);
prefs_register_bool_preference(ismacryp_module,
"padding_indication","ISMACrypPaddingIndication (T/F)",
"Indicates whether or not padding information is present (T/F)",
&padding_indication);
/* RFC3640 mode - ISMACryp v11 */
prefs_register_static_text_preference(ismacryp_module,
"codec_modes",
"Codec mode selection (RFC3640 for ISMACryp v1.1 only):",
"AU parameters set according to RFC3640 mode or user defined");
prefs_register_enum_preference(ismacryp_module,
"rfc3640_mode",
"RFC3640 mode",
"RFC3640 mode",
&mode, mode_types, TRUE);
/* User defined mode */
prefs_register_bool_preference(ismacryp_module,
"user_mode","User mode (T/F)",
"Indicates use of user mode instead of RFC3640 modes (T/F)",
&pref_user_mode);
/* following preference values only used if user mode is selected above */
prefs_register_static_text_preference(ismacryp_module,
"user_defined_modes",
"Following parameters only valid and used for user mode:",
"AU parameters defined by the user");
/* ideally would grey this out or disable this if in user mode */
prefs_register_uint_preference(ismacryp_module,
"au_size_length","User mode: SizeLength (bits)",
"Set the length of the AU size in the AU Header in bits",
10, &pref_au_size_length);
prefs_register_uint_preference(ismacryp_module,
"au_index_length","User mode: IndexLength (bits)",
"Set the length of the AU index in the AU Header in bits",
10, &pref_au_index_length);
prefs_register_uint_preference(ismacryp_module,
"au_index_delta_length","User mode: IndexDeltaLength (bits)",
"Set the length of the AU delta index in the AU Header in bits",
10, &pref_au_index_delta_length);
prefs_register_uint_preference(ismacryp_module,
"cts_delta_length","User mode: CTSDeltaLength (bits)",
"Set the length of the CTS delta field in the AU Header in bits",
10, &pref_cts_delta_length);
prefs_register_uint_preference(ismacryp_module,
"dts_delta_length","User mode: DTSDeltaLength (bits)",
"Set the length of the DTS delta field in the AU Header in bits",
10, &pref_dts_delta_length);
prefs_register_bool_preference(ismacryp_module,
"random_access_indication","User mode: RandomAccessIndication (T/F)",
"Indicates whether or not the RAP field is present in the AU Header (T/F)",
&pref_random_access_indication);
prefs_register_uint_preference(ismacryp_module,
"stream_state_indication","User mode: StreamStateIndication (number of bits)",
"Indicates the number of bits on which the stream state field is encoded"
" in the AU Header (bits)",
10, &pref_stream_state_indication);
}
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_btbnep(void)
{
module_t *module;
static hf_register_info hf[] = {
{ &hf_btbnep_bnep_type,
{ "BNEP Type", "btbnep.bnep_type",
FT_UINT8, BASE_HEX, VALS(bnep_type_vals), 0x7F,
NULL, HFILL }
},
{ &hf_btbnep_extension_flag,
{ "Extension Flag", "btbnep.extension_flag",
FT_BOOLEAN, 8, NULL, 0x80,
NULL, HFILL }
},
{ &hf_btbnep_control_type,
{ "Control Type", "btbnep.control_type",
FT_UINT8, BASE_HEX, VALS(control_type_vals), 0x00,
NULL, HFILL }
},
{ &hf_btbnep_extension_type,
{ "Extension Type", "btbnep.extension_type",
FT_UINT8, BASE_HEX, VALS(extension_type_vals), 0x00,
NULL, HFILL }
},
{ &hf_btbnep_extension_length,
{ "Extension Length", "btbnep.extension_length",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btbnep_unknown_control_type,
{ "Unknown Control Type", "btbnep.uknown_control_type",
FT_UINT8, BASE_HEX, VALS(control_type_vals), 0x00,
NULL, HFILL }
},
{ &hf_btbnep_uuid_size,
{ "UIDD Size", "btbnep.uuid_size",
FT_UINT8, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btbnep_destination_service_uuid,
{ "Destination Service UUID", "btbnep.destination_service_uuid",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btbnep_source_service_uuid,
{ "Source Service UUID", "btbnep.source_service_uuid",
FT_NONE, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btbnep_setup_connection_response_message,
{ "Response Message", "btbnep.setup_connection_response_message",
FT_UINT16, BASE_HEX, VALS(setup_connection_response_message_vals), 0x00,
NULL, HFILL }
},
{ &hf_btbnep_filter_net_type_response_message,
{ "Response Message", "btbnep.filter_net_type_response_message",
FT_UINT16, BASE_HEX, VALS(filter_net_type_response_message_vals), 0x00,
NULL, HFILL }
},
{ &hf_btbnep_filter_multi_addr_response_message,
{ "Response Message", "btbnep.filter_multi_addr_response_message",
FT_UINT16, BASE_HEX, VALS(filter_multi_addr_response_message_vals), 0x00,
NULL, HFILL }
},
{ &hf_btbnep_list_length,
{ "List Length", "btbnep.list_length",
FT_UINT16, BASE_DEC, NULL, 0x00,
NULL, HFILL }
},
/* http://www.iana.org/assignments/ethernet-numbers */
{ &hf_btbnep_network_type_start,
{ "Network Protocol Type Range Start", "btbnep.network_type_start",
FT_UINT16, BASE_HEX, VALS(etype_vals), 0x00,
NULL, HFILL }
},
{ &hf_btbnep_network_type_end,
{ "Network Protocol Type Range End", "btbnep.network_type_end",
FT_UINT16, BASE_HEX, VALS(etype_vals), 0x00,
NULL, HFILL }
},
{ &hf_btbnep_multicast_address_start,
{ "Multicast Address Start", "btbnep.multicast_address_start",
FT_ETHER, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btbnep_multicast_address_end,
{ "Multicast Address End", "btbnep.multicast_address_end",
FT_ETHER, BASE_NONE, NULL, 0x00,
NULL, HFILL }
},
{ &hf_btbnep_dst,
{ "Destination", "btbnep.dst",
FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Hardware Address", HFILL }
},
{ &hf_btbnep_src,
{ "Source", "btbnep.src",
FT_ETHER, BASE_NONE, NULL, 0x0,
"Source Hardware Address", HFILL }
},
{ &hf_btbnep_type,
{ "Type", "btbnep.type",
FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
NULL, HFILL }
},
{ &hf_btbnep_addr,
{ "Address", "btbnep.addr",
FT_ETHER, BASE_NONE, NULL, 0x0,
"Source or Destination Hardware Address", HFILL }
},
{ &hf_btbnep_lg,
{ "LG bit", "btbnep.lg",
FT_BOOLEAN, 24, TFS(&lg_tfs), 0x020000,
"Specifies if this is a locally administered or globally unique (IEEE assigned) address", HFILL }
},
{ &hf_btbnep_ig,
{ "IG bit", "btbnep.ig",
FT_BOOLEAN, 24, TFS(&ig_tfs), 0x010000,
"Specifies if this is an individual (unicast) or group (broadcast/multicast) address", HFILL }
}
};
static gint *ett[] = {
&ett_btbnep,
&ett_addr
};
proto_btbnep = proto_register_protocol("Bluetooth BNEP Protocol", "BT BNEP", "btbnep");
register_dissector("btbnep", dissect_btbnep, proto_btbnep);
proto_register_field_array(proto_btbnep, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
module = prefs_register_protocol(proto_btbnep, NULL);
prefs_register_static_text_preference(module, "bnep.version",
"Bluetooth Protocol BNEP version: 1.0",
"Version of protocol supported by this dissector.");
prefs_register_bool_preference(module, "bnep.top_dissect",
"Dissecting the top protocols", "Dissecting the top protocols",
&top_dissect);
}
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
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.");
}
