From 32ef0a1a18182a749a98668d35d70e79143741c4 Mon Sep 17 00:00:00 2001 From: Michael Mann Date: Wed, 25 Jul 2012 13:56:15 +0000 Subject: Converted scsi dissectors display filter format from scsi. to scsi_ (matching their registered filter name) svn path=/trunk/; revision=43993 --- epan/dissectors/packet-scsi-mmc.c | 290 +++++++++++++++++++------------------- epan/dissectors/packet-scsi-osd.c | 162 ++++++++++----------- epan/dissectors/packet-scsi-sbc.c | 182 ++++++++++++------------ epan/dissectors/packet-scsi-smc.c | 34 ++--- epan/dissectors/packet-scsi-ssc.c | 82 +++++------ epan/dissectors/packet-scsi.c | 40 +++--- 6 files changed, 395 insertions(+), 395 deletions(-) (limited to 'epan/dissectors') diff --git a/epan/dissectors/packet-scsi-mmc.c b/epan/dissectors/packet-scsi-mmc.c index 67e41aace2..7f06397a99 100644 --- a/epan/dissectors/packet-scsi-mmc.c +++ b/epan/dissectors/packet-scsi-mmc.c @@ -1479,439 +1479,439 @@ proto_register_scsi_mmc(void) { static hf_register_info hf[] = { { &hf_scsi_mmc_opcode, - {"MMC Opcode", "scsi.mmc.opcode", FT_UINT8, BASE_HEX, + {"MMC Opcode", "scsi_mmc.opcode", FT_UINT8, BASE_HEX, VALS (scsi_mmc_vals), 0x0, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_type, - {"Type", "scsi.mmc.setstreaming.type", FT_UINT8, BASE_DEC, + {"Type", "scsi_mmc.setstreaming.type", FT_UINT8, BASE_DEC, VALS(scsi_setstreaming_type_val), 0, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_param_len, - {"Parameter Length", "scsi.mmc.setstreaming.param_len", FT_UINT16, BASE_DEC, + {"Parameter Length", "scsi_mmc.setstreaming.param_len", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_wrc, - {"WRC", "scsi.mmc.setstreaming.wrc", FT_UINT8, BASE_HEX, + {"WRC", "scsi_mmc.setstreaming.wrc", FT_UINT8, BASE_HEX, NULL, 0x18, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_rdd, - {"RDD", "scsi.mmc.setstreaming.rdd", FT_BOOLEAN, 8, + {"RDD", "scsi_mmc.setstreaming.rdd", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_exact, - {"Exact", "scsi.mmc.setstreaming.exact", FT_BOOLEAN, 8, + {"Exact", "scsi_mmc.setstreaming.exact", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_ra, - {"RA", "scsi.mmc.setstreaming.ra", FT_BOOLEAN, 8, + {"RA", "scsi_mmc.setstreaming.ra", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_start_lba, - {"Start LBA", "scsi.mmc.setstreaming.start_lbs", FT_UINT32, BASE_DEC, + {"Start LBA", "scsi_mmc.setstreaming.start_lbs", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_end_lba, - {"End LBA", "scsi.mmc.setstreaming.end_lba", FT_UINT32, BASE_DEC, + {"End LBA", "scsi_mmc.setstreaming.end_lba", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_read_size, - {"Read Size", "scsi.mmc.setstreaming.read_size", FT_UINT32, BASE_DEC, + {"Read Size", "scsi_mmc.setstreaming.read_size", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_read_time, - {"Read Time", "scsi.mmc.setstreaming.read_time", FT_UINT32, BASE_DEC, + {"Read Time", "scsi_mmc.setstreaming.read_time", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_write_size, - {"Write Size", "scsi.mmc.setstreaming.write_size", FT_UINT32, BASE_DEC, + {"Write Size", "scsi_mmc.setstreaming.write_size", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_setstreaming_write_time, - {"Write Time", "scsi.mmc.setstreaming.write_time", FT_UINT32, BASE_DEC, + {"Write Time", "scsi_mmc.setstreaming.write_time", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_setcdspeed_rc, - {"Rotational Control", "scsi.mmc.setcdspeed.rc", FT_UINT8, BASE_HEX, + {"Rotational Control", "scsi_mmc.setcdspeed.rc", FT_UINT8, BASE_HEX, VALS(scsi_setcdspeed_rc_val), 0x03, NULL, HFILL}}, { &hf_scsi_mmc_rbc_block, - {"BLOCK", "scsi.mmc.rbc.block", FT_BOOLEAN, 8, + {"BLOCK", "scsi_mmc.rbc.block", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_rbc_lob_blocks, - {"Buffer Len (blocks)", "scsi.mmc.rbc.lob_blocks", FT_UINT32, BASE_DEC, + {"Buffer Len (blocks)", "scsi_mmc.rbc.lob_blocks", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_rbc_alob_blocks, - {"Available Buffer Len (blocks)", "scsi.mmc.rbc.alob_blocks", FT_UINT32, BASE_DEC, + {"Available Buffer Len (blocks)", "scsi_mmc.rbc.alob_blocks", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_rbc_lob_bytes, - {"Buffer Len (bytes)", "scsi.mmc.rbc.lob_bytes", FT_UINT32, BASE_DEC, + {"Buffer Len (bytes)", "scsi_mmc.rbc.lob_bytes", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_rbc_alob_bytes, - {"Available Buffer Len (bytes)", "scsi.mmc.rbc.alob_bytes", FT_UINT32, BASE_DEC, + {"Available Buffer Len (bytes)", "scsi_mmc.rbc.alob_bytes", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_rti_address_type, - {"Address Type", "scsi.mmc.rti.address_type", FT_UINT8, BASE_HEX, + {"Address Type", "scsi_mmc.rti.address_type", FT_UINT8, BASE_HEX, VALS(scsi_rti_address_type_val), 0x03, NULL, HFILL}}, { &hf_scsi_mmc_rti_damage, - {"Damage", "scsi.mmc.rti.damage", FT_BOOLEAN, 8, + {"Damage", "scsi_mmc.rti.damage", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}}, { &hf_scsi_mmc_rti_copy, - {"Copy", "scsi.mmc.rti.copy", FT_BOOLEAN, 8, + {"Copy", "scsi_mmc.rti.copy", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_mmc_rti_track_mode, - {"Track Mode", "scsi.mmc.rti.track_mode", FT_UINT8, BASE_HEX, + {"Track Mode", "scsi_mmc.rti.track_mode", FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL}}, { &hf_scsi_mmc_rti_rt, - {"RT", "scsi.mmc.rti.rt", FT_BOOLEAN, 8, + {"RT", "scsi_mmc.rti.rt", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}}, { &hf_scsi_mmc_rti_blank, - {"Blank", "scsi.mmc.rti.blank", FT_BOOLEAN, 8, + {"Blank", "scsi_mmc.rti.blank", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}}, { &hf_scsi_mmc_rti_packet, - {"Packet/Inc", "scsi.mmc.rti.packet", FT_BOOLEAN, 8, + {"Packet/Inc", "scsi_mmc.rti.packet", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}}, { &hf_scsi_mmc_rti_fp, - {"FP", "scsi.mmc.rti.fp", FT_BOOLEAN, 8, + {"FP", "scsi_mmc.rti.fp", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_mmc_rti_data_mode, - {"Data Mode", "scsi.mmc.rti.data_mode", FT_UINT8, BASE_HEX, + {"Data Mode", "scsi_mmc.rti.data_mode", FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL}}, { &hf_scsi_mmc_rti_lra_v, - {"LRA_V", "scsi.mmc.rti.lra_v", FT_BOOLEAN, 8, + {"LRA_V", "scsi_mmc.rti.lra_v", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_rti_nwa_v, - {"NWA_V", "scsi.mmc.rti.nwa_v", FT_BOOLEAN, 8, + {"NWA_V", "scsi_mmc.rti.nwa_v", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_report_key_type_code, - {"Type Code", "scsi.mmc.report_key.type_code", FT_UINT8, BASE_HEX, + {"Type Code", "scsi_mmc.report_key.type_code", FT_UINT8, BASE_HEX, VALS(scsi_report_key_type_code_val), 0xc0, NULL, HFILL}}, { &hf_scsi_mmc_report_key_vendor_resets, - {"Vendor Resets", "scsi.mmc.report_key.vendor_resets", FT_UINT8, BASE_HEX, + {"Vendor Resets", "scsi_mmc.report_key.vendor_resets", FT_UINT8, BASE_HEX, NULL, 0x38, NULL, HFILL}}, { &hf_scsi_mmc_report_key_user_changes, - {"User Changes", "scsi.mmc.report_key.user_changes", FT_UINT8, BASE_HEX, + {"User Changes", "scsi_mmc.report_key.user_changes", FT_UINT8, BASE_HEX, NULL, 0x07, NULL, HFILL}}, { &hf_scsi_mmc_report_key_region_mask, - {"Region Mask", "scsi.mmc.report_key.region_mask", FT_UINT8, BASE_HEX, + {"Region Mask", "scsi_mmc.report_key.region_mask", FT_UINT8, BASE_HEX, NULL, 0xff, NULL, HFILL}}, { &hf_scsi_mmc_report_key_rpc_scheme, - {"RPC Scheme", "scsi.mmc.report_key.rpc_scheme", FT_UINT8, BASE_HEX, + {"RPC Scheme", "scsi_mmc.report_key.rpc_scheme", FT_UINT8, BASE_HEX, VALS(scsi_report_key_rpc_scheme_val), 0, NULL, HFILL}}, { &hf_scsi_mmc_key_class, - {"Key Class", "scsi.mmc.key_class", FT_UINT8, BASE_HEX, + {"Key Class", "scsi_mmc.key_class", FT_UINT8, BASE_HEX, VALS (scsi_key_class_val), 0x00, NULL, HFILL}}, { &hf_scsi_mmc_key_format, - {"Key Format", "scsi.mmc.key_format", FT_UINT8, BASE_HEX, + {"Key Format", "scsi_mmc.key_format", FT_UINT8, BASE_HEX, VALS (scsi_key_format_val), 0x3f, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_erasable, - {"Erasable", "scsi.mmc.disc_info.erasable", FT_BOOLEAN, 8, + {"Erasable", "scsi_mmc.disc_info.erasable", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_state_of_last_session, - {"State Of Last Session", "scsi.mmc.disc_info.state_of_last_session", FT_UINT8, BASE_HEX, + {"State Of Last Session", "scsi_mmc.disc_info.state_of_last_session", FT_UINT8, BASE_HEX, VALS(scsi_disc_info_sols_val), 0x0c, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_disk_status, - {"Disk Status", "scsi.mmc.disc_info.disk_status", FT_UINT8, BASE_HEX, + {"Disk Status", "scsi_mmc.disc_info.disk_status", FT_UINT8, BASE_HEX, VALS(scsi_disc_info_disc_status_val), 0x03, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_number_of_sessions, - {"Number Of Sessions", "scsi.mmc.disc_info.number_of_sessions", FT_UINT16, BASE_DEC, + {"Number Of Sessions", "scsi_mmc.disc_info.number_of_sessions", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_first_track_in_last_session, - {"First Track In Last Session", "scsi.mmc.disc_info.first_track_in_last_session", FT_UINT16, BASE_DEC, + {"First Track In Last Session", "scsi_mmc.disc_info.first_track_in_last_session", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_last_track_in_last_session, - {"Last Track In Last Session", "scsi.mmc.disc_info.last_track_in_last_session", FT_UINT16, BASE_DEC, + {"Last Track In Last Session", "scsi_mmc.disc_info.last_track_in_last_session", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_did_v, - {"DID_V", "scsi.mmc.disc_info.did_v", FT_BOOLEAN, 8, + {"DID_V", "scsi_mmc.disc_info.did_v", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_dbc_v, - {"DBC_V", "scsi.mmc.disc_info.dbc_v", FT_BOOLEAN, 8, + {"DBC_V", "scsi_mmc.disc_info.dbc_v", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_uru, - {"URU", "scsi.mmc.disc_info.uru", FT_BOOLEAN, 8, + {"URU", "scsi_mmc.disc_info.uru", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_dac_v, - {"DAC_V", "scsi.mmc.disc_info.dac_v", FT_BOOLEAN, 8, + {"DAC_V", "scsi_mmc.disc_info.dac_v", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_dbit, - {"Dbit", "scsi.mmc.disc_info.dbit", FT_BOOLEAN, 8, + {"Dbit", "scsi_mmc.disc_info.dbit", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_bgfs, - {"BG Format Status", "scsi.mmc.disc_info.bgfs", FT_UINT8, BASE_HEX, + {"BG Format Status", "scsi_mmc.disc_info.bgfs", FT_UINT8, BASE_HEX, VALS(scsi_disc_info_bgfs_val), 0x03, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_disc_type, - {"Disc Type", "scsi.mmc.disc_info.disc_type", FT_UINT8, BASE_HEX, + {"Disc Type", "scsi_mmc.disc_info.disc_type", FT_UINT8, BASE_HEX, VALS(scsi_disc_info_disc_type_val), 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_disc_identification, - {"Disc Identification", "scsi.mmc.disc_info.disc_identification", FT_UINT32, BASE_HEX, + {"Disc Identification", "scsi_mmc.disc_info.disc_identification", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_last_session_lead_in_start_address, - {"Last Session Lead-In Start Address", "scsi.mmc.disc_info.last_session_lead_in_start_address", FT_UINT32, BASE_DEC, + {"Last Session Lead-In Start Address", "scsi_mmc.disc_info.last_session_lead_in_start_address", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_last_possible_lead_out_start_address, - {"Last Possible Lead-Out Start Address", "scsi.mmc.disc_info.last_possible_lead_out_start_address", FT_UINT32, BASE_DEC, + {"Last Possible Lead-Out Start Address", "scsi_mmc.disc_info.last_possible_lead_out_start_address", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_info_disc_bar_code, - {"Disc Bar Code", "scsi.mmc.disc_info.disc_bar_code", FT_UINT64, BASE_HEX, + {"Disc Bar Code", "scsi_mmc.disc_info.disc_bar_code", FT_UINT64, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_readtoc_time, - {"Time", "scsi.mmc.readtoc.time", FT_BOOLEAN, 8, + {"Time", "scsi_mmc.readtoc.time", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_readtoc_format, - {"Format", "scsi.mmc.readtoc.format", FT_UINT8, BASE_HEX, + {"Format", "scsi_mmc.readtoc.format", FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL}}, { &hf_scsi_mmc_readtoc_first_session, - {"First Session", "scsi.mmc.readtoc.first_session", FT_UINT8, BASE_DEC, + {"First Session", "scsi_mmc.readtoc.first_session", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_readtoc_last_track, - {"Last Track", "scsi.mmc.readtoc.last_track", FT_UINT8, BASE_DEC, + {"Last Track", "scsi_mmc.readtoc.last_track", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_readtoc_last_session, - {"Last Session", "scsi.mmc.readtoc.last_session", FT_UINT8, BASE_DEC, + {"Last Session", "scsi_mmc.readtoc.last_session", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_q_subchannel_adr, - {"Q Subchannel ADR", "scsi.mmc.q.subchannel.adr", FT_UINT8, BASE_HEX, + {"Q Subchannel ADR", "scsi_mmc.q.subchannel.adr", FT_UINT8, BASE_HEX, VALS(scsi_q_subchannel_adr_val), 0xf0, NULL, HFILL}}, { &hf_scsi_mmc_q_subchannel_control, - {"Q Subchannel Control", "scsi.mmc.q.subchannel.control", FT_UINT8, BASE_HEX, + {"Q Subchannel Control", "scsi_mmc.q.subchannel.control", FT_UINT8, BASE_HEX, VALS(scsi_q_subchannel_control_val), 0x0f, NULL, HFILL}}, { &hf_scsi_mmc_agid, - {"AGID", "scsi.mmc.agid", FT_UINT8, BASE_HEX, + {"AGID", "scsi_mmc.agid", FT_UINT8, BASE_HEX, NULL, 0xc0, NULL, HFILL}}, { &hf_scsi_mmc_track, - {"Track", "scsi.mmc.track", FT_UINT32, BASE_DEC, + {"Track", "scsi_mmc.track", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_track_size, - {"Track Size", "scsi.mmc.track_size", FT_UINT32, BASE_DEC, + {"Track Size", "scsi_mmc.track_size", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_track_start_address, - {"Track Start Address", "scsi.mmc.track_start_address", FT_UINT32, BASE_DEC, + {"Track Start Address", "scsi_mmc.track_start_address", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_track_start_time, - {"Track Start Time", "scsi.mmc.track_start_time", FT_UINT32, BASE_DEC, + {"Track Start Time", "scsi_mmc.track_start_time", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_lba, - {"Logical Block Address", "scsi.mmc.lba", FT_UINT32, BASE_DEC, + {"Logical Block Address", "scsi_mmc.lba", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_mmc_session, - {"Session", "scsi.mmc.session", FT_UINT32, BASE_DEC, + {"Session", "scsi_mmc.session", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_data_length, - {"Data Length", "scsi.mmc.data_length", FT_UINT32, BASE_DEC, + {"Data Length", "scsi_mmc.data_length", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_mmc_getconf_rt, - {"RT", "scsi.mmc.getconf.rt", FT_UINT8, BASE_HEX, + {"RT", "scsi_mmc.getconf.rt", FT_UINT8, BASE_HEX, VALS(scsi_getconf_rt_val), 0x03, NULL, HFILL}}, { &hf_scsi_mmc_getconf_current_profile, - {"Current Profile", "scsi.mmc.getconf.current_profile", FT_UINT16, BASE_HEX, + {"Current Profile", "scsi_mmc.getconf.current_profile", FT_UINT16, BASE_HEX, VALS(scsi_getconf_current_profile_val), 0, NULL, HFILL}}, { &hf_scsi_mmc_getconf_starting_feature, - {"Starting Feature", "scsi.mmc.getconf.starting_feature", FT_UINT16, BASE_HEX, + {"Starting Feature", "scsi_mmc.getconf.starting_feature", FT_UINT16, BASE_HEX, VALS(scsi_feature_val), 0, NULL, HFILL}}, { &hf_scsi_mmc_feature, - {"Feature", "scsi.mmc.feature", FT_UINT16, BASE_HEX, + {"Feature", "scsi_mmc.feature", FT_UINT16, BASE_HEX, VALS(scsi_feature_val), 0, NULL, HFILL}}, { &hf_scsi_mmc_feature_version, - {"Version", "scsi.mmc.feature.version", FT_UINT8, BASE_DEC, + {"Version", "scsi_mmc.feature.version", FT_UINT8, BASE_DEC, NULL, 0x3c, NULL, HFILL}}, { &hf_scsi_mmc_feature_persistent, - {"Persistent", "scsi.mmc.feature.persistent", FT_UINT8, BASE_HEX, + {"Persistent", "scsi_mmc.feature.persistent", FT_UINT8, BASE_HEX, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_feature_current, - {"Current", "scsi.mmc.feature.current", FT_UINT8, BASE_HEX, + {"Current", "scsi_mmc.feature.current", FT_UINT8, BASE_HEX, NULL, 001, NULL, HFILL}}, { &hf_scsi_mmc_feature_additional_length, - {"Additional Length", "scsi.mmc.feature.additional_length", FT_UINT8, BASE_DEC, + {"Additional Length", "scsi_mmc.feature.additional_length", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_feature_lun_sn, - {"LUN Serial Number", "scsi.mmc.feature.lun_sn", FT_STRING, BASE_NONE, + {"LUN Serial Number", "scsi_mmc.feature.lun_sn", FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_feature_cdread_dap, - {"DAP", "scsi.mmc.feature.cdread.dap", FT_BOOLEAN, 8, + {"DAP", "scsi_mmc.feature.cdread.dap", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}}, { &hf_scsi_mmc_feature_cdread_c2flag, - {"C2 Flag", "scsi.mmc.feature.cdread.c2flag", FT_BOOLEAN, 8, + {"C2 Flag", "scsi_mmc.feature.cdread.c2flag", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_feature_cdread_cdtext, - {"CD-Text", "scsi.mmc.feature.cdread.cdtext", FT_BOOLEAN, 8, + {"CD-Text", "scsi_mmc.feature.cdread.cdtext", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_feature_dvdrw_write, - {"Write", "scsi.mmc.feature.dvdrw.write", FT_BOOLEAN, 8, + {"Write", "scsi_mmc.feature.dvdrw.write", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_feature_dvdrw_quickstart, - {"Quick Start", "scsi.mmc.feature.dvdrw.quickstart", FT_BOOLEAN, 8, + {"Quick Start", "scsi_mmc.feature.dvdrw.quickstart", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_feature_dvdrw_closeonly, - {"Close Only", "scsi.mmc.feature.dvdrw.closeonly", FT_BOOLEAN, 8, + {"Close Only", "scsi_mmc.feature.dvdrw.closeonly", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_feature_dvdr_write, - {"Write", "scsi.mmc.feature.dvdr.write", FT_BOOLEAN, 8, + {"Write", "scsi_mmc.feature.dvdr.write", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_feature_tao_buf, - {"BUF", "scsi.mmc.feature.tao.buf", FT_BOOLEAN, 8, + {"BUF", "scsi_mmc.feature.tao.buf", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}}, { &hf_scsi_mmc_feature_tao_rwraw, - {"R-W Raw", "scsi.mmc.feature.tao.rwraw", FT_BOOLEAN, 8, + {"R-W Raw", "scsi_mmc.feature.tao.rwraw", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_mmc_feature_tao_rwpack, - {"R-W Pack", "scsi.mmc.feature.tao.rwpack", FT_BOOLEAN, 8, + {"R-W Pack", "scsi_mmc.feature.tao.rwpack", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}}, { &hf_scsi_mmc_feature_tao_testwrite, - {"Test Write", "scsi.mmc.feature.tao.testwrite", FT_BOOLEAN, 8, + {"Test Write", "scsi_mmc.feature.tao.testwrite", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_mmc_feature_tao_cdrw, - {"CD-RW", "scsi.mmc.feature.tao.cdrw", FT_BOOLEAN, 8, + {"CD-RW", "scsi_mmc.feature.tao.cdrw", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_feature_tao_rwsubcode, - {"R-W Subcode", "scsi.mmc.feature.tao.rwsubcode", FT_BOOLEAN, 8, + {"R-W Subcode", "scsi_mmc.feature.tao.rwsubcode", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_feature_dts, - {"Data Type Supported", "scsi.mmc.feature.dts", FT_UINT16, BASE_HEX, + {"Data Type Supported", "scsi_mmc.feature.dts", FT_UINT16, BASE_HEX, NULL, 0xffff, NULL, HFILL}}, { &hf_scsi_mmc_feature_sao_buf, - {"BUF", "scsi.mmc.feature.sao.buf", FT_BOOLEAN, 8, + {"BUF", "scsi_mmc.feature.sao.buf", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}}, { &hf_scsi_mmc_feature_sao_sao, - {"SAO", "scsi.mmc.feature.sao.sao", FT_BOOLEAN, 8, + {"SAO", "scsi_mmc.feature.sao.sao", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}}, { &hf_scsi_mmc_feature_sao_rawms, - {"Raw MS", "scsi.mmc.feature.sao.rawms", FT_BOOLEAN, 8, + {"Raw MS", "scsi_mmc.feature.sao.rawms", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_mmc_feature_sao_raw, - {"Raw", "scsi.mmc.feature.sao.raw", FT_BOOLEAN, 8, + {"Raw", "scsi_mmc.feature.sao.raw", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}}, { &hf_scsi_mmc_feature_sao_testwrite, - {"Test Write", "scsi.mmc.feature.sao.testwrite", FT_BOOLEAN, 8, + {"Test Write", "scsi_mmc.feature.sao.testwrite", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_mmc_feature_sao_cdrw, - {"CD-RW", "scsi.mmc.feature.sao.cdrw", FT_BOOLEAN, 8, + {"CD-RW", "scsi_mmc.feature.sao.cdrw", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_feature_sao_rw, - {"R-W", "scsi.mmc.feature.sao.rw", FT_BOOLEAN, 8, + {"R-W", "scsi_mmc.feature.sao.rw", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_feature_sao_mcsl, - {"Maximum Cue Sheet Length", "scsi.mmc.feature.sao.mcsl", FT_UINT24, BASE_DEC, + {"Maximum Cue Sheet Length", "scsi_mmc.feature.sao.mcsl", FT_UINT24, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_feature_dvdr_buf, - {"BUF", "scsi.mmc.feature.dvdr.buf", FT_BOOLEAN, 8, + {"BUF", "scsi_mmc.feature.dvdr.buf", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}}, { &hf_scsi_mmc_feature_dvdr_testwrite, - {"Test Write", "scsi.mmc.feature.dvdr.testwrite", FT_BOOLEAN, 8, + {"Test Write", "scsi_mmc.feature.dvdr.testwrite", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_mmc_feature_dvdr_dvdrw, - {"DVD-RW", "scsi.mmc.feature.dvdr.dvdrw", FT_BOOLEAN, 8, + {"DVD-RW", "scsi_mmc.feature.dvdr.dvdrw", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_feature_profile, - {"Profile", "scsi.mmc.feature.profile", FT_UINT16, BASE_HEX, + {"Profile", "scsi_mmc.feature.profile", FT_UINT16, BASE_HEX, VALS(scsi_getconf_current_profile_val), 0, NULL, HFILL}}, { &hf_scsi_mmc_feature_profile_current, - {"Current", "scsi.mmc.feature.profile.current", FT_BOOLEAN, 8, + {"Current", "scsi_mmc.feature.profile.current", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_feature_isw_buf, - {"BUF", "scsi.mmc.feature.isw.buf", FT_BOOLEAN, 8, + {"BUF", "scsi_mmc.feature.isw.buf", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_feature_isw_num_linksize, - {"Number of Link Sizes", "scsi.mmc.feature.isw.num_linksize", FT_UINT8, BASE_DEC, + {"Number of Link Sizes", "scsi_mmc.feature.isw.num_linksize", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_feature_isw_linksize, - {"Link Size", "scsi.mmc.feature.isw.linksize", FT_UINT8, BASE_DEC, + {"Link Size", "scsi_mmc.feature.isw.linksize", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_read_compatibility_lba, - {"Read Compatibility LBA", "scsi.mmc.read_compatibility_lba", FT_UINT32, BASE_DEC, + {"Read Compatibility LBA", "scsi_mmc.read_compatibility_lba", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_reservation_size, - {"Reservation Size", "scsi.mmc.reservation_size", FT_UINT32, BASE_DEC, + {"Reservation Size", "scsi_mmc.reservation_size", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_last_recorded_address, - {"Last Recorded Address", "scsi.mmc.last_recorded_address", FT_UINT32, BASE_DEC, + {"Last Recorded Address", "scsi_mmc.last_recorded_address", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_first_track, - {"First Track", "scsi.mmc.first_track", FT_UINT8, BASE_DEC, + {"First Track", "scsi_mmc.first_track", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_fixed_packet_size, - {"Fixed Packet Size", "scsi.mmc.fixed_packet_size", FT_UINT32, BASE_DEC, + {"Fixed Packet Size", "scsi_mmc.fixed_packet_size", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_closetrack_immed, - {"IMMED", "scsi.mmc.closetrack.immed", FT_BOOLEAN, 8, + {"IMMED", "scsi_mmc.closetrack.immed", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_closetrack_func, - {"Close Function", "scsi.mmc.closetrack.func", FT_UINT8, BASE_HEX, + {"Close Function", "scsi_mmc.closetrack.func", FT_UINT8, BASE_HEX, VALS(scsi_closetrack_func_val), 0x07, NULL, HFILL}}, { &hf_scsi_mmc_synccache_immed, - {"IMMED", "scsi.mmc.synccache.immed", FT_BOOLEAN, 8, + {"IMMED", "scsi_mmc.synccache.immed", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_synccache_reladr, - {"RelAdr", "scsi.mmc.synccache.reladr", FT_BOOLEAN, 8, + {"RelAdr", "scsi_mmc.synccache.reladr", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_num_blocks, - {"Number of Blocks", "scsi.mmc.num_blocks", FT_UINT32, BASE_DEC, + {"Number of Blocks", "scsi_mmc.num_blocks", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_mmc_next_writable_address, - {"Next Writable Address", "scsi.mmc.next_writable_address", FT_UINT32, BASE_DEC, + {"Next Writable Address", "scsi_mmc.next_writable_address", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_free_blocks, - {"Free Blocks", "scsi.mmc.free_blocks", FT_UINT32, BASE_DEC, + {"Free Blocks", "scsi_mmc.free_blocks", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_read_dvd_format, - { "Format Code", "scsi.mmc.read_dvd.format", FT_UINT8, BASE_HEX, + { "Format Code", "scsi_mmc.read_dvd.format", FT_UINT8, BASE_HEX, VALS(scsi_read_dvd_formats), 0x0, NULL, HFILL}}, { &hf_scsi_mmc_disc_book_type, - { "Type", "scsi.mmc.book.type", FT_UINT8, BASE_HEX, + { "Type", "scsi_mmc.book.type", FT_UINT8, BASE_HEX, VALS(scsi_disc_category_type), 0xf0, NULL, HFILL}}, { &hf_scsi_mmc_disc_book_version, - { "Version", "scsi.mmc.book.version", FT_UINT8, BASE_HEX, + { "Version", "scsi_mmc.book.version", FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL}}, { &hf_scsi_mmc_disc_size_size, - { "Size", "scsi.mmc.disc.size", FT_UINT8, BASE_HEX, + { "Size", "scsi_mmc.disc.size", FT_UINT8, BASE_HEX, VALS(scsi_disc_size), 0xf0, NULL, HFILL}}, { &hf_scsi_mmc_disc_size_rate, - { "Rate", "scsi.mmc.disc.rate", FT_UINT8, BASE_HEX, + { "Rate", "scsi_mmc.disc.rate", FT_UINT8, BASE_HEX, VALS(scsi_disc_rate), 0x0f, NULL, HFILL}}, { &hf_scsi_mmc_disc_structure_layer, - { "Structure", "scsi.mmc.disc.structure", FT_UINT8, BASE_HEX, + { "Structure", "scsi_mmc.disc.structure", FT_UINT8, BASE_HEX, VALS(scsi_disc_structure), 0x0f, NULL, HFILL}}, { &hf_scsi_mmc_disc_density_length, - { "Channel bith length", "scsi.mmc.density.channel_bit_length", FT_UINT8, BASE_HEX, + { "Channel bith length", "scsi_mmc.density.channel_bit_length", FT_UINT8, BASE_HEX, VALS(scsi_density_length), 0xf0, NULL, HFILL}}, { &hf_scsi_mmc_disc_density_pitch, - { "Average Track Pitch", "scsi.mmc.density.average_track_pitch", FT_UINT8, BASE_HEX, + { "Average Track Pitch", "scsi_mmc.density.average_track_pitch", FT_UINT8, BASE_HEX, VALS(scsi_density_pitch), 0x0f, NULL, HFILL}}, { &hf_scsi_mmc_disc_first_physical, - { "First physical sector of data zone", "scsi.mmc.first_physical", FT_UINT24, BASE_HEX, + { "First physical sector of data zone", "scsi_mmc.first_physical", FT_UINT24, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_last_physical, - { "Last physical sector of data zone", "scsi.mmc.last_physical", FT_UINT24, BASE_HEX, + { "Last physical sector of data zone", "scsi_mmc.last_physical", FT_UINT24, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_last_physical_layer0, - { "Last physical sector of layer 0", "scsi.mmc.last_physical_layer0", FT_UINT24, BASE_HEX, + { "Last physical sector of layer 0", "scsi_mmc.last_physical_layer0", FT_UINT24, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_mmc_disc_extended_format_info, - { "Extended Format Info", "scsi.mmc.adip.extended_format_info", FT_BOOLEAN, 8, + { "Extended Format Info", "scsi_mmc.adip.extended_format_info", FT_BOOLEAN, 8, TFS(&scsi_adip_extended_format_info), 0x40, NULL, HFILL}}, { &hf_scsi_mmc_disc_application_code, - { "Disk Application Code", "scsi.mmc.disk_application_code", FT_UINT8, BASE_HEX, + { "Disk Application Code", "scsi_mmc.disk_application_code", FT_UINT8, BASE_HEX, VALS(scsi_disk_application_code), 0x0, NULL, HFILL}}, { &hf_scsi_mmc_adip_eib0, - { "Extended Format Block 0", "scsi.mmc.adip.extended_format_block.0", FT_BOOLEAN, 8, + { "Extended Format Block 0", "scsi_mmc.adip.extended_format_block.0", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_mmc_adip_eib1, - { "Extended Format Block 1", "scsi.mmc.adip.extended_format_block.1", FT_BOOLEAN, 8, + { "Extended Format Block 1", "scsi_mmc.adip.extended_format_block.1", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_mmc_adip_eib2, - { "Extended Format Block 2", "scsi.mmc.adip.extended_format_block.2", FT_BOOLEAN, 8, + { "Extended Format Block 2", "scsi_mmc.adip.extended_format_block.2", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_mmc_adip_eib3, - { "Extended Format Block 3", "scsi.mmc.adip.extended_format_block.3", FT_BOOLEAN, 8, + { "Extended Format Block 3", "scsi_mmc.adip.extended_format_block.3", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}}, { &hf_scsi_mmc_adip_eib4, - { "Extended Format Block 4", "scsi.mmc.adip.extended_format_block.4", FT_BOOLEAN, 8, + { "Extended Format Block 4", "scsi_mmc.adip.extended_format_block.4", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_mmc_adip_eib5, - { "Extended Format Block 5", "scsi.mmc.adip.extended_format_block.5", FT_BOOLEAN, 8, + { "Extended Format Block 5", "scsi_mmc.adip.extended_format_block.5", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}}, { &hf_scsi_mmc_adip_device_manuf_id, - { "Device Manufacturer Id", "scsi.mmc.adip.device_manufacturer_id", FT_STRING, BASE_NONE, + { "Device Manufacturer Id", "scsi_mmc.adip.device_manufacturer_id", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_mmc_adip_media_type_id, - { "Media Type Id", "scsi.mmc.adip.media_type_id", FT_STRING, BASE_NONE, + { "Media Type Id", "scsi_mmc.adip.media_type_id", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_mmc_adip_product_revision_number, - { "Product Revision Number", "scsi.mmc.adip.product_revision_number", FT_UINT8, BASE_HEX, + { "Product Revision Number", "scsi_mmc.adip.product_revision_number", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_mmc_adip_number_of_physical_info, - { "Number of bytes of physical info", "scsi.mmc.adip.number_of_physical_info", FT_UINT8, BASE_HEX, + { "Number of bytes of physical info", "scsi_mmc.adip.number_of_physical_info", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_mmc_disc_num_layers, - { "Number of Layers", "scsi.mmc.disk.num_layers", FT_UINT8, BASE_DEC, + { "Number of Layers", "scsi_mmc.disk.num_layers", FT_UINT8, BASE_DEC, VALS(scsi_num_layers), 0x60, NULL, HFILL}}, { &hf_scsi_mmc_disc_track_path, - { "Track Path", "scsi.mmc.disk.track_path", FT_BOOLEAN, 8, + { "Track Path", "scsi_mmc.disk.track_path", FT_BOOLEAN, 8, TFS(&scsi_track_path), 0x10, NULL, HFILL}}, }; diff --git a/epan/dissectors/packet-scsi-osd.c b/epan/dissectors/packet-scsi-osd.c index d4de87aade..f5978682e2 100644 --- a/epan/dissectors/packet-scsi-osd.c +++ b/epan/dissectors/packet-scsi-osd.c @@ -2950,253 +2950,253 @@ proto_register_scsi_osd(void) { static hf_register_info hf[] = { { &hf_scsi_osd_opcode, - {"OSD Opcode", "scsi.osd.opcode", FT_UINT8, BASE_HEX, + {"OSD Opcode", "scsi_osd.opcode", FT_UINT8, BASE_HEX, VALS (scsi_osd_vals), 0x0, NULL, HFILL}}, { &hf_scsi_osd_add_cdblen, - {"Additional CDB Length", "scsi.osd.addcdblen", FT_UINT8, BASE_DEC, + {"Additional CDB Length", "scsi_osd.addcdblen", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_svcaction, - {"Service Action", "scsi.osd.svcaction", FT_UINT16, BASE_HEX, + {"Service Action", "scsi_osd.svcaction", FT_UINT16, BASE_HEX, VALS(scsi_osd_svcaction_vals), 0x0, NULL, HFILL}}, { &hf_scsi_osd_option, - {"Options Byte", "scsi.osd.option", FT_UINT8, BASE_HEX, + {"Options Byte", "scsi_osd.option", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_option_dpo, - {"DPO", "scsi.osd.option.dpo", FT_BOOLEAN, 8, + {"DPO", "scsi_osd.option.dpo", FT_BOOLEAN, 8, TFS(&option_dpo_tfs), 0x10, NULL, HFILL}}, { &hf_scsi_osd_option_fua, - {"FUA", "scsi.osd.option.fua", FT_BOOLEAN, 8, + {"FUA", "scsi_osd.option.fua", FT_BOOLEAN, 8, TFS(&option_fua_tfs), 0x08, NULL, HFILL}}, { &hf_scsi_osd_getsetattrib, - {"GET/SET CDBFMT", "scsi.osd.getset", FT_UINT8, BASE_HEX, + {"GET/SET CDBFMT", "scsi_osd.getset", FT_UINT8, BASE_HEX, VALS(scsi_osd_getsetattrib_vals), 0x30, NULL, HFILL}}, { &hf_scsi_osd_timestamps_control, - {"Timestamps Control", "scsi.osd.timestamps_control", FT_UINT8, BASE_HEX, + {"Timestamps Control", "scsi_osd.timestamps_control", FT_UINT8, BASE_HEX, VALS(scsi_osd_timestamps_control_vals), 0x0, NULL, HFILL}}, { &hf_scsi_osd_formatted_capacity, - {"Formatted Capacity", "scsi.osd.formatted_capacity", FT_UINT64, BASE_DEC, + {"Formatted Capacity", "scsi_osd.formatted_capacity", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_get_attributes_page, - {"Get Attributes Page", "scsi.osd.get_attributes_page", FT_UINT32, BASE_HEX, + {"Get Attributes Page", "scsi_osd.get_attributes_page", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_get_attributes_list_length, - {"Get Attributes List Length", "scsi.osd.get_attributes_list_length", FT_UINT32, BASE_HEX, + {"Get Attributes List Length", "scsi_osd.get_attributes_list_length", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_get_attributes_list_offset, - {"Get Attributes List Offset", "scsi.osd.get_attributes_list_offset", FT_UINT32, BASE_HEX, + {"Get Attributes List Offset", "scsi_osd.get_attributes_list_offset", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_set_attributes_list_length, - {"Set Attributes List Length", "scsi.osd.set_attributes_list_length", FT_UINT32, BASE_HEX, + {"Set Attributes List Length", "scsi_osd.set_attributes_list_length", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_set_attributes_list_offset, - {"Set Attributes List Offset", "scsi.osd.set_attributes_list_offset", FT_UINT32, BASE_HEX, + {"Set Attributes List Offset", "scsi_osd.set_attributes_list_offset", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_get_attributes_allocation_length, - {"Get Attributes Allocation Length", "scsi.osd.get_attributes_allocation_length", FT_UINT32, BASE_HEX, + {"Get Attributes Allocation Length", "scsi_osd.get_attributes_allocation_length", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_retrieved_attributes_offset, - {"Retrieved Attributes Offset", "scsi.osd.retrieved_attributes_offset", FT_UINT32, BASE_HEX, + {"Retrieved Attributes Offset", "scsi_osd.retrieved_attributes_offset", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_set_attributes_page, - {"Set Attributes Page", "scsi.osd.set_attributes_page", FT_UINT32, BASE_HEX, + {"Set Attributes Page", "scsi_osd.set_attributes_page", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_set_attribute_length, - {"Set Attribute Length", "scsi.osd.set_attribute_length", FT_UINT32, BASE_HEX, + {"Set Attribute Length", "scsi_osd.set_attribute_length", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_set_attribute_number, - {"Set Attribute Number", "scsi.osd.set_attribute_number", FT_UINT32, BASE_HEX, + {"Set Attribute Number", "scsi_osd.set_attribute_number", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_set_attributes_offset, - {"Set Attributes Offset", "scsi.osd.set_attributes_offset", FT_UINT32, BASE_HEX, + {"Set Attributes Offset", "scsi_osd.set_attributes_offset", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_osd_capability_format, - {"Capability Format", "scsi.osd.capability_format", FT_UINT8, BASE_HEX, + {"Capability Format", "scsi_osd.capability_format", FT_UINT8, BASE_HEX, VALS(scsi_osd_capability_format_vals), 0x0f, NULL, HFILL}}, { &hf_scsi_osd_key_version, - {"Key Version", "scsi.osd.key_version", FT_UINT8, BASE_HEX, + {"Key Version", "scsi_osd.key_version", FT_UINT8, BASE_HEX, NULL, 0xf0, NULL, HFILL}}, { &hf_scsi_osd_icva, - {"Integrity Check Value Algorithm", "scsi.osd.icva", FT_UINT8, BASE_HEX, + {"Integrity Check Value Algorithm", "scsi_osd.icva", FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL}}, { &hf_scsi_osd_security_method, - {"Security Method", "scsi.osd.security_method", FT_UINT8, BASE_HEX, + {"Security Method", "scsi_osd.security_method", FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL}}, { &hf_scsi_osd_capability_expiration_time, - {"Capability Expiration Time", "scsi.osd.capability_expiration_time", FT_BYTES, BASE_NONE, + {"Capability Expiration Time", "scsi_osd.capability_expiration_time", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_audit, - {"Audit", "scsi.osd.audit", FT_BYTES, BASE_NONE, + {"Audit", "scsi_osd.audit", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_capability_discriminator, - {"Capability Discriminator", "scsi.osd.capability_descriminator", FT_BYTES, BASE_NONE, + {"Capability Discriminator", "scsi_osd.capability_descriminator", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_object_created_time, - {"Object Created Time", "scsi.osd.object_created_time", FT_BYTES, BASE_NONE, + {"Object Created Time", "scsi_osd.object_created_time", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_object_type, - {"Object Type", "scsi.osd.object_type", FT_UINT8, BASE_HEX, + {"Object Type", "scsi_osd.object_type", FT_UINT8, BASE_HEX, VALS(scsi_osd_object_type_vals), 0, NULL, HFILL}}, { &hf_scsi_osd_permissions, - {"Permissions", "scsi.osd.permissions", FT_UINT16, BASE_HEX, + {"Permissions", "scsi_osd.permissions", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_permissions_read, - {"READ", "scsi.osd.permissions.read", FT_BOOLEAN, 16, + {"READ", "scsi_osd.permissions.read", FT_BOOLEAN, 16, TFS(&permissions_read_tfs), 0x8000, NULL, HFILL}}, { &hf_scsi_osd_permissions_write, - {"WRITE", "scsi.osd.permissions.write", FT_BOOLEAN, 16, + {"WRITE", "scsi_osd.permissions.write", FT_BOOLEAN, 16, TFS(&permissions_write_tfs), 0x4000, NULL, HFILL}}, { &hf_scsi_osd_permissions_get_attr, - {"GET_ATTR", "scsi.osd.permissions.get_attr", FT_BOOLEAN, 16, + {"GET_ATTR", "scsi_osd.permissions.get_attr", FT_BOOLEAN, 16, TFS(&permissions_get_attr_tfs), 0x2000, NULL, HFILL}}, { &hf_scsi_osd_permissions_set_attr, - {"SET_ATTR", "scsi.osd.permissions.set_attr", FT_BOOLEAN, 16, + {"SET_ATTR", "scsi_osd.permissions.set_attr", FT_BOOLEAN, 16, TFS(&permissions_set_attr_tfs), 0x1000, NULL, HFILL}}, { &hf_scsi_osd_permissions_create, - {"CREATE", "scsi.osd.permissions.create", FT_BOOLEAN, 16, + {"CREATE", "scsi_osd.permissions.create", FT_BOOLEAN, 16, TFS(&permissions_create_tfs), 0x0800, NULL, HFILL}}, { &hf_scsi_osd_permissions_remove, - {"REMOVE", "scsi.osd.permissions.remove", FT_BOOLEAN, 16, + {"REMOVE", "scsi_osd.permissions.remove", FT_BOOLEAN, 16, TFS(&permissions_remove_tfs), 0x0400, NULL, HFILL}}, { &hf_scsi_osd_permissions_obj_mgmt, - {"OBJ_MGMT", "scsi.osd.permissions.obj_mgmt", FT_BOOLEAN, 16, + {"OBJ_MGMT", "scsi_osd.permissions.obj_mgmt", FT_BOOLEAN, 16, TFS(&permissions_obj_mgmt_tfs), 0x0200, NULL, HFILL}}, { &hf_scsi_osd_permissions_append, - {"APPEND", "scsi.osd.permissions.append", FT_BOOLEAN, 16, + {"APPEND", "scsi_osd.permissions.append", FT_BOOLEAN, 16, TFS(&permissions_append_tfs), 0x0100, NULL, HFILL}}, { &hf_scsi_osd_permissions_dev_mgmt, - {"DEV_MGMT", "scsi.osd.permissions.dev_mgmt", FT_BOOLEAN, 16, + {"DEV_MGMT", "scsi_osd.permissions.dev_mgmt", FT_BOOLEAN, 16, TFS(&permissions_dev_mgmt_tfs), 0x0080, NULL, HFILL}}, { &hf_scsi_osd_permissions_global, - {"GLOBAL", "scsi.osd.permissions.global", FT_BOOLEAN, 16, + {"GLOBAL", "scsi_osd.permissions.global", FT_BOOLEAN, 16, TFS(&permissions_global_tfs), 0x0040, NULL, HFILL}}, { &hf_scsi_osd_permissions_pol_sec, - {"POL/SEC", "scsi.osd.permissions.pol_sec", FT_BOOLEAN, 16, + {"POL/SEC", "scsi_osd.permissions.pol_sec", FT_BOOLEAN, 16, TFS(&permissions_pol_sec_tfs), 0x0020, NULL, HFILL}}, { &hf_scsi_osd_object_descriptor_type, - {"Object Descriptor Type", "scsi.osd.object_descriptor_type", FT_UINT8, BASE_HEX, + {"Object Descriptor Type", "scsi_osd.object_descriptor_type", FT_UINT8, BASE_HEX, VALS(scsi_osd_object_descriptor_type_vals), 0xf0, NULL, HFILL}}, { &hf_scsi_osd_object_descriptor, - {"Object Descriptor", "scsi.osd.object_descriptor", FT_BYTES, BASE_NONE, + {"Object Descriptor", "scsi_osd.object_descriptor", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_ricv, - {"Request Integrity Check value", "scsi.osd.ricv", FT_BYTES, BASE_NONE, + {"Request Integrity Check value", "scsi_osd.ricv", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_request_nonce, - {"Request Nonce", "scsi.osd.request_nonce", FT_BYTES, BASE_NONE, + {"Request Nonce", "scsi_osd.request_nonce", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_diicvo, - {"Data-In Integrity Check Value Offset", "scsi.osd.diicvo", FT_UINT32, BASE_DEC, + {"Data-In Integrity Check Value Offset", "scsi_osd.diicvo", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_doicvo, - {"Data-Out Integrity Check Value Offset", "scsi.osd.doicvo", FT_UINT32, BASE_DEC, + {"Data-Out Integrity Check Value Offset", "scsi_osd.doicvo", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_requested_partition_id, - {"Requested Partition Id", "scsi.osd.requested_partition_id", FT_UINT64, BASE_HEX, + {"Requested Partition Id", "scsi_osd.requested_partition_id", FT_UINT64, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_sortorder, - {"Sort Order", "scsi.osd.sort_order", FT_UINT8, BASE_DEC, + {"Sort Order", "scsi_osd.sort_order", FT_UINT8, BASE_DEC, VALS(scsi_osd_sort_order_vals), 0x0f, NULL, HFILL}}, { &hf_scsi_osd_partition_id, - {"Partition Id", "scsi.osd.partition_id", FT_UINT64, BASE_HEX, + {"Partition Id", "scsi_osd.partition_id", FT_UINT64, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_list_identifier, - {"List Identifier", "scsi.osd.list_identifier", FT_UINT32, BASE_DEC, + {"List Identifier", "scsi_osd.list_identifier", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_allocation_length, - {"Allocation Length", "scsi.osd.allocation_length", FT_UINT64, BASE_DEC, + {"Allocation Length", "scsi_osd.allocation_length", FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_length, - {"Length", "scsi.osd.length", FT_UINT64, BASE_DEC, + {"Length", "scsi_osd.length", FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_starting_byte_address, - {"Starting Byte Address", "scsi.osd.starting_byte_address", FT_UINT64, BASE_DEC, + {"Starting Byte Address", "scsi_osd.starting_byte_address", FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_initial_object_id, - {"Initial Object Id", "scsi.osd.initial_object_id", FT_BYTES, BASE_NONE, + {"Initial Object Id", "scsi_osd.initial_object_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_additional_length, - {"Additional Length", "scsi.osd.additional_length", FT_UINT64, BASE_DEC, + {"Additional Length", "scsi_osd.additional_length", FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_continuation_object_id, - {"Continuation Object Id", "scsi.osd.continuation_object_id", FT_BYTES, BASE_NONE, + {"Continuation Object Id", "scsi_osd.continuation_object_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_user_object_id, - {"User Object Id", "scsi.osd.user_object_id", FT_BYTES, BASE_NONE, + {"User Object Id", "scsi_osd.user_object_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_list_flags_lstchg, - {"LSTCHG", "scsi.osd.list.lstchg", FT_BOOLEAN, 8, + {"LSTCHG", "scsi_osd.list.lstchg", FT_BOOLEAN, 8, TFS(&list_lstchg_tfs), 0x02, NULL, HFILL}}, { &hf_scsi_osd_list_flags_root, - {"ROOT", "scsi.osd.list.root", FT_BOOLEAN, 8, + {"ROOT", "scsi_osd.list.root", FT_BOOLEAN, 8, TFS(&list_root_tfs), 0x01, NULL, HFILL}}, { &hf_scsi_osd_requested_user_object_id, - {"Requested User Object Id", "scsi.osd.requested_user_object_id", FT_BYTES, BASE_NONE, + {"Requested User Object Id", "scsi_osd.requested_user_object_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_number_of_user_objects, - {"Number Of User Objects", "scsi.osd.number_of_user_objects", FT_UINT16, BASE_DEC, + {"Number Of User Objects", "scsi_osd.number_of_user_objects", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_key_to_set, - {"Key to Set", "scsi.osd.key_to_set", FT_UINT8, BASE_DEC, + {"Key to Set", "scsi_osd.key_to_set", FT_UINT8, BASE_DEC, VALS(key_to_set_vals), 0x03, NULL, HFILL}}, { &hf_scsi_osd_set_key_version, - {"Key Version", "scsi.osd.set_key_version", FT_UINT8, BASE_DEC, + {"Key Version", "scsi_osd.set_key_version", FT_UINT8, BASE_DEC, NULL, 0x0f, NULL, HFILL}}, { &hf_scsi_osd_key_identifier, - {"Key Identifier", "scsi.osd.key_identifier", FT_BYTES, BASE_NONE, + {"Key Identifier", "scsi_osd.key_identifier", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_seed, - {"Seed", "scsi.osd.seed", FT_BYTES, BASE_NONE, + {"Seed", "scsi_osd.seed", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_collection_fcr, - {"FCR", "scsi.osd.collection.fcr", FT_BOOLEAN, 8, + {"FCR", "scsi_osd.collection.fcr", FT_BOOLEAN, 8, TFS(&collection_fcr_tfs), 0x01, NULL, HFILL}}, { &hf_scsi_osd_collection_object_id, - {"Collection Object Id", "scsi.osd.collection_object_id", FT_BYTES, BASE_NONE, + {"Collection Object Id", "scsi_osd.collection_object_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_requested_collection_object_id, - {"Requested Collection Object Id", "scsi.osd.requested_collection_object_id", FT_BYTES, BASE_NONE, + {"Requested Collection Object Id", "scsi_osd.requested_collection_object_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_partition_created_in, - { "Created In", "scsi.osd.partition.created_in", FT_FRAMENUM, BASE_NONE, + { "Created In", "scsi_osd.partition.created_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "The frame this partition was created", HFILL }}, { &hf_scsi_osd_partition_removed_in, - { "Removed In", "scsi.osd.partition.removed_in", FT_FRAMENUM, BASE_NONE, + { "Removed In", "scsi_osd.partition.removed_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, "The frame this partition was removed", HFILL }}, { &hf_scsi_osd_flush_scope, - {"Flush Scope", "scsi.osd.flush.scope", FT_UINT8, BASE_DEC, + {"Flush Scope", "scsi_osd.flush.scope", FT_UINT8, BASE_DEC, VALS(flush_scope_vals), 0x03, NULL, HFILL}}, { &hf_scsi_osd_flush_collection_scope, - {"Flush Collection Scope", "scsi.osd.flush_collection.scope", FT_UINT8, BASE_DEC, + {"Flush Collection Scope", "scsi_osd.flush_collection.scope", FT_UINT8, BASE_DEC, VALS(flush_collection_scope_vals), 0x03, NULL, HFILL}}, { &hf_scsi_osd_flush_partition_scope, - {"Flush Partition Scope", "scsi.osd.flush_partition.scope", FT_UINT8, BASE_DEC, + {"Flush Partition Scope", "scsi_osd.flush_partition.scope", FT_UINT8, BASE_DEC, VALS(flush_partition_scope_vals), 0x03, NULL, HFILL}}, { &hf_scsi_osd_flush_osd_scope, - {"Flush OSD Scope", "scsi.osd.flush_osd.scope", FT_UINT8, BASE_DEC, + {"Flush OSD Scope", "scsi_osd.flush_osd.scope", FT_UINT8, BASE_DEC, VALS(flush_osd_scope_vals), 0x03, NULL, HFILL}}, { &hf_scsi_osd_attributes_list_type, - {"Attributes List Type", "scsi.osd.attributes_list.type", FT_UINT8, BASE_HEX, + {"Attributes List Type", "scsi_osd.attributes_list.type", FT_UINT8, BASE_HEX, VALS(attributes_list_type_vals), 0x0f, NULL, HFILL}}, { &hf_scsi_osd_attributes_list_length, - {"Attributes List Length", "scsi.osd.attributes_list.length", FT_UINT16, BASE_DEC, + {"Attributes List Length", "scsi_osd.attributes_list.length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_attributes_page, - {"Attributes Page", "scsi.osd.attributes.page", FT_UINT32, BASE_HEX, + {"Attributes Page", "scsi_osd.attributes.page", FT_UINT32, BASE_HEX, VALS(attributes_page_vals), 0, NULL, HFILL}}, { &hf_scsi_osd_attribute_number, - {"Attribute Number", "scsi.osd.attribute.number", FT_UINT32, BASE_HEX, + {"Attribute Number", "scsi_osd.attribute.number", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_attribute_length, - {"Attribute Length", "scsi.osd.attribute.length", FT_UINT16, BASE_DEC, + {"Attribute Length", "scsi_osd.attribute.length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_osd_user_object_logical_length, - {"User Object Logical Length", "scsi.osd.user_object.logical_length", FT_UINT64, BASE_DEC, + {"User Object Logical Length", "scsi_osd.user_object.logical_length", FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL}}, }; diff --git a/epan/dissectors/packet-scsi-sbc.c b/epan/dissectors/packet-scsi-sbc.c index c62cf6bcfe..54c2875788 100644 --- a/epan/dissectors/packet-scsi-sbc.c +++ b/epan/dissectors/packet-scsi-sbc.c @@ -1791,277 +1791,277 @@ proto_register_scsi_sbc(void) { static hf_register_info hf[] = { { &hf_scsi_sbc_opcode, - {"SBC Opcode", "scsi.sbc.opcode", FT_UINT8, BASE_HEX, + {"SBC Opcode", "scsi_sbc.opcode", FT_UINT8, BASE_HEX, VALS (scsi_sbc_vals), 0x0, NULL, HFILL}}, { &hf_scsi_sbc_formatunit_flags, - {"Flags", "scsi.sbc.formatunit.flags", FT_UINT8, BASE_HEX, NULL, 0xF8, + {"Flags", "scsi_sbc.formatunit.flags", FT_UINT8, BASE_HEX, NULL, 0xF8, NULL, HFILL}}, { &hf_scsi_sbc_defect_list_format, - {"Defect List Format", "scsi.sbc.defect_list_format", FT_UINT8, BASE_DEC, + {"Defect List Format", "scsi_sbc.defect_list_format", FT_UINT8, BASE_DEC, NULL, 0x7, NULL, HFILL}}, { &hf_scsi_sbc_formatunit_vendor, - {"Vendor Unique", "scsi.sbc.formatunit.vendor", FT_UINT8, BASE_HEX, NULL, + {"Vendor Unique", "scsi_sbc.formatunit.vendor", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_formatunit_interleave, - {"Interleave", "scsi.sbc.formatunit.interleave", FT_UINT16, BASE_HEX, + {"Interleave", "scsi_sbc.formatunit.interleave", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_rdwr6_lba, - {"Logical Block Address (LBA)", "scsi.sbc.rdwr6.lba", FT_UINT24, BASE_DEC, + {"Logical Block Address (LBA)", "scsi_sbc.rdwr6.lba", FT_UINT24, BASE_DEC, NULL, 0x0FFFFF, NULL, HFILL}}, { &hf_scsi_sbc_rdwr6_xferlen, - {"Transfer Length", "scsi.sbc.rdwr6.xferlen", FT_UINT24, BASE_DEC, NULL, 0x0, + {"Transfer Length", "scsi_sbc.rdwr6.xferlen", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_rdwr10_lba, - {"Logical Block Address (LBA)", "scsi.sbc.rdwr10.lba", FT_UINT32, BASE_DEC, + {"Logical Block Address (LBA)", "scsi_sbc.rdwr10.lba", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_rdwr10_xferlen, - {"Transfer Length", "scsi.sbc.rdwr10.xferlen", FT_UINT16, BASE_DEC, NULL, + {"Transfer Length", "scsi_sbc.rdwr10.xferlen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_rdwr12_xferlen, - {"Transfer Length", "scsi.sbc.rdwr12.xferlen", FT_UINT32, BASE_DEC, NULL, + {"Transfer Length", "scsi_sbc.rdwr12.xferlen", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_rdwr16_lba, - {"Logical Block Address (LBA)", "scsi.sbc.rdwr16.lba", FT_BYTES, BASE_NONE, + {"Logical Block Address (LBA)", "scsi_sbc.rdwr16.lba", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_ssu_immed, - {"Immediate", "scsi.sbc.ssu.immediate", FT_BOOLEAN, 8, NULL, + {"Immediate", "scsi_sbc.ssu.immediate", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_sbc_ssu_pwr_cond, - {"Power Conditions", "scsi.sbc.ssu.pwr", FT_UINT8, BASE_HEX, + {"Power Conditions", "scsi_sbc.ssu.pwr", FT_UINT8, BASE_HEX, VALS (scsi_ssu_pwrcnd_val), 0xF0, NULL, HFILL}}, { &hf_scsi_sbc_ssu_loej, - {"LOEJ", "scsi.sbc.ssu.loej", FT_BOOLEAN, 8, NULL, 0x2, NULL, + {"LOEJ", "scsi_sbc.ssu.loej", FT_BOOLEAN, 8, NULL, 0x2, NULL, HFILL}}, { &hf_scsi_sbc_ssu_start, - {"Start", "scsi.sbc.ssu.start", FT_BOOLEAN, 8, NULL, 0x1, + {"Start", "scsi_sbc.ssu.start", FT_BOOLEAN, 8, NULL, 0x1, NULL, HFILL}}, { &hf_scsi_sbc_bytchk, - {"BYTCHK", "scsi.sbc.bytchk", FT_BOOLEAN, 8, + {"BYTCHK", "scsi_sbc.bytchk", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_sbc_verify_reladdr, - {"RELADDR", "scsi.sbc.verify.reladdr", FT_BOOLEAN, 8, NULL, + {"RELADDR", "scsi_sbc.verify.reladdr", FT_BOOLEAN, 8, NULL, 0x1, NULL, HFILL}}, { &hf_scsi_sbc_verify_lba, - {"LBA", "scsi.sbc.verify.lba", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, + {"LBA", "scsi_sbc.verify.lba", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_verify_lba64, - {"LBA", "scsi.sbc.verify.lba64", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, + {"LBA", "scsi_sbc.verify.lba64", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_verify_vlen, - {"Verification Length", "scsi.sbc.verify.vlen", FT_UINT16, + {"Verification Length", "scsi_sbc.verify.vlen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_verify_vlen32, - {"Verification Length", "scsi.sbc.verify.vlen32", FT_UINT32, + {"Verification Length", "scsi_sbc.verify.vlen32", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_wrverify_lba, - {"LBA", "scsi.sbc.wrverify.lba", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, + {"LBA", "scsi_sbc.wrverify.lba", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_wrverify_xferlen, - {"Transfer Length", "scsi.sbc.wrverify.xferlen", FT_UINT16, BASE_DEC, + {"Transfer Length", "scsi_sbc.wrverify.xferlen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_wrverify_lba64, - {"LBA", "scsi.sbc.wrverify.lba64", FT_UINT64, BASE_DEC, NULL, 0x0, + {"LBA", "scsi_sbc.wrverify.lba64", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_wrverify_xferlen32, - {"Transfer Length", "scsi.sbc.wrverify.xferlen32", FT_UINT32, + {"Transfer Length", "scsi_sbc.wrverify.xferlen32", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_readcapacity_flags, - {"Flags", "scsi.sbc.readcapacity.flags", FT_UINT8, BASE_HEX, NULL, 0x0, + {"Flags", "scsi_sbc.readcapacity.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_readcapacity_lba, - {"Logical Block Address", "scsi.sbc.readcapacity.lba", FT_UINT32, BASE_DEC, + {"Logical Block Address", "scsi_sbc.readcapacity.lba", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_readdefdata_flags, - {"Flags", "scsi.sbc.readdefdata.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.readdefdata.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_reassignblks_flags, - {"Flags", "scsi.sbc.reassignblks.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.reassignblks.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_read_flags, - {"Flags", "scsi.sbc.read.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.read.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_alloclen32, - {"Allocation Length", "scsi.sbc.alloclen32", FT_UINT32, BASE_DEC, + {"Allocation Length", "scsi_sbc.alloclen32", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_alloclen16, - {"Allocation Length", "scsi.sbc.alloclen16", FT_UINT16, BASE_DEC, + {"Allocation Length", "scsi_sbc.alloclen16", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_fuflags_fmtpinfo, - {"FMTPINFO", "scsi.sbc.format_unit.fmtpinfo", FT_BOOLEAN, 8, + {"FMTPINFO", "scsi_sbc.format_unit.fmtpinfo", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}}, { &hf_scsi_sbc_fuflags_rto_req, - {"RTO_REQ", "scsi.sbc.format_unit.rto_req", FT_BOOLEAN, 8, + {"RTO_REQ", "scsi_sbc.format_unit.rto_req", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}}, { &hf_scsi_sbc_fuflags_longlist, - {"LONGLIST", "scsi.sbc.format_unit.longlist", FT_BOOLEAN, 8, + {"LONGLIST", "scsi_sbc.format_unit.longlist", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}}, { &hf_scsi_sbc_fuflags_fmtdata, - {"FMTDATA", "scsi.sbc.format_unit.fmtdata", FT_BOOLEAN, 8, + {"FMTDATA", "scsi_sbc.format_unit.fmtdata", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_sbc_fuflags_cmplist, - {"CMPLIST", "scsi.sbc.format_unit.cmplist", FT_BOOLEAN, 8, + {"CMPLIST", "scsi_sbc.format_unit.cmplist", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}}, { &hf_scsi_sbc_prefetch_flags, - {"Flags", "scsi.sbc.prefetch.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.prefetch.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_prefetch_immed, - {"Immediate", "scsi.sbc.prefetch.immediate", FT_BOOLEAN, 8, NULL, + {"Immediate", "scsi_sbc.prefetch.immediate", FT_BOOLEAN, 8, NULL, 0x2, NULL, HFILL}}, { &hf_scsi_sbc_group, - {"Group", "scsi.sbc.group", FT_UINT8, BASE_HEX, NULL, + {"Group", "scsi_sbc.group", FT_UINT8, BASE_HEX, NULL, 0x1f, NULL, HFILL}}, { &hf_scsi_sbc_rdprotect, - {"RDPROTECT", "scsi.sbc.rdprotect", FT_UINT8, BASE_HEX, + {"RDPROTECT", "scsi_sbc.rdprotect", FT_UINT8, BASE_HEX, NULL, 0xe0, NULL, HFILL}}, { &hf_scsi_sbc_dpo, - {"DPO", "scsi.sbc.dpo", FT_BOOLEAN, 8, + {"DPO", "scsi_sbc.dpo", FT_BOOLEAN, 8, TFS(&dpo_tfs), 0x10, "DisablePageOut: Whether the device should cache the data or not", HFILL}}, { &hf_scsi_sbc_fua, - {"FUA", "scsi.sbc.fua", FT_BOOLEAN, 8, + {"FUA", "scsi_sbc.fua", FT_BOOLEAN, 8, TFS(&fua_tfs), 0x08, "ForceUnitAccess: Whether to allow reading from the cache or not", HFILL}}, { &hf_scsi_sbc_fua_nv, - {"FUA_NV", "scsi.sbc.fua_nv", FT_BOOLEAN, 8, + {"FUA_NV", "scsi_sbc.fua_nv", FT_BOOLEAN, 8, TFS(&fua_nv_tfs), 0x02, "ForceUnitAccess_NonVolatile: Whether to allow reading from non-volatile cache or not", HFILL}}, { &hf_scsi_sbc_pmi, - {"PMI", "scsi.sbc.pmi", FT_BOOLEAN, 8, + {"PMI", "scsi_sbc.pmi", FT_BOOLEAN, 8, TFS(&pmi_tfs), 0x01, "Partial Medium Indicator", HFILL}}, { &hf_scsi_sbc_pmi_flags, - {"PMI Flags", "scsi.sbc.pmi_flags", FT_UINT8, BASE_HEX, + {"PMI Flags", "scsi_sbc.pmi_flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_blocksize, - {"Block size in bytes", "scsi.sbc.blocksize", FT_UINT32, BASE_DEC, + {"Block size in bytes", "scsi_sbc.blocksize", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_returned_lba, - {"Returned LBA", "scsi.sbc.returned_lba", FT_UINT32, BASE_DEC, + {"Returned LBA", "scsi_sbc.returned_lba", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_req_plist, - {"REQ_PLIST", "scsi.sbc.req_plist", FT_BOOLEAN, 8, + {"REQ_PLIST", "scsi_sbc.req_plist", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_sbc_req_glist, - {"REQ_GLIST", "scsi.sbc.req_glist", FT_BOOLEAN, 8, + {"REQ_GLIST", "scsi_sbc.req_glist", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}}, { &hf_scsi_sbc_corrct, - {"CORRCT", "scsi.sbc.corrct", FT_BOOLEAN, 8, + {"CORRCT", "scsi_sbc.corrct", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_sbc_corrct_flags, - {"Flags", "scsi.sbc.corrct_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_sbc.corrct_flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_reassignblocks_longlba, - {"LongLBA", "scsi.sbc.reassignblocks.longlba", FT_BOOLEAN, 8, + {"LongLBA", "scsi_sbc.reassignblocks.longlba", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_sbc_reassignblocks_longlist, - {"LongList", "scsi.sbc.reassignblocks.longlist", FT_BOOLEAN, 8, + {"LongList", "scsi_sbc.reassignblocks.longlist", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_sbc_ssu_immed_flags, - {"Immed flags", "scsi.sbc.ssu.immed_flags", FT_UINT8, BASE_HEX, + {"Immed flags", "scsi_sbc.ssu.immed_flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_ssu_pwr_flags, - {"Pwr flags", "scsi.sbc.ssu.pwr_flags", FT_UINT8, BASE_HEX, + {"Pwr flags", "scsi_sbc.ssu.pwr_flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_synccache_flags, - {"Flags", "scsi.sbc.synccache.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.synccache.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_synccache_immed, - {"Immediate", "scsi.sbc.synccache.immediate", FT_BOOLEAN, 8, NULL, + {"Immediate", "scsi_sbc.synccache.immediate", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_sbc_synccache_sync_nv, - {"SYNC_NV", "scsi.sbc.synccache.sync_nv", FT_BOOLEAN, 8, NULL, + {"SYNC_NV", "scsi_sbc.synccache.sync_nv", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_sbc_vrprotect, - {"VRPROTECT", "scsi.sbc.vrprotect", FT_UINT8, BASE_HEX, + {"VRPROTECT", "scsi_sbc.vrprotect", FT_UINT8, BASE_HEX, NULL, 0xe0, NULL, HFILL}}, { &hf_scsi_sbc_verify_flags, - {"Flags", "scsi.sbc.verify_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_sbc.verify_flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_wrprotect, - {"WRPROTECT", "scsi.sbc.wrprotect", FT_UINT8, BASE_HEX, + {"WRPROTECT", "scsi_sbc.wrprotect", FT_UINT8, BASE_HEX, NULL, 0xe0, NULL, HFILL}}, { &hf_scsi_sbc_wrverify_flags, - {"Flags", "scsi.sbc.wrverify_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_sbc.wrverify_flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_writesame_flags, - {"Flags", "scsi.sbc.writesame_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_sbc.writesame_flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_anchor, - {"ANCHOR", "scsi.sbc.anchor", FT_BOOLEAN, 8, NULL, + {"ANCHOR", "scsi_sbc.anchor", FT_BOOLEAN, 8, NULL, 0x10, NULL, HFILL}}, { &hf_scsi_sbc_unmap, - {"UNMAP", "scsi.sbc.unmap", FT_BOOLEAN, 8, NULL, + {"UNMAP", "scsi_sbc.unmap", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}}, { &hf_scsi_sbc_pbdata, - {"PBDATA", "scsi.sbc.pbdata", FT_BOOLEAN, 8, NULL, + {"PBDATA", "scsi_sbc.pbdata", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_sbc_lbdata, - {"LBDATA", "scsi.sbc.lbdata", FT_BOOLEAN, 8, NULL, + {"LBDATA", "scsi_sbc.lbdata", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_sbc_xdread_flags, - {"Flags", "scsi.sbc.xdread.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.xdread.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_xorpinfo, - {"XORPINFO", "scsi.sbc.xorpinfo", FT_BOOLEAN, 8, NULL, + {"XORPINFO", "scsi_sbc.xorpinfo", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_sbc_disable_write, - {"DISABLE_WRITE", "scsi.sbc.disable_write", FT_BOOLEAN, 8, NULL, + {"DISABLE_WRITE", "scsi_sbc.disable_write", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_sbc_xdwrite_flags, - {"Flags", "scsi.sbc.xdwrite.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.xdwrite.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_xdwriteread_flags, - {"Flags", "scsi.sbc.xdwriteread.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.xdwriteread.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_xpwrite_flags, - {"Flags", "scsi.sbc.xpwrite.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, + {"Flags", "scsi_sbc.xpwrite.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_sbc_unmap_anchor, - {"ANCHOR", "scsi.sbc.unmap.anchor", FT_BOOLEAN, 8, NULL, + {"ANCHOR", "scsi_sbc.unmap.anchor", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_sbc_unmap_flags, - {"Flags", "scsi.sbc.unmap_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_sbc.unmap_flags", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_unmap_data_length, - {"Data Length", "scsi.sbc.unmap.data_length", FT_UINT16, BASE_DEC, + {"Data Length", "scsi_sbc.unmap.data_length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_unmap_block_descriptor_data_length, - {"Block Descriptor Data Length", "scsi.sbc.unmap.block_descriptor_data_length", FT_UINT16, BASE_DEC, + {"Block Descriptor Data Length", "scsi_sbc.unmap.block_descriptor_data_length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_unmap_lba, - {"LBA", "scsi.sbc.unmap.lba", FT_UINT64, BASE_DEC, + {"LBA", "scsi_sbc.unmap.lba", FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_unmap_num_blocks, - {"Num Blocks", "scsi.sbc.unmap.num_blocks", FT_UINT32, BASE_DEC, + {"Num Blocks", "scsi_sbc.unmap.num_blocks", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_ptype, - {"PTYPE", "scsi.sbc.ptype", FT_UINT8, BASE_DEC, + {"PTYPE", "scsi_sbc.ptype", FT_UINT8, BASE_DEC, VALS(scsi_ptype_val), 0x0e, NULL, HFILL}}, { &hf_scsi_sbc_prot_en, - {"PROT_EN", "scsi.sbc.prot_en", FT_BOOLEAN, 8, + {"PROT_EN", "scsi_sbc.prot_en", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_sbc_p_i_exponent, - {"P_I_EXPONENT", "scsi.sbc.p_i_exponent", FT_UINT8, BASE_DEC, + {"P_I_EXPONENT", "scsi_sbc.p_i_exponent", FT_UINT8, BASE_DEC, NULL, 0xf0, NULL, HFILL}}, { &hf_scsi_sbc_lbppbe, - {"LOGICAL_BLOCKS_PER_PHYSICAL_BLOCK_EXPONENT", "scsi.sbc.lbppbe", FT_UINT8, BASE_DEC, + {"LOGICAL_BLOCKS_PER_PHYSICAL_BLOCK_EXPONENT", "scsi_sbc.lbppbe", FT_UINT8, BASE_DEC, NULL, 0x0f, NULL, HFILL}}, { &hf_scsi_sbc_lbpme, - {"LBPME", "scsi.sbc.lbpme", FT_BOOLEAN, 8, + {"LBPME", "scsi_sbc.lbpme", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}}, { &hf_scsi_sbc_lbprz, - {"LBPRZ", "scsi.sbc.lbprz", FT_BOOLEAN, 8, + {"LBPRZ", "scsi_sbc.lbprz", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}}, { &hf_scsi_sbc_lalba, - {"LOWEST_ALIGNED_LBA", "scsi.sbc.lalba", FT_UINT16, BASE_DEC, + {"LOWEST_ALIGNED_LBA", "scsi_sbc.lalba", FT_UINT16, BASE_DEC, NULL, 0x3fff, NULL, HFILL}}, { &hf_scsi_sbc_get_lba_status_lba, - {"LBA", "scsi.sbc.get_lba_status.start_lba", FT_UINT64, BASE_DEC, + {"LBA", "scsi_sbc.get_lba_status.start_lba", FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_get_lba_status_data_length, - {"Data Length", "scsi.sbc.get_lba_status.data_length", FT_UINT32, BASE_DEC, + {"Data Length", "scsi_sbc.get_lba_status.data_length", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_get_lba_status_num_blocks, - {"Num Blocks", "scsi.sbc.get_lba_status.num_blocks", FT_UINT32, BASE_DEC, + {"Num Blocks", "scsi_sbc.get_lba_status.num_blocks", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_get_lba_status_provisioning_status, - {"Provisioning Type", "scsi.sbc.get_lba_status.provisioning_type", FT_UINT8, BASE_DEC, + {"Provisioning Type", "scsi_sbc.get_lba_status.provisioning_type", FT_UINT8, BASE_DEC, VALS(scsi_provisioning_type_val), 0x07, NULL, HFILL}}, }; diff --git a/epan/dissectors/packet-scsi-smc.c b/epan/dissectors/packet-scsi-smc.c index c91f9dc90e..e2ecd15b59 100644 --- a/epan/dissectors/packet-scsi-smc.c +++ b/epan/dissectors/packet-scsi-smc.c @@ -875,55 +875,55 @@ proto_register_scsi_smc(void) { static hf_register_info hf[] = { { &hf_scsi_smc_opcode, - {"SMC Opcode", "scsi.smc.opcode", FT_UINT8, BASE_HEX, + {"SMC Opcode", "scsi_smc.opcode", FT_UINT8, BASE_HEX, VALS (scsi_smc_vals), 0x0, NULL, HFILL}}, { &hf_scsi_smc_mta, - {"Medium Transport Address", "scsi.smc.mta", FT_UINT16, BASE_DEC, + {"Medium Transport Address", "scsi_smc.mta", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_sa, - {"Source Address", "scsi.smc.sa", FT_UINT16, BASE_DEC, + {"Source Address", "scsi_smc.sa", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_da, - {"Destination Address", "scsi.smc.da", FT_UINT16, BASE_DEC, + {"Destination Address", "scsi_smc.da", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_fda, - {"First Destination Address", "scsi.smc.fda", FT_UINT16, BASE_DEC, + {"First Destination Address", "scsi_smc.fda", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_sda, - {"Second Destination Address", "scsi.smc.sda", FT_UINT16, BASE_DEC, + {"Second Destination Address", "scsi_smc.sda", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_medium_flags, - {"Flags", "scsi.smc.medium_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_smc.medium_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_inv1, - {"INV1", "scsi.smc.inv1", FT_BOOLEAN, 8, + {"INV1", "scsi_smc.inv1", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_smc_inv2, - {"INV2", "scsi.smc.inv2", FT_BOOLEAN, 8, + {"INV2", "scsi_smc.inv2", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_smc_range_flags, - {"Flags", "scsi.smc.range_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_smc.range_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_fast, - {"FAST", "scsi.smc.fast", FT_BOOLEAN, 8, + {"FAST", "scsi_smc.fast", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_smc_range, - {"RANGE", "scsi.smc.range", FT_BOOLEAN, 8, + {"RANGE", "scsi_smc.range", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_smc_sea, - {"Starting Element Address", "scsi.smc.sea", FT_UINT16, BASE_DEC, + {"Starting Element Address", "scsi_smc.sea", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_num_elements, - {"Number of Elements", "scsi.smc.num_elements", FT_UINT16, BASE_DEC, + {"Number of Elements", "scsi_smc.num_elements", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_invert, - {"INVERT", "scsi.smc.invert", FT_BOOLEAN, 8, + {"INVERT", "scsi_smc.invert", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_smc_ea, - {"Element Address", "scsi.smc.ea", FT_UINT16, BASE_DEC, + {"Element Address", "scsi_smc.ea", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_smc_action_code, - {"Action Code", "scsi.smc.action_code", FT_UINT8, BASE_HEX, + {"Action Code", "scsi_smc.action_code", FT_UINT8, BASE_HEX, VALS(action_code_vals), 0x1f, NULL, HFILL}}, }; diff --git a/epan/dissectors/packet-scsi-ssc.c b/epan/dissectors/packet-scsi-ssc.c index fcefb2f3fc..984f0e2f4c 100644 --- a/epan/dissectors/packet-scsi-ssc.c +++ b/epan/dissectors/packet-scsi-ssc.c @@ -1227,128 +1227,128 @@ proto_register_scsi_ssc(void) { static hf_register_info hf[] = { { &hf_scsi_ssc_opcode, - {"SSC Opcode", "scsi.ssc.opcode", FT_UINT8, BASE_HEX, + {"SSC Opcode", "scsi_ssc.opcode", FT_UINT8, BASE_HEX, VALS (scsi_ssc_vals), 0x0, NULL, HFILL}}, { &hf_scsi_ssc_rdwr6_xferlen, - {"Transfer Length", "scsi.ssc.rdwr6.xferlen", FT_UINT24, BASE_DEC, NULL, 0x0, + {"Transfer Length", "scsi_ssc.rdwr6.xferlen", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_ver16_verlen, - {"Verification Length", "scsi.ssc.verify16.verify_len", FT_UINT24, BASE_DEC, NULL, 0x0, + {"Verification Length", "scsi_ssc.verify16.verify_len", FT_UINT24, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_locate10_loid, - {"Logical Object Identifier", "scsi.ssc.locate10.loid", FT_UINT32, BASE_DEC, NULL, 0x0, + {"Logical Object Identifier", "scsi_ssc.locate10.loid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_locate16_loid, - {"Logical Identifier", "scsi.ssc.locate16.loid", FT_UINT64, BASE_DEC, NULL, 0x0, + {"Logical Identifier", "scsi_ssc.locate16.loid", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_space6_count, - {"Count", "scsi.ssc.space6.count", FT_INT24, BASE_DEC, NULL, 0x0, + {"Count", "scsi_ssc.space6.count", FT_INT24, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_space6_code, - {"Code", "scsi.ssc.space6.code", FT_UINT8, BASE_HEX, + {"Code", "scsi_ssc.space6.code", FT_UINT8, BASE_HEX, VALS(space6_code_vals), 0x0f, NULL, HFILL}}, { &hf_scsi_ssc_space16_count, - {"Count", "scsi.ssc.space16.count", FT_UINT64, BASE_DEC, NULL, 0x0, + {"Count", "scsi_ssc.space16.count", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_rdwr10_xferlen, - {"Transfer Length", "scsi.ssc.rdwr10.xferlen", FT_UINT16, BASE_DEC, NULL, + {"Transfer Length", "scsi_ssc.rdwr10.xferlen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_erase_flags, - {"Flags", "scsi.ssc.erase_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_ssc.erase_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_fcs, - {"FCS", "scsi.ssc.fcs", FT_BOOLEAN, 8, + {"FCS", "scsi_ssc.fcs", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}}, { &hf_scsi_ssc_lcs, - {"LCS", "scsi.ssc.lcs", FT_BOOLEAN, 8, + {"LCS", "scsi_ssc.lcs", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_ssc_erase_immed, - {"IMMED", "scsi.ssc.erase_immed", FT_BOOLEAN, 8, + {"IMMED", "scsi_ssc.erase_immed", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_ssc_long, - {"LONG", "scsi.ssc.long", FT_BOOLEAN, 8, + {"LONG", "scsi_ssc.long", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_ssc_partition, - {"Partition", "scsi.ssc.partition", FT_UINT8, BASE_HEX, + {"Partition", "scsi_ssc.partition", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_lbi, - {"Logical Block Identifier", "scsi.ssc.lbi", FT_UINT64, BASE_HEX, + {"Logical Block Identifier", "scsi_ssc.lbi", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_verify, - {"VERIFY", "scsi.ssc.verify", FT_BOOLEAN, 8, + {"VERIFY", "scsi_ssc.verify", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_ssc_immed, - {"IMMED", "scsi.ssc.immed", FT_BOOLEAN, 8, + {"IMMED", "scsi_ssc.immed", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_ssc_formatmedium_flags, - {"Flags", "scsi.ssc.formatmedium_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_ssc.formatmedium_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_format, - {"Format", "scsi.ssc.format", FT_UINT8, BASE_HEX, + {"Format", "scsi_ssc.format", FT_UINT8, BASE_HEX, VALS(format_vals), 0x0f, NULL, HFILL}}, { &hf_scsi_ssc_loadunload_immed_flags, - {"Immed", "scsi.ssc.loadunload_immed_flags", FT_UINT8, BASE_HEX, + {"Immed", "scsi_ssc.loadunload_immed_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_loadunload_flags, - {"Flags", "scsi.ssc.loadunload_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_ssc.loadunload_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_hold, - {"HOLD", "scsi.ssc.hold", FT_BOOLEAN, 8, + {"HOLD", "scsi_ssc.hold", FT_BOOLEAN, 8, NULL, 0x08, NULL, HFILL}}, { &hf_scsi_ssc_eot, - {"EOT", "scsi.ssc.eot", FT_BOOLEAN, 8, + {"EOT", "scsi_ssc.eot", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_ssc_reten, - {"RETEN", "scsi.ssc.reten", FT_BOOLEAN, 8, + {"RETEN", "scsi_ssc.reten", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_ssc_load, - {"LOAD", "scsi.ssc.load", FT_BOOLEAN, 8, + {"LOAD", "scsi_ssc.load", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_ssc_locate_flags, - {"Flags", "scsi.ssc.locate_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_ssc.locate_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_bt, - {"BT", "scsi.ssc.bt", FT_BOOLEAN, 8, + {"BT", "scsi_ssc.bt", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_ssc_cp, - {"CP", "scsi.ssc.cp", FT_BOOLEAN, 8, + {"CP", "scsi_ssc.cp", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_ssc_dest_type, - {"Dest Type", "scsi.ssc.dest_type", FT_UINT8, BASE_HEX, + {"Dest Type", "scsi_ssc.dest_type", FT_UINT8, BASE_HEX, VALS(dest_type_vals), 0x18, NULL, HFILL}}, { &hf_scsi_ssc_bam_flags, - {"Flags", "scsi.ssc.bam_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_ssc.bam_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_bam, - {"BAM", "scsi.ssc.bam", FT_BOOLEAN, 8, + {"BAM", "scsi_ssc.bam", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_ssc_read6_flags, - {"Flags", "scsi.ssc.read6_flags", FT_UINT8, BASE_HEX, + {"Flags", "scsi_ssc.read6_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}}, { &hf_scsi_ssc_sili, - {"SILI", "scsi.ssc.sili", FT_BOOLEAN, 8, + {"SILI", "scsi_ssc.sili", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_ssc_fixed, - {"FIXED", "scsi.ssc.fixed", FT_BOOLEAN, 8, + {"FIXED", "scsi_ssc.fixed", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_ssc_bytord, - {"BYTORD", "scsi.ssc.bytord", FT_BOOLEAN, 8, + {"BYTORD", "scsi_ssc.bytord", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_ssc_bytcmp, - {"BYTCMP", "scsi.ssc.bytcmp", FT_BOOLEAN, 8, + {"BYTCMP", "scsi_ssc.bytcmp", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_ssc_verify16_immed, - {"IMMED", "scsi.ssc.verify16_immed", FT_BOOLEAN, 8, + {"IMMED", "scsi_ssc.verify16_immed", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_ssc_medium_type, - {"Medium Type", "scsi.ssc.medium_type", FT_BOOLEAN, 8, + {"Medium Type", "scsi_ssc.medium_type", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_ssc_media, - {"Media", "scsi.ssc.media", FT_BOOLEAN, 8, + {"Media", "scsi_ssc.media", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_ssc_capacity_prop_value, - {"Capacity Proportion Value", "scsi.ssc.cpv", FT_UINT16, BASE_DEC, + {"Capacity Proportion Value", "scsi_ssc.cpv", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, }; diff --git a/epan/dissectors/packet-scsi.c b/epan/dissectors/packet-scsi.c index 4580f0501e..80f8184797 100644 --- a/epan/dissectors/packet-scsi.c +++ b/epan/dissectors/packet-scsi.c @@ -5726,64 +5726,64 @@ proto_register_scsi(void) {"worm medium overwrite attempted", "scsi.log.ta.wmoa", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_sbc_treshold_exponent, - {"Treshold Exponent", "scsi.sbc.treshold_exponent", FT_UINT8, BASE_DEC, NULL, 0, + {"Treshold Exponent", "scsi_sbc.treshold_exponent", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_sbc_lbpu, - {"LBPU", "scsi.sbc.lbpu", FT_BOOLEAN, 8, NULL, 0x80, + {"LBPU", "scsi_sbc.lbpu", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}}, { &hf_scsi_sbc_lbpws, - {"LBPWS", "scsi.sbc.lbpws", FT_BOOLEAN, 8, NULL, 0x40, + {"LBPWS", "scsi_sbc.lbpws", FT_BOOLEAN, 8, NULL, 0x40, NULL, HFILL}}, { &hf_scsi_sbc_lbpws10, - {"LBPWS10", "scsi.sbc.lbpws10", FT_BOOLEAN, 8, NULL, 0x20, + {"LBPWS10", "scsi_sbc.lbpws10", FT_BOOLEAN, 8, NULL, 0x20, NULL, HFILL}}, { &hf_scsi_sbc_lbprz, - {"LBPRZ", "scsi.sbc.lbprz", FT_BOOLEAN, 8, NULL, 0x04, + {"LBPRZ", "scsi_sbc.lbprz", FT_BOOLEAN, 8, NULL, 0x04, NULL, HFILL}}, { &hf_scsi_sbc_anc_sup, - {"ANC_SUP", "scsi.sbc.anc_sup", FT_BOOLEAN, 8, NULL, 0x02, + {"ANC_SUP", "scsi_sbc.anc_sup", FT_BOOLEAN, 8, NULL, 0x02, NULL, HFILL}}, { &hf_scsi_sbc_dp, - {"DP", "scsi.sbc.dp", FT_BOOLEAN, 8, NULL, 0x01, + {"DP", "scsi_sbc.dp", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_sbc_ptype, - {"Provisioning Type", "scsi.sbc.ptype", FT_UINT8, BASE_DEC, VALS(provisioning_vals), 0x07, + {"Provisioning Type", "scsi_sbc.ptype", FT_UINT8, BASE_DEC, VALS(provisioning_vals), 0x07, NULL, HFILL}}, { &hf_scsi_block_limits_wsnz, - {"WSNZ", "scsi.sbc.bl.wsnz", FT_BOOLEAN, 8, NULL, 0x01, + {"WSNZ", "scsi_sbc.bl.wsnz", FT_BOOLEAN, 8, NULL, 0x01, NULL, HFILL}}, { &hf_scsi_block_limits_mcawl, - {"Maximum Compare And Write Length", "scsi.sbc.bl.mcawl", FT_UINT8, BASE_DEC, NULL, 0, + {"Maximum Compare And Write Length", "scsi_sbc.bl.mcawl", FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_block_limits_otlg, - {"Optimal Transfer Length Granularity", "scsi.sbc.bl.otlg", FT_UINT16, BASE_DEC, NULL, 0, + {"Optimal Transfer Length Granularity", "scsi_sbc.bl.otlg", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_block_limits_mtl, - {"Maximum Transfer Length", "scsi.sbc.bl.mtl", FT_UINT32, BASE_DEC, NULL, 0, + {"Maximum Transfer Length", "scsi_sbc.bl.mtl", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_block_limits_otl, - {"Optimal Transfer Length", "scsi.sbc.bl.otl", FT_UINT32, BASE_DEC, NULL, 0, + {"Optimal Transfer Length", "scsi_sbc.bl.otl", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_block_limits_mpl, - {"Optimal Prefetch/Xdread/Xdwrite Transfer Length", "scsi.sbc.bl.mpl", FT_UINT32, BASE_DEC, NULL, 0, + {"Optimal Prefetch/Xdread/Xdwrite Transfer Length", "scsi_sbc.bl.mpl", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_block_limits_mulc, - {"Maximum Unmap LBA Count", "scsi.sbc.bl.mulc", FT_UINT32, BASE_DEC, NULL, 0, + {"Maximum Unmap LBA Count", "scsi_sbc.bl.mulc", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_block_limits_mubdc, - {"Maximum Unmap Block Descriptor Count", "scsi.sbc.bl.mubdc", FT_UINT32, BASE_DEC, NULL, 0, + {"Maximum Unmap Block Descriptor Count", "scsi_sbc.bl.mubdc", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_block_limits_oug, - {"Optimal Unmap Block Granularity", "scsi.sbc.bl.oug", FT_UINT32, BASE_DEC, NULL, 0, + {"Optimal Unmap Block Granularity", "scsi_sbc.bl.oug", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_block_limits_ugavalid, - {"UGAVALID", "scsi.sbc.bl.ugavalid", FT_BOOLEAN, 8, NULL, 0x80, + {"UGAVALID", "scsi_sbc.bl.ugavalid", FT_BOOLEAN, 8, NULL, 0x80, NULL, HFILL}}, { &hf_scsi_block_limits_uga, - {"Unmap Granularity Alignment", "scsi.sbc.bl.uga", FT_UINT32, BASE_DEC, NULL, 0x7fffffff, + {"Unmap Granularity Alignment", "scsi_sbc.bl.uga", FT_UINT32, BASE_DEC, NULL, 0x7fffffff, NULL, HFILL}}, { &hf_scsi_block_limits_mwsl, - {"Maximum Write Same Length", "scsi.sbc.bl.mwsl", FT_UINT64, BASE_DEC, NULL, 0, + {"Maximum Write Same Length", "scsi_sbc.bl.mwsl", FT_UINT64, BASE_DEC, NULL, 0, NULL, HFILL}}, { &hf_scsi_modepage_ps, {"PS", "scsi.spc.modepage.ps", FT_BOOLEAN, 8, NULL, 0x80, -- cgit v1.2.1