summaryrefslogtreecommitdiff
path: root/epan/dissectors
diff options
context:
space:
mode:
authorMichael Mann <mmann78@netscape.net>2012-07-25 13:56:15 +0000
committerMichael Mann <mmann78@netscape.net>2012-07-25 13:56:15 +0000
commit32ef0a1a18182a749a98668d35d70e79143741c4 (patch)
tree05b7f6c329da3b3b8be2d5a2945bba837c0d0258 /epan/dissectors
parent2516627cd58fcedd143b88d891aa619b12a43279 (diff)
downloadwireshark-32ef0a1a18182a749a98668d35d70e79143741c4.tar.gz
Converted scsi dissectors display filter format from scsi.<protocol> to scsi_<protocol> (matching their registered filter name)
svn path=/trunk/; revision=43993
Diffstat (limited to 'epan/dissectors')
-rw-r--r--epan/dissectors/packet-scsi-mmc.c290
-rw-r--r--epan/dissectors/packet-scsi-osd.c162
-rw-r--r--epan/dissectors/packet-scsi-sbc.c182
-rw-r--r--epan/dissectors/packet-scsi-smc.c34
-rw-r--r--epan/dissectors/packet-scsi-ssc.c82
-rw-r--r--epan/dissectors/packet-scsi.c40
6 files changed, 395 insertions, 395 deletions
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,
generated by cgit v1.2.1 (git 2.18.0) at 2024-07-02 11:33:01 +0000