forked from osmocom/wireshark
4043 lines
141 KiB
C
4043 lines
141 KiB
C
/* packet-scsi-osd.c
|
|
* Dissector for the SCSI OSD (object based storage) commandset
|
|
*
|
|
* Ronnie sahlberg 2006
|
|
* Joe Breher 2006
|
|
* Javier Godoy 2013 (OSD-2 dissector)
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 2002 Gerald Combs
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <epan/packet.h>
|
|
#include <epan/conversation.h>
|
|
#include <epan/expert.h>
|
|
#include "packet-scsi.h"
|
|
#include "packet-scsi-osd.h"
|
|
|
|
void proto_register_scsi_osd(void);
|
|
|
|
static int proto_scsi_osd = -1;
|
|
int hf_scsi_osd_opcode = -1;
|
|
static int hf_scsi_osd_add_cdblen = -1;
|
|
static int hf_scsi_osd_svcaction = -1;
|
|
static int hf_scsi_osd_option = -1;
|
|
static int hf_scsi_osd_option_dpo = -1;
|
|
static int hf_scsi_osd_option_fua = -1;
|
|
static int hf_scsi_osd_getsetattrib = -1;
|
|
static int hf_scsi_osd_timestamps_control = -1;
|
|
static int hf_scsi_osd_formatted_capacity = -1;
|
|
static int hf_scsi_osd_get_attributes_page = -1;
|
|
static int hf_scsi_osd_get_attributes_allocation_length = -1;
|
|
static int hf_scsi_osd_get_attributes_list_length = -1;
|
|
static int hf_scsi_osd_get_attributes_list_offset = -1;
|
|
static int hf_scsi_osd_retrieved_attributes_offset = -1;
|
|
static int hf_scsi_osd_set_attributes_page = -1;
|
|
static int hf_scsi_osd_set_attribute_length = -1;
|
|
static int hf_scsi_osd_set_attribute_number = -1;
|
|
static int hf_scsi_osd_set_attributes_offset = -1;
|
|
static int hf_scsi_osd_set_attributes_list_length = -1;
|
|
static int hf_scsi_osd_set_attributes_list_offset = -1;
|
|
static int hf_scsi_osd_capability_format = -1;
|
|
static int hf_scsi_osd_key_version = -1;
|
|
static int hf_scsi_osd_icva = -1;
|
|
static int hf_scsi_osd_security_method = -1;
|
|
static int hf_scsi_osd_capability_expiration_time = -1;
|
|
static int hf_scsi_osd_audit = -1;
|
|
static int hf_scsi_osd_capability_discriminator = -1;
|
|
static int hf_scsi_osd_object_created_time = -1;
|
|
static int hf_scsi_osd_object_type = -1;
|
|
static int hf_scsi_osd_permissions = -1;
|
|
static int hf_scsi_osd_permissions_read = -1;
|
|
static int hf_scsi_osd_permissions_write = -1;
|
|
static int hf_scsi_osd_permissions_get_attr = -1;
|
|
static int hf_scsi_osd_permissions_set_attr = -1;
|
|
static int hf_scsi_osd_permissions_create = -1;
|
|
static int hf_scsi_osd_permissions_remove = -1;
|
|
static int hf_scsi_osd_permissions_obj_mgmt = -1;
|
|
static int hf_scsi_osd_permissions_append = -1;
|
|
static int hf_scsi_osd_permissions_dev_mgmt = -1;
|
|
static int hf_scsi_osd_permissions_global = -1;
|
|
static int hf_scsi_osd_permissions_pol_sec = -1;
|
|
static int hf_scsi_osd_object_descriptor_type = -1;
|
|
static int hf_scsi_osd_object_descriptor = -1;
|
|
static int hf_scsi_osd_ricv = -1;
|
|
static int hf_scsi_osd_request_nonce = -1;
|
|
static int hf_scsi_osd_diicvo = -1;
|
|
static int hf_scsi_osd_doicvo = -1;
|
|
static int hf_scsi_osd_requested_partition_id = -1;
|
|
static int hf_scsi_osd_sortorder = -1;
|
|
static int hf_scsi_osd_partition_id = -1;
|
|
static int hf_scsi_osd_list_identifier = -1;
|
|
static int hf_scsi_osd_allocation_length = -1;
|
|
static int hf_scsi_osd_length = -1;
|
|
static int hf_scsi_osd_starting_byte_address = -1;
|
|
static int hf_scsi_osd_initial_object_id = -1;
|
|
static int hf_scsi_osd_additional_length = -1;
|
|
static int hf_scsi_osd_continuation_object_id = -1;
|
|
static int hf_scsi_osd_list_flags_lstchg = -1;
|
|
static int hf_scsi_osd_list_flags_root = -1;
|
|
static int hf_scsi_osd_list_collection_flags_coltn = -1;
|
|
static int hf_scsi_osd_user_object_id = -1;
|
|
static int hf_scsi_osd_requested_user_object_id = -1;
|
|
static int hf_scsi_osd_number_of_user_objects = -1;
|
|
static int hf_scsi_osd_key_to_set = -1;
|
|
static int hf_scsi_osd_set_key_version = -1;
|
|
static int hf_scsi_osd_key_identifier = -1;
|
|
static int hf_scsi_osd_seed = -1;
|
|
static int hf_scsi_osd_collection_fcr = -1;
|
|
static int hf_scsi_osd_collection_object_id = -1;
|
|
static int hf_scsi_osd_requested_collection_object_id = -1;
|
|
static int hf_scsi_osd_partition_created_in = -1;
|
|
static int hf_scsi_osd_partition_removed_in = -1;
|
|
static int hf_scsi_osd_flush_scope = -1;
|
|
static int hf_scsi_osd_flush_collection_scope = -1;
|
|
static int hf_scsi_osd_flush_partition_scope = -1;
|
|
static int hf_scsi_osd_flush_osd_scope = -1;
|
|
static int hf_scsi_osd_attributes_list_type = -1;
|
|
static int hf_scsi_osd_attributes_list_length = -1;
|
|
static int hf_scsi_osd_attributes_page = -1;
|
|
static int hf_scsi_osd_attribute_number = -1;
|
|
static int hf_scsi_osd_attribute_length = -1;
|
|
static int hf_scsi_osd_attrval_user_object_logical_length = -1;
|
|
static int hf_scsi_osd_attrval_object_type = -1;
|
|
static int hf_scsi_osd_attrval_partition_id = -1;
|
|
static int hf_scsi_osd_attrval_object_id = -1;
|
|
static int hf_scsi_osd2_query_type = -1;
|
|
static int hf_scsi_osd2_query_entry_length = -1;
|
|
static int hf_scsi_osd2_query_attributes_page = -1;
|
|
static int hf_scsi_osd2_query_attribute_number = -1;
|
|
static int hf_scsi_osd2_query_minimum_attribute_value_length = -1;
|
|
static int hf_scsi_osd2_query_maximum_attribute_value_length = -1;
|
|
|
|
/* Fields that are defined in OSD-2 are prefixed with hf_scsi_osd2_ */
|
|
static int hf_scsi_osd2_attributes_list_length = -1;
|
|
static int hf_scsi_osd2_set_attribute_value = -1;
|
|
static int hf_scsi_osd2_isolation = -1;
|
|
static int hf_scsi_osd2_immed_tr = -1;
|
|
static int hf_scsi_osd2_list_attr = -1;
|
|
static int hf_scsi_osd2_object_descriptor_format = -1;
|
|
static int hf_scsi_osd2_matches_collection_object_id = -1;
|
|
static int hf_scsi_osd2_source_collection_object_id = -1;
|
|
static int hf_scsi_osd2_cdb_continuation_length = -1;
|
|
static int hf_scsi_osd2_cdb_continuation_format = -1;
|
|
static int hf_scsi_osd2_continued_service_action = -1;
|
|
static int hf_scsi_osd2_cdb_continuation_descriptor_type = -1;
|
|
static int hf_scsi_osd2_cdb_continuation_descriptor_pad_length = -1;
|
|
static int hf_scsi_osd2_cdb_continuation_descriptor_length = -1;
|
|
static int hf_scsi_osd2_remove_scope = -1;
|
|
|
|
static gint ett_osd_option = -1;
|
|
static gint ett_osd_partition = -1;
|
|
static gint ett_osd_attribute_parameters = -1;
|
|
static gint ett_osd_capability = -1;
|
|
static gint ett_osd_permission_bitmask = -1;
|
|
static gint ett_osd_security_parameters = -1;
|
|
static gint ett_osd_get_attributes = -1;
|
|
static gint ett_osd_set_attributes = -1;
|
|
static gint ett_osd_multi_object = -1;
|
|
static gint ett_osd_attribute = -1;
|
|
static gint ett_osd2_query_criteria_entry = -1;
|
|
|
|
static expert_field ei_osd_attr_unknown = EI_INIT;
|
|
static expert_field ei_osd2_invalid_offset = EI_INIT;
|
|
static expert_field ei_osd2_invalid_object_descriptor_format = EI_INIT;
|
|
static expert_field ei_osd_unknown_attributes_list_type = EI_INIT;
|
|
static expert_field ei_osd2_cdb_continuation_format_unknown = EI_INIT;
|
|
static expert_field ei_osd2_continued_service_action_mismatch = EI_INIT;
|
|
static expert_field ei_osd2_cdb_continuation_descriptor_type_unknown = EI_INIT;
|
|
static expert_field ei_osd2_cdb_continuation_descriptor_length_invalid = EI_INIT;
|
|
static expert_field ei_osd2_cdb_continuation_length_invalid = EI_INIT;
|
|
static expert_field ei_osd_attr_length_invalid = EI_INIT;
|
|
static expert_field ei_osd2_query_values_equal= EI_INIT;
|
|
|
|
#define PAGE_NUMBER_OBJECT 0x00000000
|
|
#define PAGE_NUMBER_PARTITION 0x30000000
|
|
#define PAGE_NUMBER_COLLECTION 0x60000000
|
|
#define PAGE_NUMBER_ROOT 0x90000000
|
|
|
|
|
|
/* There will be one such structure create for each conversation ontop of which
|
|
* there is an OSD session
|
|
*/
|
|
typedef struct _scsi_osd_conv_info_t {
|
|
wmem_tree_t *luns;
|
|
} scsi_osd_conv_info_t;
|
|
|
|
/* there will be one such structure created for each lun for each conversation
|
|
* that is handled by the OSD dissector
|
|
*/
|
|
struct _scsi_osd_lun_info_t {
|
|
wmem_tree_t *partitions;
|
|
};
|
|
|
|
typedef void (*scsi_osd_dissector_t)(tvbuff_t *tvb, packet_info *pinfo,
|
|
proto_tree *tree, guint offset,
|
|
gboolean isreq, gboolean iscdb,
|
|
guint32 payload_len, scsi_task_data_t *cdata,
|
|
scsi_osd_conv_info_t *conv_info,
|
|
scsi_osd_lun_info_t *lun_info
|
|
);
|
|
|
|
/* One such structure is created per conversation/lun/partition to
|
|
* keep track of when partitions are created/used/destroyed
|
|
*/
|
|
typedef struct _partition_info_t {
|
|
int created_in;
|
|
int removed_in;
|
|
} partition_info_t;
|
|
|
|
|
|
/* This is a set of extra data specific to OSD that we need to attach to every
|
|
* task.
|
|
*/
|
|
typedef struct _scsi_osd_extra_data_t {
|
|
guint16 svcaction;
|
|
guint8 gsatype;
|
|
union {
|
|
struct { /* gsatype: attribute list */
|
|
guint32 get_list_length;
|
|
guint32 get_list_offset;
|
|
guint32 get_list_allocation_length;
|
|
guint32 retrieved_list_offset;
|
|
guint32 set_list_length;
|
|
guint32 set_list_offset;
|
|
} al;
|
|
} u;
|
|
guint32 continuation_length;
|
|
gboolean osd2;
|
|
} scsi_osd_extra_data_t;
|
|
|
|
static proto_item*
|
|
dissect_osd_user_object_id(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* user object id */
|
|
proto_item *item;
|
|
item = proto_tree_add_item(tree, hf_scsi_osd_user_object_id, tvb, offset, 8, ENC_NA);
|
|
return item;
|
|
}
|
|
|
|
|
|
/*dissects an attribute that is defined as a pair of hf_index, length*/
|
|
static void
|
|
generic_attribute_dissector(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree,
|
|
scsi_osd_lun_info_t *lun_info _U_, const attribute_page_numbers_t *att)
|
|
{
|
|
proto_tree_add_item(tree, *att->hf_index, tvb, 0, att->expected_length, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static proto_item *
|
|
dissect_osd_partition_id(packet_info *pinfo, tvbuff_t *tvb, int offset,
|
|
proto_tree *tree, int hf_index,
|
|
scsi_osd_lun_info_t *lun_info, gboolean is_created,
|
|
gboolean is_removed);
|
|
|
|
static void
|
|
partition_id_attribute_dissector(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
scsi_osd_lun_info_t *lun_info, const attribute_page_numbers_t *att)
|
|
{
|
|
dissect_osd_partition_id(pinfo, tvb, 0, tree, *att->hf_index, lun_info, FALSE, FALSE);
|
|
}
|
|
|
|
static const attribute_page_numbers_t user_object_info_attributes[] = {
|
|
{0x82, "User object logical length", generic_attribute_dissector, &hf_scsi_osd_attrval_user_object_logical_length, 8},
|
|
{0, NULL, NULL, NULL, 0}
|
|
};
|
|
|
|
static const attribute_page_numbers_t current_command_attributes[] = {
|
|
{0x02, "Object Type", generic_attribute_dissector, &hf_scsi_osd_attrval_object_type, 1},
|
|
{0x03, "Partition ID", partition_id_attribute_dissector, &hf_scsi_osd_attrval_partition_id, 8},
|
|
{0x04, "Collection Object ID or User Object ID", generic_attribute_dissector, &hf_scsi_osd_attrval_object_id, 8},
|
|
{0, NULL, NULL, NULL, 0}
|
|
};
|
|
|
|
typedef struct _attribute_pages_t {
|
|
guint32 page;
|
|
const attribute_page_numbers_t *attributes;
|
|
} attribute_pages_t;
|
|
|
|
static const attribute_pages_t attribute_pages[] = {
|
|
{PAGE_NUMBER_OBJECT+1, user_object_info_attributes},
|
|
{0xFFFFFFFE, current_command_attributes},
|
|
{0, NULL}
|
|
};
|
|
|
|
static const value_string attributes_page_vals[] = {
|
|
{PAGE_NUMBER_OBJECT+0, "User Object Directory"},
|
|
{PAGE_NUMBER_OBJECT+1, "User Object Information"},
|
|
{PAGE_NUMBER_OBJECT+2, "User Object Quotas"},
|
|
{PAGE_NUMBER_OBJECT+3, "User Object Timestamps"},
|
|
{PAGE_NUMBER_OBJECT+4, "User Object Collections"},
|
|
{PAGE_NUMBER_OBJECT+5, "User Object Policy/Security"},
|
|
{PAGE_NUMBER_PARTITION, "Partition Directory"},
|
|
{PAGE_NUMBER_PARTITION+1, "Partition Information"},
|
|
{PAGE_NUMBER_PARTITION+2, "Partition Quotas"},
|
|
{PAGE_NUMBER_PARTITION+3, "Partition Timestamps"},
|
|
{PAGE_NUMBER_PARTITION+5, "Partition Policy/Security"},
|
|
{PAGE_NUMBER_COLLECTION, "Collection Directory"},
|
|
{PAGE_NUMBER_COLLECTION+1, "Collection Information"},
|
|
{PAGE_NUMBER_COLLECTION+2, "Collection Quotas"},
|
|
{PAGE_NUMBER_COLLECTION+4, "Collection Command Tracking"},
|
|
{PAGE_NUMBER_COLLECTION+5, "Collection Policy/Security"},
|
|
{PAGE_NUMBER_ROOT, "Root Directory"},
|
|
{PAGE_NUMBER_ROOT+1, "Root Information"},
|
|
{PAGE_NUMBER_ROOT+2, "Root Quotas"},
|
|
{PAGE_NUMBER_ROOT+3, "Root Timestamps"},
|
|
{PAGE_NUMBER_ROOT+5, "Root Policy/Security"},
|
|
{0xFFFFFFFE, "Current Command"},
|
|
{0xFFFFFFFF, "All attribute pages"},
|
|
{0, NULL}
|
|
};
|
|
value_string_ext attributes_page_vals_ext = VALUE_STRING_EXT_INIT(attributes_page_vals);
|
|
|
|
static const value_string attributes_list_type_vals[] = {
|
|
{0x01, "Retrieve attributes for this OSD object"},
|
|
{0x09, "Retrieve/Set attributes for this OSD object"},
|
|
{0x0f, "Retrieve attributes for a CREATE command"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static const value_string scsi_osd2_isolation_val[] = {
|
|
{0x00, "Default"},
|
|
{0x01, "None"},
|
|
{0x02, "Strict"},
|
|
{0x04, "Range"},
|
|
{0x05, "Functional"},
|
|
{0x07, "Vendor specific"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static const value_string scsi_osd2_object_descriptor_format_val[] = {
|
|
{0x01, "Partition ID"},
|
|
{0x02, "Partition ID followed by attribute parameters"},
|
|
{0x11, "Collection ID"},
|
|
{0x12, "Collection ID followed by attribute parameters"},
|
|
{0x21, "User Object ID"},
|
|
{0x22, "User Object ID followed by attribute parameters"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static const value_string scsi_osd2_remove_scope[] = {
|
|
{0x00, "Fail if there are collections or user objects in the partition"},
|
|
{0x01, "Remove collections and user objects in the partition"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static const value_string scsi_osd2_cdb_continuation_format_val[] = {
|
|
{0x01, "OSD2"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static const value_string scsi_osd2_cdb_continuation_descriptor_type_val[] = {
|
|
{0x0000, "No more continuation descriptors"},
|
|
{0x0001, "Scatter/gather list"},
|
|
{0x0002, "Query list"},
|
|
{0x0100, "User object"},
|
|
{0x0101, "Copy user object source"},
|
|
{0xFFEE, "Extension capabilities"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static const value_string scsi_osd2_query_type_vals[] = {
|
|
{0x00, "Match any query criteria"},
|
|
{0x01, "Match all query criteria"},
|
|
{0, NULL}
|
|
};
|
|
|
|
/* OSD2/3 helper functions */
|
|
|
|
static void
|
|
dissect_osd2_isolation(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* isolation */
|
|
proto_tree_add_item(tree, hf_scsi_osd2_isolation, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static void
|
|
dissect_osd2_list_attr(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* list_attr */
|
|
proto_tree_add_item(tree, hf_scsi_osd2_list_attr, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
|
|
/* used by dissect_osd_attributes_list, dissect_osd2_attribute_list_entry
|
|
and dissect_scsi_descriptor_snsinfo from packet-scsi.c*/
|
|
const attribute_page_numbers_t *
|
|
osd_lookup_attribute(guint32 page, guint32 number)
|
|
{
|
|
const attribute_pages_t *ap;
|
|
const attribute_page_numbers_t *apn;
|
|
|
|
/* find the proper attributes page */
|
|
apn = NULL;
|
|
for (ap=attribute_pages;ap->attributes;ap++) {
|
|
if (ap->page == page) {
|
|
apn = ap->attributes;
|
|
break;
|
|
}
|
|
}
|
|
if (!apn) return NULL;
|
|
|
|
/* find the specific attribute */
|
|
for (;apn->name;apn++) {
|
|
if (apn->number == number) {
|
|
break;
|
|
}
|
|
}
|
|
if (!apn->name) return NULL;
|
|
|
|
/* found it */
|
|
return apn;
|
|
}
|
|
|
|
/* OSD-1: 7.1.3.3, OSD2 7.1.4.3 list entry format */
|
|
static guint32
|
|
dissect_osd_attribute_list_entry(packet_info *pinfo, tvbuff_t *tvb,
|
|
proto_tree *tree, proto_item *item,
|
|
guint32 offset, scsi_osd_lun_info_t *lun_info,
|
|
gboolean osd2)
|
|
{
|
|
guint16 attribute_length;
|
|
guint32 page, number;
|
|
const attribute_page_numbers_t *apn;
|
|
|
|
/* attributes page */
|
|
page = tvb_get_ntohl(tvb, offset);
|
|
proto_tree_add_item(tree, hf_scsi_osd_attributes_page, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
/* attribute number */
|
|
number = tvb_get_ntohl(tvb, offset);
|
|
proto_tree_add_item(tree, hf_scsi_osd_attribute_number, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
if (osd2) {
|
|
/*6 reserved bytes*/
|
|
offset += 6;
|
|
}
|
|
|
|
/* attribute length */
|
|
attribute_length = tvb_get_ntohs(tvb, offset);
|
|
proto_tree_add_item(tree, hf_scsi_osd_attribute_length, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
offset += 2;
|
|
|
|
proto_item_append_text(item, " 0x%08x (%s)", page, val_to_str_ext_const(page, &attributes_page_vals_ext, "Unknown"));
|
|
proto_item_append_text(item, " 0x%08x", number);
|
|
apn= osd_lookup_attribute(page, number);
|
|
|
|
if (!apn) {
|
|
expert_add_info(pinfo, item, &ei_osd_attr_unknown);
|
|
proto_item_append_text(item, " (Unknown)");
|
|
} else {
|
|
proto_item_append_text(item, " (%s)", apn->name);
|
|
|
|
/* attribute value */
|
|
if (attribute_length) {
|
|
if (attribute_length != apn->expected_length) {
|
|
proto_tree_add_expert_format(tree, pinfo, &ei_osd_attr_length_invalid,
|
|
tvb, 0, attribute_length, "%s", apn->name);
|
|
} else {
|
|
tvbuff_t *next_tvb = tvb_new_subset_length(tvb, offset, attribute_length);
|
|
apn->dissector(next_tvb, pinfo, tree, lun_info, apn);
|
|
}
|
|
}
|
|
}
|
|
|
|
offset += attribute_length;
|
|
if (osd2 && (attribute_length&7)) {
|
|
/* 8-bit padding */
|
|
offset += 8-(attribute_length&7);
|
|
}
|
|
|
|
return offset;
|
|
}
|
|
|
|
/* OSD1: 7.1.3.1
|
|
OSD2: 7.1.4.1*/
|
|
static void
|
|
dissect_osd_attributes_list(packet_info *pinfo, tvbuff_t *tvb, int offset,
|
|
proto_tree *tree, scsi_osd_lun_info_t *lun_info,
|
|
gboolean osd2)
|
|
{
|
|
guint8 type;
|
|
guint32 length;
|
|
guint32 page, number;
|
|
int start_offset = offset;
|
|
proto_item *item, *list_type_item;
|
|
const attribute_page_numbers_t *apn;
|
|
|
|
/* list type */
|
|
type = tvb_get_guint8(tvb, offset)&0x0f;
|
|
list_type_item = proto_tree_add_item(tree, hf_scsi_osd_attributes_list_type, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
/* OSD-1: a reserved byte */
|
|
/* OSD-2: 3 reserved bytes */
|
|
offset += (osd2?3:1);
|
|
|
|
/* OSD-1: length (16 bit)
|
|
OSD-2: length (32 bit) */
|
|
if (osd2) {
|
|
length = tvb_get_ntohl(tvb, offset);
|
|
proto_tree_add_item(tree, hf_scsi_osd2_attributes_list_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
} else {
|
|
length = tvb_get_ntohs(tvb, offset);
|
|
proto_tree_add_item(tree, hf_scsi_osd_attributes_list_length, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
offset += 2;
|
|
}
|
|
|
|
/* if type is 1 length will be zero and we have to cycle over
|
|
* all remaining bytes. 7.1.3.1
|
|
*/
|
|
if (!osd2 && type == 1) {
|
|
length = tvb_reported_length_remaining(tvb, offset);
|
|
}
|
|
|
|
length += (osd2?8:4);
|
|
|
|
while ( (guint32)(offset-start_offset)<length ) {
|
|
proto_item *ti;
|
|
proto_tree *tt;
|
|
guint32 attribute_entry_length;
|
|
|
|
switch (type) {
|
|
case 0x01:
|
|
attribute_entry_length = 8;
|
|
break;
|
|
case 0x0f:
|
|
attribute_entry_length = 18+tvb_get_ntohs(tvb, offset+16);
|
|
break;
|
|
case 0x09:
|
|
if (osd2) {
|
|
attribute_entry_length = 16+tvb_get_ntohs(tvb, offset+14);
|
|
} else {
|
|
attribute_entry_length = 10+tvb_get_ntohs(tvb, offset+8);
|
|
}
|
|
break;
|
|
default:
|
|
expert_add_info(pinfo, list_type_item, &ei_osd_unknown_attributes_list_type);
|
|
return;
|
|
}
|
|
|
|
if ((guint32)(offset-start_offset)+attribute_entry_length>length) break;
|
|
tt = proto_tree_add_subtree(tree, tvb, offset, attribute_entry_length, ett_osd_attribute, &ti, "Attribute:");
|
|
|
|
switch (type) {
|
|
case 0x01: /* retrieving attributes 7.1.3.2 */
|
|
/* attributes page */
|
|
page = tvb_get_ntohl(tvb, offset);
|
|
proto_tree_add_item(tt, hf_scsi_osd_attributes_page, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
/* attribute number */
|
|
number = tvb_get_ntohl(tvb, offset);
|
|
item = proto_tree_add_item(tt, hf_scsi_osd_attribute_number, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
proto_item_append_text(ti, " 0x%08x (%s)", page, val_to_str_ext_const(page, &attributes_page_vals_ext, "Unknown"));
|
|
proto_item_append_text(ti, " 0x%08x", number);
|
|
|
|
/* find the proper attributes page */
|
|
apn = osd_lookup_attribute(page, number);
|
|
if (!apn) {
|
|
proto_item_append_text(ti, " (Unknown)");
|
|
proto_item_append_text(item, " (Unknown)");
|
|
} else {
|
|
proto_item_append_text(ti, " (%s)", apn->name);
|
|
proto_item_append_text(item, " (%s)", apn->name);
|
|
}
|
|
break;
|
|
case 0x0f: /* create attributes 7.1.3.4 */
|
|
/* user object id */
|
|
dissect_osd_user_object_id(tvb, offset, tt);
|
|
offset += 8;
|
|
/* fallthrough */
|
|
case 0x09: /* retrieved/set attributes OSD-1: 7.1.3.3 OSD-2: 7.1.4.3*/
|
|
offset = dissect_osd_attribute_list_entry(pinfo, tvb, tt, ti, offset, lun_info, osd2);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* OSD2 5.2.4 */
|
|
static void
|
|
dissect_osd_option(tvbuff_t *tvb, int offset, proto_tree *parent_tree)
|
|
{
|
|
proto_tree *tree;
|
|
proto_item *it;
|
|
guint8 option;
|
|
|
|
option = tvb_get_guint8(tvb, offset);
|
|
|
|
it = proto_tree_add_item(parent_tree, hf_scsi_osd_option, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
tree = proto_item_add_subtree(it, ett_osd_option);
|
|
|
|
proto_tree_add_item(tree, hf_scsi_osd_option_dpo, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
if (option&0x10) {
|
|
proto_item_append_text(tree, " DPO");
|
|
}
|
|
|
|
proto_tree_add_item(tree, hf_scsi_osd_option_fua, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
if (option&0x08) {
|
|
proto_item_append_text(tree, " FUA");
|
|
}
|
|
}
|
|
|
|
|
|
static const value_string scsi_osd_getsetattrib_vals[] = {
|
|
{1, "Set one attribute using CDB fields (OSD-2)"},
|
|
{2, "Get an attributes page and set an attribute value"},
|
|
{3, "Get and set attributes using a list"},
|
|
{0, NULL},
|
|
};
|
|
|
|
/* OSD2 5.2.2.1 */
|
|
static void
|
|
dissect_osd_getsetattrib(tvbuff_t *tvb, int offset, proto_tree *tree, scsi_task_data_t *cdata)
|
|
{
|
|
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
|
|
scsi_osd_extra_data_t *extra_data = (scsi_osd_extra_data_t *)cdata->itlq->extra_data;
|
|
extra_data->gsatype = (tvb_get_guint8(tvb, offset)>>4)&0x03;
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_getsetattrib, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static const value_string scsi_osd_timestamps_control_vals[] = {
|
|
{0x00, "Timestamps shall be updated"},
|
|
{0x7f, "Timestamps shall not be updated"},
|
|
{0, NULL},
|
|
};
|
|
|
|
/* OSD2 5.2.8 */
|
|
static void
|
|
dissect_osd_timestamps_control(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
proto_tree_add_item(tree, hf_scsi_osd_timestamps_control, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_formatted_capacity(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
proto_tree_add_item(tree, hf_scsi_osd_formatted_capacity, tvb, offset, 8, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static void
|
|
dissect_osd_offset(packet_info *pinfo, tvbuff_t *tvb, int offset,
|
|
proto_tree *tree, int field, guint32 *raw_value_ptr,
|
|
gboolean osd2)
|
|
{
|
|
/* dissects an OSD offset value, add proto item and updates *raw_value_ptr */
|
|
guint32 value = *raw_value_ptr;
|
|
|
|
if (value != 0xFFFFFFFF) {
|
|
if (!osd2) {
|
|
/*OSD-1: the exponent is an unsigned value (4.12.5)*/
|
|
value = (value & 0x0fffffff) << ((value>>28) & 0x0f);
|
|
value <<= 8;
|
|
} else {
|
|
/*OSD-2: the exponent is a signed value (4.15.5)*/
|
|
int exponent = (value>>28);
|
|
guint32 mantissa = (value&0x0FFFFFFF);
|
|
|
|
if (exponent&0x8) {
|
|
exponent = -(((~exponent)&7)+1);
|
|
if (exponent <=- 6 && mantissa != 0xFFFFFFF) {
|
|
proto_item *item;
|
|
item = proto_tree_add_item(tree, field, tvb, offset, 4, value);
|
|
expert_add_info(pinfo, item, &ei_osd2_invalid_offset);
|
|
*raw_value_ptr = 0xFFFFFFFF;
|
|
return;
|
|
}
|
|
}
|
|
value = mantissa << (exponent+8);
|
|
}
|
|
}
|
|
proto_tree_add_uint(tree, field, tvb, offset, 4, value);
|
|
*raw_value_ptr = value;
|
|
}
|
|
|
|
static int
|
|
dissect_osd_attribute_parameters(packet_info *pinfo, tvbuff_t *tvb, int offset, proto_tree *parent_tree, scsi_task_data_t *cdata)
|
|
{
|
|
guint8 gsatype = 0;
|
|
proto_tree *tree;
|
|
scsi_osd_extra_data_t *extra_data = NULL;
|
|
gboolean osd2;
|
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, offset, 28,
|
|
ett_osd_attribute_parameters, NULL, "Attribute Parameters");
|
|
|
|
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
|
|
extra_data = (scsi_osd_extra_data_t *)cdata->itlq->extra_data;
|
|
gsatype = extra_data->gsatype;
|
|
osd2 = extra_data->osd2;
|
|
} else {
|
|
return offset;
|
|
}
|
|
|
|
switch (gsatype) {
|
|
case 1: /* OSD-2 5.2.6.2 Set one attribute using CDB fields*/
|
|
if (osd2) {
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_attributes_page, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_attribute_number, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_attribute_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd2_set_attribute_value, tvb, offset, 18, ENC_NA);
|
|
offset += 18;
|
|
}
|
|
break;
|
|
case 2: /* 5.2.2.2 attribute page */
|
|
proto_tree_add_item(tree, hf_scsi_osd_get_attributes_page, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd_get_attributes_allocation_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd_retrieved_attributes_offset, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_attributes_page, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_attribute_number, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_attribute_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_attributes_offset, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
break;
|
|
case 3: /* 5.2.2.3 attribute list */
|
|
proto_tree_add_item(tree, hf_scsi_osd_get_attributes_list_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
extra_data->u.al.get_list_length = tvb_get_ntohl(tvb, offset);
|
|
offset += 4;
|
|
|
|
/* 4.12.5 */
|
|
extra_data->u.al.get_list_offset = tvb_get_ntohl(tvb, offset);
|
|
dissect_osd_offset(pinfo, tvb, offset, tree, hf_scsi_osd_get_attributes_list_offset,
|
|
&extra_data->u.al.get_list_offset, osd2);
|
|
if (extra_data->u.al.get_list_offset == 0xFFFFFFFF) {
|
|
extra_data->u.al.get_list_length = 0;
|
|
}
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_scsi_osd_get_attributes_allocation_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
extra_data->u.al.get_list_allocation_length = tvb_get_ntohl(tvb, offset);
|
|
offset += 4;
|
|
|
|
/* 4.12.5 */
|
|
extra_data->u.al.retrieved_list_offset = tvb_get_ntohl(tvb, offset);
|
|
dissect_osd_offset(pinfo, tvb, offset, tree, hf_scsi_osd_retrieved_attributes_offset,
|
|
&extra_data->u.al.retrieved_list_offset, osd2);
|
|
if (extra_data->u.al.retrieved_list_offset == 0xFFFFFFFF) {
|
|
extra_data->u.al.get_list_allocation_length = 0;
|
|
}
|
|
offset += 4;
|
|
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_attributes_list_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
extra_data->u.al.set_list_length = tvb_get_ntohl(tvb, offset);
|
|
offset += 4;
|
|
|
|
extra_data->u.al.set_list_offset = tvb_get_ntohl(tvb, offset);
|
|
dissect_osd_offset(pinfo, tvb, offset, tree, hf_scsi_osd_set_attributes_list_offset,
|
|
&extra_data->u.al.set_list_offset, osd2);
|
|
if (extra_data->u.al.set_list_offset == 0xFFFFFFFF) {
|
|
extra_data->u.al.set_list_length = 0;
|
|
}
|
|
offset += 4;
|
|
|
|
/* 4 reserved bytes */
|
|
offset += 4;
|
|
|
|
break;
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_attribute_data_out(packet_info *pinfo, tvbuff_t *tvb, int offset _U_,
|
|
proto_tree *tree, scsi_task_data_t *cdata,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
guint8 gsatype = 0;
|
|
proto_tree *subtree;
|
|
scsi_osd_extra_data_t *extra_data = NULL;
|
|
|
|
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
|
|
extra_data = (scsi_osd_extra_data_t *)cdata->itlq->extra_data;
|
|
gsatype = extra_data->gsatype;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
switch (gsatype) {
|
|
case 2: /* 5.2.2.2 attribute page */
|
|
/*qqq*/
|
|
break;
|
|
case 3: /* 5.2.2.3 attribute list */
|
|
if (extra_data->u.al.get_list_length) {
|
|
subtree = proto_tree_add_subtree(tree, tvb, extra_data->u.al.get_list_offset, extra_data->u.al.get_list_length,
|
|
ett_osd_get_attributes, NULL, "Get Attributes Segment");
|
|
dissect_osd_attributes_list(pinfo, tvb, extra_data->u.al.get_list_offset, subtree, lun_info, extra_data->osd2);
|
|
}
|
|
if (extra_data->u.al.set_list_length) {
|
|
subtree = proto_tree_add_subtree(tree, tvb, extra_data->u.al.set_list_offset, extra_data->u.al.set_list_length,
|
|
ett_osd_get_attributes, NULL, "Set Attributes Segment");
|
|
dissect_osd_attributes_list(pinfo, tvb, extra_data->u.al.set_list_offset, subtree, lun_info, extra_data->osd2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_attribute_data_in(packet_info *pinfo, tvbuff_t *tvb, int offset _U_, proto_tree *tree, scsi_task_data_t *cdata, scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
guint8 gsatype = 0;
|
|
scsi_osd_extra_data_t *extra_data = NULL;
|
|
|
|
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
|
|
extra_data = (scsi_osd_extra_data_t *)cdata->itlq->extra_data;
|
|
gsatype = extra_data->gsatype;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
switch (gsatype) {
|
|
case 2: /* 5.2.2.2 attribute page */
|
|
/*qqq*/
|
|
break;
|
|
case 3: /* 5.2.2.3 attribute list */
|
|
if (extra_data->u.al.get_list_allocation_length) {
|
|
dissect_osd_attributes_list(pinfo, tvb, extra_data->u.al.retrieved_list_offset, tree, lun_info, extra_data->osd2);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
dissect_osd2_cdb_continuation_length(packet_info *pinfo, tvbuff_t *tvb,
|
|
guint32 offset, proto_tree *tree,
|
|
scsi_task_data_t *cdata)
|
|
{
|
|
scsi_osd_extra_data_t *extra_data;
|
|
guint32 continuation_length;
|
|
proto_item *item;
|
|
|
|
continuation_length = tvb_get_ntohl(tvb, offset);
|
|
item = proto_tree_add_item(tree, hf_scsi_osd2_cdb_continuation_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
|
|
extra_data = (scsi_osd_extra_data_t *)cdata->itlq->extra_data;
|
|
extra_data->continuation_length = continuation_length;
|
|
}
|
|
if (continuation_length>0 && continuation_length<40) {
|
|
expert_add_info(pinfo, item, &ei_osd2_cdb_continuation_length_invalid);
|
|
}
|
|
}
|
|
|
|
static void dissect_osd2_query_list_descriptor(packet_info *pinfo, tvbuff_t *tvb, guint32 offset, proto_tree *tree, guint32 length) {
|
|
guint32 end = offset+length;
|
|
|
|
/* query type */
|
|
proto_tree_add_item(tree, hf_scsi_osd2_query_type, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/*query criteria entry*/
|
|
while (offset<end) {
|
|
guint32 page, number;
|
|
guint32 min_value_length, max_value_length;
|
|
guint32 min_value_offset, max_value_offset;
|
|
proto_item *item;
|
|
const attribute_page_numbers_t *apn;
|
|
|
|
/* 2 reserved bytes */
|
|
offset += 2;
|
|
|
|
/* query entry length */
|
|
proto_tree_add_item(tree, hf_scsi_osd2_query_entry_length, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
offset += 2;
|
|
|
|
/* query attributes page */
|
|
page = tvb_get_ntohl(tvb, offset);
|
|
proto_tree_add_item(tree, hf_scsi_osd2_query_attributes_page, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
/* query attributes number */
|
|
number = tvb_get_ntohl(tvb, offset);
|
|
item = proto_tree_add_item(tree, hf_scsi_osd2_query_attribute_number, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
apn = osd_lookup_attribute(page, number);
|
|
|
|
if (!apn) {
|
|
expert_add_info(pinfo, item, &ei_osd_attr_unknown);
|
|
proto_item_append_text(item, " (Unknown)");
|
|
} else {
|
|
proto_item_append_text(item, " (%s)", apn->name);
|
|
}
|
|
|
|
/* query minimum attribute value length */
|
|
proto_tree_add_item(tree, hf_scsi_osd2_query_minimum_attribute_value_length, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
min_value_length = tvb_get_ntohs(tvb, offset);
|
|
offset += 2;
|
|
|
|
/* query minimum attribute value */
|
|
/* if (apn && min_value_length) {
|
|
call_apn_dissector(tvb, pinfo, tree, lun_info, apn, offset, min_value_length);
|
|
} */
|
|
max_value_offset = offset;
|
|
offset += min_value_length;
|
|
|
|
/* query maximum attribute value length */
|
|
item = proto_tree_add_item(tree, hf_scsi_osd2_query_maximum_attribute_value_length, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
max_value_length = tvb_get_ntohs(tvb, offset);
|
|
offset += 2;
|
|
|
|
/* xxx query maximum attribute value */
|
|
/* if (apn && max_value_length) {
|
|
call_apn_dissector(tvb, pinfo, tree, lun_info, apn, offset, max_value_length);
|
|
} */
|
|
min_value_offset = offset;
|
|
offset += max_value_length;
|
|
|
|
/* test if min and max values are equal */
|
|
if (max_value_length == min_value_length) {
|
|
unsigned int i;
|
|
for (i=0; i<max_value_length; i++) {
|
|
if (tvb_get_guint8(tvb, max_value_offset+i) != tvb_get_guint8(tvb, min_value_offset+i)) return;
|
|
}
|
|
expert_add_info(pinfo, item, &ei_osd2_query_values_equal);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
dissect_osd2_cdb_continuation(packet_info *pinfo, tvbuff_t *tvb, guint32 offset,
|
|
proto_tree *tree, scsi_task_data_t *cdata)
|
|
{
|
|
scsi_osd_extra_data_t *extra_data = NULL;
|
|
proto_item *item;
|
|
guint8 format;
|
|
guint16 sa;
|
|
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
|
|
extra_data = (scsi_osd_extra_data_t *)cdata->itlq->extra_data;
|
|
}
|
|
if (!extra_data || extra_data->continuation_length<40) return;
|
|
|
|
/* cdb continuation format */
|
|
item = proto_tree_add_item(tree, hf_scsi_osd2_cdb_continuation_format, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
format = tvb_get_guint8(tvb, offset);
|
|
if (format != 0x01) {
|
|
expert_add_info(pinfo, item, &ei_osd2_cdb_continuation_format_unknown);
|
|
return;
|
|
}
|
|
offset += 1;
|
|
|
|
/* 1 reserved byte */
|
|
offset += 1;
|
|
|
|
/* continued service action */
|
|
item = proto_tree_add_item(tree, hf_scsi_osd2_continued_service_action, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
sa = tvb_get_ntohs(tvb, offset);
|
|
if (sa != extra_data->svcaction) {
|
|
expert_add_info(pinfo, item, &ei_osd2_continued_service_action_mismatch);
|
|
}
|
|
offset += 2;
|
|
|
|
/*4 reserved bytes and continuation integrity check value (32 bytes, not dissected)*/
|
|
offset += 36;
|
|
|
|
|
|
/* CDB continuation descriptors */
|
|
while (offset<extra_data->continuation_length) {
|
|
guint16 type;
|
|
guint32 length, padlen;
|
|
proto_item *item_type, *item_length;
|
|
|
|
/* descriptor type */
|
|
item_type= proto_tree_add_item(tree, hf_scsi_osd2_cdb_continuation_descriptor_type, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
type = tvb_get_ntohs(tvb, offset);
|
|
offset += 2;
|
|
|
|
/* 1 reserved byte*/
|
|
offset += 1;
|
|
|
|
/* descriptor pad length */
|
|
proto_tree_add_item(tree, hf_scsi_osd2_cdb_continuation_descriptor_pad_length, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
padlen = tvb_get_guint8(tvb, offset)&7;
|
|
offset += 1;
|
|
|
|
/* descriptor length */
|
|
item_length = proto_tree_add_item(tree, hf_scsi_osd2_cdb_continuation_descriptor_length, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
length = tvb_get_ntohl(tvb, offset);
|
|
offset += 4;
|
|
|
|
switch (type) {
|
|
case 0x0000: break;
|
|
case 0x0001: break;
|
|
case 0x0002: dissect_osd2_query_list_descriptor(pinfo, tvb, offset, tree, length);
|
|
case 0x0100: break;
|
|
case 0x0101: break;
|
|
case 0xFFEE: break;
|
|
default: expert_add_info(pinfo, item_type, &ei_osd2_cdb_continuation_descriptor_type_unknown);
|
|
}
|
|
|
|
if ((length+padlen)%8) {
|
|
expert_add_info(pinfo, item_length, &ei_osd2_cdb_continuation_descriptor_length_invalid);
|
|
return;
|
|
}
|
|
/* check for overflow */
|
|
if (offset + length + padlen > offset) {
|
|
offset += length+padlen;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static const value_string scsi_osd_capability_format_vals[] = {
|
|
{0x00, "No Capability"},
|
|
{0x01, "SCSI OSD Capabilities"},
|
|
{0, NULL},
|
|
};
|
|
static const value_string scsi_osd_object_type_vals[] = {
|
|
{0x01, "ROOT"},
|
|
{0x02, "PARTITION"},
|
|
{0x40, "COLLECTION"},
|
|
{0x80, "USER"},
|
|
{0, NULL},
|
|
};
|
|
static const value_string scsi_osd_object_descriptor_type_vals[] = {
|
|
{0, "NONE: the object descriptor field shall be ignored"},
|
|
{1, "U/C: a single collection or user object"},
|
|
{2, "PAR: a single partition, including partition zero"},
|
|
{0, NULL},
|
|
};
|
|
|
|
|
|
/* OSD 4.9.2.2.1 */
|
|
static void
|
|
dissect_osd_permissions(tvbuff_t *tvb, int offset, proto_tree *parent_tree)
|
|
{
|
|
proto_tree *tree = NULL;
|
|
proto_item *it = NULL;
|
|
guint16 permissions;
|
|
|
|
permissions = tvb_get_ntohs(tvb, offset);
|
|
|
|
if (parent_tree) {
|
|
it = proto_tree_add_item(parent_tree, hf_scsi_osd_permissions, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
tree = proto_item_add_subtree(it, ett_osd_permission_bitmask);
|
|
}
|
|
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_read, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x8000) {
|
|
proto_item_append_text(tree, " READ");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_write, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x4000) {
|
|
proto_item_append_text(tree, " WRITE");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_get_attr, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x2000) {
|
|
proto_item_append_text(tree, " GET_ATTR");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_set_attr, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x1000) {
|
|
proto_item_append_text(tree, " SET_ATTR");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_create, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x0800) {
|
|
proto_item_append_text(tree, " CREATE");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_remove, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x0400) {
|
|
proto_item_append_text(tree, " REMOVE");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_obj_mgmt, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x0200) {
|
|
proto_item_append_text(tree, " OBJ_MGMT");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_append, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x0100) {
|
|
proto_item_append_text(tree, " APPEND");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_dev_mgmt, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x0080) {
|
|
proto_item_append_text(tree, " DEV_MGMT");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_global, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x0040) {
|
|
proto_item_append_text(tree, " GLOBAL");
|
|
}
|
|
proto_tree_add_item(tree, hf_scsi_osd_permissions_pol_sec, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
if (permissions&0x0020) {
|
|
proto_item_append_text(tree, " POL/SEC");
|
|
}
|
|
}
|
|
|
|
/* OSD-1 4.9.2.2
|
|
OSD-2 4.11.2.2 */
|
|
static void
|
|
dissect_osd_capability(tvbuff_t *tvb, int offset, proto_tree *parent_tree)
|
|
{
|
|
proto_tree *tree;
|
|
guint8 format;
|
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, offset, 80,
|
|
ett_osd_capability, NULL, "Capability");
|
|
|
|
/* capability format */
|
|
proto_tree_add_item(tree, hf_scsi_osd_capability_format, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
format = tvb_get_guint8(tvb, offset)&0x0F;
|
|
offset += 1;
|
|
|
|
if (format != 1) return;
|
|
|
|
/* key version and icva */
|
|
proto_tree_add_item(tree, hf_scsi_osd_key_version, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
proto_tree_add_item(tree, hf_scsi_osd_icva, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
/* security method */
|
|
proto_tree_add_item(tree, hf_scsi_osd_security_method, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
/* a reserved byte */
|
|
offset += 1;
|
|
|
|
/* capability expiration time */
|
|
proto_tree_add_item(tree, hf_scsi_osd_capability_expiration_time, tvb, offset, 6, ENC_NA);
|
|
offset += 6;
|
|
|
|
/* audit */
|
|
proto_tree_add_item(tree, hf_scsi_osd_audit, tvb, offset, 20, ENC_NA);
|
|
offset += 20;
|
|
|
|
/* capability discriminator */
|
|
proto_tree_add_item(tree, hf_scsi_osd_capability_discriminator, tvb, offset, 12, ENC_NA);
|
|
offset += 12;
|
|
|
|
/* object created time */
|
|
proto_tree_add_item(tree, hf_scsi_osd_object_created_time, tvb, offset, 6, ENC_NA);
|
|
offset += 6;
|
|
|
|
/* object type */
|
|
proto_tree_add_item(tree, hf_scsi_osd_object_type, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
/* permission bitmask */
|
|
dissect_osd_permissions(tvb, offset, tree);
|
|
offset += 5;
|
|
|
|
/* a reserved byte */
|
|
offset += 1;
|
|
|
|
/* object descriptor type */
|
|
proto_tree_add_item(tree, hf_scsi_osd_object_descriptor_type, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
/* object descriptor */
|
|
proto_tree_add_item(tree, hf_scsi_osd_object_descriptor, tvb, offset, 24, ENC_NA);
|
|
/*offset += 24;*/
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
/* 5.2.6 */
|
|
static int
|
|
dissect_osd_security_parameters(tvbuff_t *tvb, int offset, proto_tree *parent_tree)
|
|
{
|
|
proto_tree *tree;
|
|
|
|
tree = proto_tree_add_subtree(parent_tree, tvb, offset, 40,
|
|
ett_osd_security_parameters, NULL, "Security Parameters");
|
|
|
|
/* request integrity check value */
|
|
proto_tree_add_item(tree, hf_scsi_osd_ricv, tvb, offset, 20, ENC_NA);
|
|
offset += 20;
|
|
|
|
/* request nonce */
|
|
proto_tree_add_item(tree, hf_scsi_osd_request_nonce, tvb, offset, 12, ENC_NA);
|
|
offset += 12;
|
|
|
|
/* data in integrity check value offset */
|
|
proto_tree_add_item(tree, hf_scsi_osd_diicvo, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
/* data out integrity check value offset */
|
|
proto_tree_add_item(tree, hf_scsi_osd_doicvo, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static void
|
|
dissect_osd_format_osd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info _U_)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 23 reserved bytes */
|
|
offset += 23;
|
|
|
|
/* formatted capacity */
|
|
dissect_osd_formatted_capacity(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 8 reserved bytes */
|
|
offset += 8;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for format osd */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for format osd */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static proto_item*
|
|
dissect_osd_partition_id(packet_info *pinfo, tvbuff_t *tvb, int offset,
|
|
proto_tree *tree, int hf_index,
|
|
scsi_osd_lun_info_t *lun_info, gboolean is_created,
|
|
gboolean is_removed)
|
|
{
|
|
proto_item *item = NULL;
|
|
guint32 partition_id[2];
|
|
|
|
/* partition id */
|
|
item = proto_tree_add_item(tree, hf_index, tvb, offset, 8, ENC_BIG_ENDIAN);
|
|
partition_id[0] = tvb_get_ntohl(tvb, offset);
|
|
partition_id[1] = tvb_get_ntohl(tvb, offset+4);
|
|
if (!partition_id[0] && !partition_id[1]) {
|
|
proto_item_append_text(item, " (ROOT partition)");
|
|
} else {
|
|
partition_info_t *part_info;
|
|
wmem_tree_key_t pikey[2];
|
|
proto_tree *partition_tree = NULL;
|
|
|
|
pikey[0].length = 2;
|
|
pikey[0].key = partition_id;
|
|
pikey[1].length = 0;
|
|
part_info = (partition_info_t *)wmem_tree_lookup32_array(lun_info->partitions, &pikey[0]);
|
|
if (!part_info) {
|
|
part_info = wmem_new(wmem_file_scope(), partition_info_t);
|
|
part_info->created_in = 0;
|
|
part_info->removed_in = 0;
|
|
|
|
pikey[0].length = 2;
|
|
pikey[0].key = partition_id;
|
|
pikey[1].length = 0;
|
|
wmem_tree_insert32_array(lun_info->partitions, &pikey[0], part_info);
|
|
}
|
|
if (is_created) {
|
|
part_info->created_in = pinfo->num;
|
|
}
|
|
if (is_removed) {
|
|
part_info->removed_in = pinfo->num;
|
|
}
|
|
if (item) {
|
|
partition_tree = proto_item_add_subtree(item, ett_osd_partition);
|
|
}
|
|
if (part_info->created_in) {
|
|
proto_item *tmp_item;
|
|
tmp_item = proto_tree_add_uint(partition_tree, hf_scsi_osd_partition_created_in, tvb, 0, 0, part_info->created_in);
|
|
proto_item_set_generated(tmp_item);
|
|
}
|
|
if (part_info->removed_in) {
|
|
proto_item *tmp_item;
|
|
tmp_item = proto_tree_add_uint(partition_tree, hf_scsi_osd_partition_removed_in, tvb, 0, 0, part_info->removed_in);
|
|
proto_item_set_generated(tmp_item);
|
|
}
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
dissect_osd_create_partition(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
gboolean osd2 = ((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->svcaction&0x80;
|
|
((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->osd2 = osd2;
|
|
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
if (osd2) dissect_osd2_isolation(tvb, offset, tree);
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* requested partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_requested_partition_id, lun_info, TRUE, FALSE);
|
|
offset += 8;
|
|
|
|
/* 24 reserved bytes */
|
|
offset += 24;
|
|
|
|
if (osd2) {
|
|
dissect_osd2_cdb_continuation_length(pinfo, tvb, offset, tree, cdata);
|
|
} else {
|
|
/* 4 reserved bytes */
|
|
}
|
|
offset += 4;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += osd2?104:80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += osd2?52:40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* CDB continuation */
|
|
dissect_osd2_cdb_continuation(pinfo, tvb, offset, tree, cdata);
|
|
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for create partition */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for create partition */
|
|
}
|
|
|
|
}
|
|
|
|
static const value_string scsi_osd_sort_order_vals[] = {
|
|
{0x00, "Ascending numeric value"},
|
|
{0, NULL},
|
|
};
|
|
static int
|
|
dissect_osd_sortorder(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* sort order */
|
|
proto_tree_add_item(tree, hf_scsi_osd_sortorder, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static int
|
|
dissect_osd_list_identifier(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* list identifier */
|
|
proto_tree_add_item(tree, hf_scsi_osd_list_identifier, tvb, offset, 4, ENC_BIG_ENDIAN);
|
|
offset += 4;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static void
|
|
dissect_osd_allocation_length(tvbuff_t *tvb, int offset, proto_tree *tree, scsi_task_data_t *cdata)
|
|
{
|
|
/* allocation length */
|
|
proto_tree_add_item(tree, hf_scsi_osd_allocation_length, tvb, offset, 8, ENC_BIG_ENDIAN);
|
|
|
|
if (cdata) {
|
|
guint64 alloc_len = tvb_get_ntoh64(tvb, offset);
|
|
if (alloc_len>G_GINT64_CONSTANT(0xFFFFFFFF)) {
|
|
alloc_len = G_GINT64_CONSTANT(0xFFFFFFFF);
|
|
}
|
|
cdata->itlq->alloc_len = (guint32)alloc_len;
|
|
}
|
|
}
|
|
|
|
static int
|
|
dissect_osd_initial_object_id(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* initial object id */
|
|
proto_tree_add_item(tree, hf_scsi_osd_initial_object_id, tvb, offset, 8, ENC_NA);
|
|
offset += 8;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static int
|
|
dissect_osd_additional_length(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* additional length */
|
|
proto_tree_add_item(tree, hf_scsi_osd_additional_length, tvb, offset, 8, ENC_BIG_ENDIAN);
|
|
offset += 8;
|
|
|
|
return offset;
|
|
}
|
|
|
|
|
|
static int
|
|
dissect_osd_continuation_object_id(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* continuation object id */
|
|
proto_tree_add_item(tree, hf_scsi_osd_continuation_object_id, tvb, offset, 8, ENC_NA);
|
|
offset += 8;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static const true_false_string list_lstchg_tfs = {
|
|
"List has CHANGED since the first List command",
|
|
"List has NOT changed since first command"
|
|
};
|
|
static const true_false_string list_root_tfs = {
|
|
"Objects are from root and are PARTITION IDs",
|
|
"Objects are from the partition and are USER OBJECTs"
|
|
};
|
|
static const true_false_string list_coltn_tfs = {
|
|
"Objects are from the partition and are COLLECTION IDs",
|
|
"Objects are from the collection and are USER OBJECTs"
|
|
};
|
|
|
|
static proto_item*
|
|
dissect_osd_collection_object_id(tvbuff_t *tvb, int offset, proto_tree *tree, const int hfindex)
|
|
{
|
|
/* collection object id */
|
|
proto_item *item;
|
|
item = proto_tree_add_item(tree, hfindex, tvb, offset, 8, ENC_NA);
|
|
return item;
|
|
}
|
|
|
|
static void
|
|
dissect_osd_list(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
guint svcaction = ((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->svcaction;
|
|
gboolean list_collection = (svcaction == 0x8817) || (svcaction == 0x8897);
|
|
gboolean osd2 = svcaction&0x80;
|
|
((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->osd2 = osd2;
|
|
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
|
|
if (isreq && iscdb) {
|
|
/*byte 10*/
|
|
if (osd2) dissect_osd2_isolation(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte / sort order */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
if (!list_collection) dissect_osd_sortorder(tvb, offset, tree);
|
|
if (osd2) dissect_osd2_list_attr(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
if (list_collection) {
|
|
/* collection id */
|
|
dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd_collection_object_id);
|
|
} else {
|
|
/* 8 reserved bytes */
|
|
}
|
|
offset += 8;
|
|
|
|
if (osd2) {
|
|
/* allocation length */
|
|
dissect_osd_allocation_length(tvb, offset, tree, cdata);
|
|
offset += 8;
|
|
|
|
/* initial object id */
|
|
dissect_osd_initial_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* list identifier */
|
|
dissect_osd_list_identifier(tvb, offset, tree);
|
|
offset += 4;
|
|
} else {
|
|
/* list identifier */
|
|
dissect_osd_list_identifier(tvb, offset, tree);
|
|
offset += 4;
|
|
|
|
/* allocation length */
|
|
dissect_osd_allocation_length(tvb, offset, tree, cdata);
|
|
offset += 8;
|
|
|
|
/* initial object id */
|
|
dissect_osd_initial_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
}
|
|
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += osd2?104:80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += osd2?52:40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for LIST or LIST COLLECTION */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
|
|
guint64 additional_length;
|
|
guint64 allocation_length;
|
|
guint64 remaining_length;
|
|
gboolean is_root_or_coltn;
|
|
guint8 format = 0;
|
|
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
allocation_length = cdata->itlq->alloc_len;
|
|
remaining_length = tvb_captured_length_remaining(tvb, offset);
|
|
if (remaining_length<allocation_length) allocation_length = remaining_length;
|
|
if (allocation_length<24) return;
|
|
|
|
/* dissection of the LIST or LIST COLLECTION DATA-IN */
|
|
/* additional length */
|
|
additional_length = tvb_get_ntoh64(tvb, offset);
|
|
if (allocation_length<additional_length) additional_length = allocation_length;
|
|
|
|
dissect_osd_additional_length(tvb, offset, tree);
|
|
|
|
offset += 8;
|
|
/* continuation object id */
|
|
dissect_osd_continuation_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
/* list identifier */
|
|
dissect_osd_list_identifier(tvb, offset, tree);
|
|
offset += 4;
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* OSD: LSTCHG and ROOT flags
|
|
OSD2: LSTCHG and OBJECT DESCRIPTOR FORMAT*/
|
|
proto_tree_add_item(tree, hf_scsi_osd_list_flags_lstchg, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
if (osd2) {
|
|
proto_item *item;
|
|
item = proto_tree_add_item(tree, hf_scsi_osd2_object_descriptor_format, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
format = tvb_get_guint8(tvb, offset)>>2;
|
|
if (format == 0x01 || format == 0x02) {
|
|
is_root_or_coltn = TRUE;
|
|
if (list_collection) format = 0;
|
|
} else if (format == 0x11 || format == 0x12) {
|
|
is_root_or_coltn = TRUE;
|
|
if (!list_collection) format = 0;
|
|
} else if (format == 0x21 || format == 0x22) {
|
|
is_root_or_coltn = FALSE;
|
|
} else format = 0;
|
|
if (!format) {
|
|
expert_add_info(pinfo, item, &ei_osd2_invalid_object_descriptor_format);
|
|
return;
|
|
}
|
|
} else {
|
|
if (list_collection) {
|
|
proto_tree_add_item(tree, hf_scsi_osd_list_collection_flags_coltn, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
} else {
|
|
proto_tree_add_item(tree, hf_scsi_osd_list_flags_root, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
is_root_or_coltn = tvb_get_guint8(tvb, offset)&0x01;
|
|
}
|
|
|
|
offset += 1;
|
|
|
|
while (additional_length > (offset-8)) {
|
|
proto_item *ti;
|
|
/* list of 8-byte IDs; the type of ID is given by is_root_or_coltn and list_collection*/
|
|
if (is_root_or_coltn) {
|
|
if (list_collection) {
|
|
ti = dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd_collection_object_id);
|
|
} else {
|
|
ti = dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
}
|
|
} else {
|
|
ti = dissect_osd_user_object_id(tvb, offset, tree);
|
|
}
|
|
offset += 8;
|
|
|
|
/* for OSD-2 if format is 0x02, 0x12 or 0x22: sub-list of attributes*/
|
|
if (osd2 && (format&0x02)) {
|
|
guint32 attr_list_end;
|
|
proto_tree *subtree;
|
|
|
|
if (offset+8>additional_length) break;
|
|
subtree = proto_item_add_subtree(ti, ett_osd_multi_object);
|
|
|
|
/*object type*/
|
|
proto_tree_add_item(subtree, hf_scsi_osd_object_type, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
/* 5 reserved bytes */
|
|
offset += 5;
|
|
/* attribute list length*/
|
|
attr_list_end = offset+2+tvb_get_ntohs(tvb, offset);
|
|
offset += 2;
|
|
if (attr_list_end>additional_length+8) break;
|
|
while (offset+16<attr_list_end) {
|
|
guint32 attribute_length = tvb_get_ntohs(tvb, offset+14);
|
|
proto_item *att_item;
|
|
proto_tree *att_tree = proto_tree_add_subtree(subtree, tvb, offset, 16+attribute_length, ett_osd_attribute, &att_item, "Attribute:");
|
|
offset = dissect_osd_attribute_list_entry(pinfo, tvb, att_tree, att_item, offset, lun_info, TRUE);
|
|
}
|
|
offset = attr_list_end;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static int
|
|
dissect_osd_requested_user_object_id(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* request user object id */
|
|
proto_tree_add_item(tree, hf_scsi_osd_requested_user_object_id, tvb, offset, 8, ENC_NA);
|
|
offset += 8;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static int
|
|
dissect_osd_number_of_user_objects(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* number_of_user_objects */
|
|
proto_tree_add_item(tree, hf_scsi_osd_number_of_user_objects, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
offset += 2;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static void
|
|
dissect_osd_create(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* requested user_object id */
|
|
dissect_osd_requested_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 4 reserved bytes */
|
|
offset += 4;
|
|
|
|
/* number of user objects */
|
|
dissect_osd_number_of_user_objects(tvb, offset, tree);
|
|
offset += 2;
|
|
|
|
/* 14 reserved bytes */
|
|
offset += 14;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for create */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for create */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_remove_partition(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
gboolean osd2 = ((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->svcaction&0x80;
|
|
((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->osd2 = osd2;
|
|
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
if (osd2) dissect_osd2_isolation(tvb, offset, tree);
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
if (osd2) proto_tree_add_item(tree, hf_scsi_osd2_remove_scope, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, TRUE);
|
|
offset += 8;
|
|
|
|
/* 24 reserved bytes */
|
|
offset += 24;
|
|
|
|
if (osd2) {
|
|
dissect_osd2_cdb_continuation_length(pinfo, tvb, offset, tree, cdata);
|
|
} else {
|
|
/* 4 reserved bytes */
|
|
}
|
|
offset += 4;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += osd2?104:80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += osd2?52:40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* CDB continuation */
|
|
dissect_osd2_cdb_continuation(pinfo, tvb, offset, tree, cdata);
|
|
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for remove partition */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for remove partition */
|
|
}
|
|
|
|
}
|
|
|
|
static const value_string key_to_set_vals[] = {
|
|
{1, "Root"},
|
|
{2, "Partition"},
|
|
{3, "Working"},
|
|
{0, NULL},
|
|
};
|
|
static void
|
|
dissect_osd_key_to_set(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
proto_tree_add_item(tree, hf_scsi_osd_key_to_set, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static void
|
|
dissect_osd_set_key_version(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
proto_tree_add_item(tree, hf_scsi_osd_set_key_version, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static void
|
|
dissect_osd_key_identifier(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
proto_tree_add_item(tree, hf_scsi_osd_key_identifier, tvb, offset, 7, ENC_NA);
|
|
}
|
|
|
|
static void
|
|
dissect_osd_seed(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
proto_tree_add_item(tree, hf_scsi_osd_seed, tvb, offset, 20, ENC_NA);
|
|
}
|
|
|
|
static void
|
|
dissect_osd_set_key(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* a reserved byte */
|
|
offset += 1;
|
|
|
|
/* getset attributes byte and key to set*/
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
dissect_osd_key_to_set(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* key version */
|
|
dissect_osd_set_key_version(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* key identifier */
|
|
dissect_osd_key_identifier(tvb, offset, tree);
|
|
offset += 7;
|
|
|
|
/* seed */
|
|
dissect_osd_seed(tvb, offset, tree);
|
|
offset += 20;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for set key */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for set key */
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
dissect_osd_remove(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* user object id */
|
|
dissect_osd_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 20 reserved bytes */
|
|
offset += 20;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for remove */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for remove */
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
dissect_osd_collection_fcr(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
proto_tree_add_item(tree, hf_scsi_osd_collection_fcr, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
}
|
|
|
|
static void
|
|
dissect_osd_remove_collection(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
gboolean osd2 = ((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->svcaction&0x80;
|
|
((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->osd2 = osd2;
|
|
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
dissect_osd_collection_fcr(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* collection object id */
|
|
dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd_collection_object_id);
|
|
offset += 8;
|
|
|
|
/* 16 reserved bytes */
|
|
offset += 16;
|
|
|
|
if (osd2) {
|
|
dissect_osd2_cdb_continuation_length(pinfo, tvb, offset, tree, cdata);
|
|
} else {
|
|
/* 4 reserved bytes */
|
|
}
|
|
offset += 4;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += osd2?104:80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += osd2?52:40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* CDB continuation */
|
|
dissect_osd2_cdb_continuation(pinfo, tvb, offset, tree, cdata);
|
|
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for remove collection */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for remove collection */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static int
|
|
dissect_osd_length(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* length */
|
|
proto_tree_add_item(tree, hf_scsi_osd_length, tvb, offset, 8, ENC_BIG_ENDIAN);
|
|
offset += 8;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static int
|
|
dissect_osd_starting_byte_address(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* starting_byte_address */
|
|
proto_tree_add_item(tree, hf_scsi_osd_starting_byte_address, tvb, offset, 8, ENC_BIG_ENDIAN);
|
|
offset += 8;
|
|
|
|
return offset;
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_write(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte / sort order */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* user object id */
|
|
dissect_osd_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 4 reserved bytes */
|
|
offset += 4;
|
|
|
|
/* length */
|
|
dissect_osd_length(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* starting byte address */
|
|
dissect_osd_starting_byte_address(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* xxx should dissect the data ? */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for WRITE */
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
dissect_osd_create_collection(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
dissect_osd_collection_fcr(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* requested collection object id */
|
|
dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd_requested_collection_object_id);
|
|
offset += 8;
|
|
|
|
/* 20 reserved bytes */
|
|
offset += 20;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for create collection */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for create collection */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static const value_string flush_scope_vals[] = {
|
|
{0, "User object data and attributes"},
|
|
{1, "User object attributes only"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static int
|
|
dissect_osd_flush_scope(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* flush scope */
|
|
proto_tree_add_item(tree, hf_scsi_osd_flush_scope, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static void
|
|
dissect_osd_flush(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_flush_scope(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* user object id */
|
|
dissect_osd_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 20 reserved bytes */
|
|
offset += 20;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for flush */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for flush */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static const value_string flush_collection_scope_vals[] = {
|
|
{0, "List of user objects contained in the collection"},
|
|
{1, "Collection attributes only"},
|
|
{2, "List of user objects and collection attributes"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static int
|
|
dissect_osd_flush_collection_scope(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* flush collection scope */
|
|
proto_tree_add_item(tree, hf_scsi_osd_flush_collection_scope, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static void
|
|
dissect_osd_flush_collection(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_flush_collection_scope(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
dissect_osd_collection_fcr(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* collection object id */
|
|
dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd_collection_object_id);
|
|
offset += 8;
|
|
|
|
/* 20 reserved bytes */
|
|
offset += 20;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for flush collection */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for flush collection */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_append(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* user object id */
|
|
dissect_osd_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 4 reserved bytes */
|
|
offset += 4;
|
|
|
|
/* length */
|
|
dissect_osd_length(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 8 reserved bytes */
|
|
offset += 8;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* xxx should dissect the data ? */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for append */
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
dissect_osd_create_and_write(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* requested user_object id */
|
|
dissect_osd_requested_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 4 reserved bytes */
|
|
offset += 4;
|
|
|
|
/* length */
|
|
dissect_osd_length(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* starting byte address */
|
|
dissect_osd_starting_byte_address(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* should we dissect the data? */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for create and write*/
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static const value_string flush_osd_scope_vals[] = {
|
|
{0, "List of partitions contained in the OSD logical unit"},
|
|
{1, "Root object attributes only"},
|
|
{2, "Everything"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static int
|
|
dissect_osd_flush_osd_scope(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* flush osd scope */
|
|
proto_tree_add_item(tree, hf_scsi_osd_flush_osd_scope, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
return offset;
|
|
}
|
|
|
|
static void
|
|
dissect_osd_flush_osd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info _U_)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_flush_osd_scope(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 39 reserved bytes */
|
|
offset += 39;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for flush osd */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for flush osd */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static const value_string flush_partition_scope_vals[] = {
|
|
{0, "List of user objects and collections in the partition"},
|
|
{1, "Partition attributes only"},
|
|
{2, "Everything"},
|
|
{0, NULL}
|
|
};
|
|
|
|
static int
|
|
dissect_osd_flush_partition_scope(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
{
|
|
/* flush partition scope */
|
|
proto_tree_add_item(tree, hf_scsi_osd_flush_partition_scope, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
return offset;
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_flush_partition(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_flush_partition_scope(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* 28 reserved bytes */
|
|
offset += 28;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for flush partition */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for flush partition */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_get_attributes(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
gboolean osd2 = ((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->svcaction&0x80;
|
|
((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->osd2 = osd2;
|
|
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* user_object id */
|
|
dissect_osd_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 16 reserved bytes */
|
|
offset += 16;
|
|
|
|
if (osd2) {
|
|
dissect_osd2_cdb_continuation_length(pinfo, tvb, offset, tree, cdata);
|
|
} else {
|
|
/* 4 reserved bytes */
|
|
}
|
|
offset += 4;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += osd2?104:80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += osd2?52:40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for get attributes */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for get attributes */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_read(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte / sort order */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* user object id */
|
|
dissect_osd_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 4 reserved bytes */
|
|
offset += 4;
|
|
|
|
/* length */
|
|
dissect_osd_length(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* starting byte address */
|
|
dissect_osd_starting_byte_address(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for READ */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* xxx should dissect the data ? */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd_set_attributes(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
gboolean osd2 = ((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->svcaction&0x80;
|
|
((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->osd2 = osd2;
|
|
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
/* options byte */
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partiton id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* user_object id */
|
|
dissect_osd_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 16 reserved bytes */
|
|
offset += 16;
|
|
|
|
if (osd2) {
|
|
dissect_osd2_cdb_continuation_length(pinfo, tvb, offset, tree, cdata);
|
|
} else {
|
|
/* 4 reserved bytes */
|
|
}
|
|
offset += 4;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += osd2?104:80;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += osd2?52:40;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for set attributes */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for set attributes */
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void
|
|
dissect_osd2_create_user_tracking_collection(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->osd2 = TRUE;
|
|
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
|
|
/* options byte */
|
|
dissect_osd2_isolation(tvb, offset, tree);
|
|
dissect_osd_option(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* getset attributes byte */
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partition id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* user_object id */
|
|
dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd_requested_collection_object_id);
|
|
offset += 8;
|
|
|
|
/* 8 reserved bytes */
|
|
offset += 8;
|
|
|
|
/* source collection id */
|
|
dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd2_source_collection_object_id);
|
|
offset += 8;
|
|
|
|
/*cdb continuation length*/
|
|
dissect_osd2_cdb_continuation_length(pinfo, tvb, offset, tree, cdata);
|
|
offset += 4;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 104;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 52;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* CDB continuation */
|
|
dissect_osd2_cdb_continuation(pinfo, tvb, offset, tree, cdata);
|
|
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for create user tracking collection */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data in for create user tracking collection */
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
dissect_osd2_query(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len _U_, scsi_task_data_t *cdata _U_,
|
|
scsi_osd_conv_info_t *conv_info _U_,
|
|
scsi_osd_lun_info_t *lun_info)
|
|
{
|
|
((scsi_osd_extra_data_t *)cdata->itlq->extra_data)->osd2 = TRUE;
|
|
|
|
/* dissecting the CDB dissection starts at byte 10 of the CDB */
|
|
if (isreq && iscdb) {
|
|
|
|
/* isolation field */
|
|
dissect_osd2_isolation(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* immed_tr, getset attributes*/
|
|
proto_tree_add_item(tree, hf_scsi_osd2_immed_tr, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
dissect_osd_getsetattrib(tvb, offset, tree, cdata);
|
|
offset += 1;
|
|
|
|
/* timestamps control */
|
|
dissect_osd_timestamps_control(tvb, offset, tree);
|
|
offset += 1;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
|
|
/* partition id */
|
|
dissect_osd_partition_id(pinfo, tvb, offset, tree, hf_scsi_osd_partition_id, lun_info, FALSE, FALSE);
|
|
offset += 8;
|
|
|
|
/* collection_object id */
|
|
dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd_collection_object_id);
|
|
offset += 8;
|
|
|
|
/* allocation_length */
|
|
dissect_osd_allocation_length(tvb, offset, tree, cdata);
|
|
offset += 8;
|
|
|
|
/* matches collection id */
|
|
dissect_osd_collection_object_id(tvb, offset, tree, hf_scsi_osd2_matches_collection_object_id);
|
|
offset += 8;
|
|
|
|
/*cdb continuation length*/
|
|
dissect_osd2_cdb_continuation_length(pinfo, tvb, offset, tree, cdata);
|
|
offset += 4;
|
|
|
|
/* attribute parameters */
|
|
dissect_osd_attribute_parameters(pinfo, tvb, offset, tree, cdata);
|
|
offset += 28;
|
|
|
|
/* capability */
|
|
dissect_osd_capability(tvb, offset, tree);
|
|
offset += 104;
|
|
|
|
/* security parameters */
|
|
dissect_osd_security_parameters(tvb, offset, tree);
|
|
offset += 52;
|
|
}
|
|
|
|
/* dissecting the DATA OUT */
|
|
if (isreq && !iscdb) {
|
|
/* CDB continuation */
|
|
dissect_osd2_cdb_continuation(pinfo, tvb, offset, tree, cdata);
|
|
|
|
/* attribute data out */
|
|
dissect_osd_attribute_data_out(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
/* no data out for query */
|
|
}
|
|
|
|
/* dissecting the DATA IN */
|
|
if (!isreq && !iscdb) {
|
|
guint64 additional_length;
|
|
guint64 allocation_length;
|
|
guint64 remaining_length;
|
|
guint8 format;
|
|
proto_item *item;
|
|
|
|
/* attribute data in */
|
|
dissect_osd_attribute_data_in(pinfo, tvb, offset, tree, cdata, lun_info);
|
|
|
|
allocation_length = cdata->itlq->alloc_len;
|
|
remaining_length = tvb_captured_length_remaining(tvb, offset);
|
|
if (remaining_length<allocation_length) allocation_length = remaining_length;
|
|
if (allocation_length<12) return;
|
|
|
|
/* dissection of the LIST or LIST COLLECTION DATA-IN */
|
|
/* additional length */
|
|
additional_length = tvb_get_ntoh64(tvb, offset);
|
|
if ((guint32)(allocation_length-8)<additional_length) additional_length = (guint32)(allocation_length-8);
|
|
|
|
dissect_osd_additional_length(tvb, offset, tree);
|
|
offset += 8;
|
|
|
|
/* 3 reserved bytes */
|
|
offset += 3;
|
|
item = proto_tree_add_item(tree, hf_scsi_osd2_object_descriptor_format, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
format = tvb_get_guint8(tvb, offset)>>2;
|
|
offset += 1;
|
|
if (format != 0x21) {
|
|
expert_add_info(pinfo, item, &ei_osd2_invalid_object_descriptor_format);
|
|
return;
|
|
}
|
|
|
|
while (additional_length > (offset-4)) {
|
|
dissect_osd_user_object_id(tvb, offset, tree);
|
|
offset += 8;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/* OSD Service Actions */
|
|
#define OSD_FORMAT_OSD 0x8801
|
|
#define OSD_CREATE 0x8802
|
|
#define OSD_LIST 0x8803
|
|
#define OSD_READ 0x8805
|
|
#define OSD_WRITE 0x8806
|
|
#define OSD_APPEND 0x8807
|
|
#define OSD_FLUSH 0x8808
|
|
#define OSD_REMOVE 0x880a
|
|
#define OSD_CREATE_PARTITION 0x880b
|
|
#define OSD_REMOVE_PARTITION 0x880c
|
|
#define OSD_GET_ATTRIBUTES 0x880e
|
|
#define OSD_SET_ATTRIBUTES 0x880f
|
|
#define OSD_CREATE_AND_WRITE 0x8812
|
|
#define OSD_CREATE_COLLECTION 0x8815
|
|
#define OSD_REMOVE_COLLECTION 0x8816
|
|
#define OSD_LIST_COLLECTION 0x8817
|
|
#define OSD_SET_KEY 0x8818
|
|
#define OSD_FLUSH_COLLECTION 0x881a
|
|
#define OSD_FLUSH_PARTITION 0x881b
|
|
#define OSD_FLUSH_OSD 0x881c
|
|
|
|
#define OSD_2_CREATE 0x8882
|
|
#define OSD_2_LIST 0x8883
|
|
#define OSD_2_READ 0x8885
|
|
#define OSD_2_WRITE 0x8886
|
|
#define OSD_2_APPEND 0x8887
|
|
#define OSD_2_CLEAR 0x8889
|
|
#define OSD_2_REMOVE 0x888a
|
|
#define OSD_2_CREATE_PARTITION 0x888b
|
|
#define OSD_2_REMOVE_PARTITION 0x888c
|
|
#define OSD_2_GET_ATTRIBUTES 0x888e
|
|
#define OSD_2_SET_ATTRIBUTES 0x888f
|
|
#define OSD_2_CREATE_AND_WRITE 0x8892
|
|
#define OSD_2_COPY_USER_OBJECTS 0x8893
|
|
#define OSD_2_CREATE_USER_TRACKING_COLLECTION 0x8894
|
|
#define OSD_2_REMOVE_COLLECTION 0x8896
|
|
#define OSD_2_LIST_COLLECTION 0x8897
|
|
#define OSD_2_QUERY 0x88a0
|
|
#define OSD_2_REMOVE_MEMBER_OBJECTS 0x88a1
|
|
#define OSD_2_GET_MEMBER_ATTRIBUTES 0x88a2
|
|
#define OSD_2_SET_MEMBER_ATTRIBUTES 0x88a3
|
|
|
|
static const value_string scsi_osd_svcaction_vals[] = {
|
|
{OSD_FORMAT_OSD, "Format OSD"},
|
|
{OSD_CREATE, "Create"},
|
|
{OSD_LIST, "List"},
|
|
{OSD_READ, "Read"},
|
|
{OSD_WRITE, "Write"},
|
|
{OSD_APPEND, "Append"},
|
|
{OSD_FLUSH, "Flush"},
|
|
{OSD_REMOVE, "Remove"},
|
|
{OSD_CREATE_PARTITION, "Create Partition"},
|
|
{OSD_REMOVE_PARTITION, "Remove Partition"},
|
|
{OSD_GET_ATTRIBUTES, "Get Attributes"},
|
|
{OSD_SET_ATTRIBUTES, "Set Attributes"},
|
|
{OSD_CREATE_AND_WRITE, "Create And Write"},
|
|
{OSD_CREATE_COLLECTION, "Create Collection"},
|
|
{OSD_REMOVE_COLLECTION, "Remove Collection"},
|
|
{OSD_LIST_COLLECTION, "List Collection"},
|
|
{OSD_SET_KEY, "Set Key"},
|
|
{OSD_FLUSH_COLLECTION, "Flush Collection"},
|
|
{OSD_FLUSH_PARTITION, "Flush Partition"},
|
|
{OSD_FLUSH_OSD, "Flush OSD"},
|
|
|
|
{OSD_2_CREATE, "Create (OSD-2)"},
|
|
{OSD_2_LIST, "List (OSD-2)"},
|
|
{OSD_2_READ, "Read (OSD-2)"},
|
|
{OSD_2_WRITE, "Write (OSD-2)"},
|
|
{OSD_2_APPEND, "Append (OSD-2)"},
|
|
{OSD_2_CLEAR, "Clear (OSD-2)"},
|
|
{OSD_2_REMOVE, "Remove (OSD-2)"},
|
|
{OSD_2_CREATE_PARTITION, "Create Partition (OSD-2)"},
|
|
{OSD_2_REMOVE_PARTITION, "Remove Partition (OSD-2)"},
|
|
{OSD_2_GET_ATTRIBUTES, "Get Attributes (OSD-2)"},
|
|
{OSD_2_SET_ATTRIBUTES, "Set Attributes (OSD-2)"},
|
|
{OSD_2_CREATE_AND_WRITE, "Create And Write (OSD-2)"},
|
|
{OSD_2_COPY_USER_OBJECTS, "Copy User Objects (OSD-2)"},
|
|
{OSD_2_CREATE_USER_TRACKING_COLLECTION, "Create User Tracking Collection (OSD-2)"},
|
|
{OSD_2_REMOVE_COLLECTION, "Remove Collection (OSD-2)"},
|
|
{OSD_2_LIST_COLLECTION, "List Collection (OSD-2)"},
|
|
{OSD_2_QUERY, "Query (OSD-2)"},
|
|
{OSD_2_REMOVE_MEMBER_OBJECTS, "Remove Member Objects (OSD-2)"},
|
|
{OSD_2_GET_MEMBER_ATTRIBUTES, "Get Member Attributes (OSD-2)"},
|
|
{OSD_2_SET_MEMBER_ATTRIBUTES, "Set Member Attributes (OSD-2)"},
|
|
{0, NULL},
|
|
};
|
|
static value_string_ext scsi_osd_svcaction_vals_ext = VALUE_STRING_EXT_INIT(scsi_osd_svcaction_vals);
|
|
|
|
/* OSD Service Action dissectors */
|
|
typedef struct _scsi_osd_svcaction_t {
|
|
guint16 svcaction;
|
|
scsi_osd_dissector_t dissector;
|
|
} scsi_osd_svcaction_t;
|
|
|
|
static const scsi_osd_svcaction_t scsi_osd_svcaction[] = {
|
|
{OSD_FORMAT_OSD, dissect_osd_format_osd},
|
|
{OSD_CREATE, dissect_osd_create},
|
|
{OSD_LIST, dissect_osd_list},
|
|
{OSD_READ, dissect_osd_read},
|
|
{OSD_WRITE, dissect_osd_write},
|
|
{OSD_APPEND, dissect_osd_append},
|
|
{OSD_FLUSH, dissect_osd_flush},
|
|
{OSD_REMOVE, dissect_osd_remove},
|
|
{OSD_CREATE_PARTITION, dissect_osd_create_partition},
|
|
{OSD_REMOVE_PARTITION, dissect_osd_remove_partition},
|
|
{OSD_GET_ATTRIBUTES, dissect_osd_get_attributes},
|
|
{OSD_SET_ATTRIBUTES, dissect_osd_set_attributes},
|
|
{OSD_CREATE_AND_WRITE, dissect_osd_create_and_write},
|
|
{OSD_CREATE_COLLECTION, dissect_osd_create_collection},
|
|
{OSD_REMOVE_COLLECTION, dissect_osd_remove_collection},
|
|
{OSD_LIST_COLLECTION, dissect_osd_list},
|
|
{OSD_SET_KEY, dissect_osd_set_key},
|
|
{OSD_FLUSH_COLLECTION, dissect_osd_flush_collection},
|
|
{OSD_FLUSH_PARTITION, dissect_osd_flush_partition},
|
|
{OSD_FLUSH_OSD, dissect_osd_flush_osd},
|
|
{OSD_2_LIST, dissect_osd_list},
|
|
{OSD_2_CREATE_PARTITION, dissect_osd_create_partition},
|
|
{OSD_2_CREATE_USER_TRACKING_COLLECTION, dissect_osd2_create_user_tracking_collection},
|
|
{OSD_2_REMOVE_PARTITION, dissect_osd_remove_partition},
|
|
{OSD_2_LIST_COLLECTION, dissect_osd_list},
|
|
{OSD_2_CREATE_USER_TRACKING_COLLECTION, dissect_osd2_create_user_tracking_collection},
|
|
{OSD_2_REMOVE_COLLECTION, dissect_osd_remove_collection},
|
|
{OSD_2_GET_ATTRIBUTES, dissect_osd_get_attributes},
|
|
{OSD_2_SET_ATTRIBUTES, dissect_osd_set_attributes},
|
|
{OSD_2_QUERY, dissect_osd2_query},
|
|
{0, NULL},
|
|
};
|
|
|
|
static scsi_osd_dissector_t
|
|
find_svcaction_dissector(guint16 svcaction)
|
|
{
|
|
const scsi_osd_svcaction_t *sa = scsi_osd_svcaction;
|
|
|
|
while (sa && sa->dissector) {
|
|
if (sa->svcaction == svcaction) {
|
|
return sa->dissector;
|
|
}
|
|
sa++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
dissect_osd_opcode(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
|
|
guint offset, gboolean isreq, gboolean iscdb,
|
|
guint payload_len, scsi_task_data_t *cdata)
|
|
{
|
|
guint16 svcaction = 0;
|
|
scsi_osd_dissector_t dissector;
|
|
scsi_osd_conv_info_t *conv_info;
|
|
scsi_osd_lun_info_t *lun_info;
|
|
|
|
if (!tree) {
|
|
return;
|
|
}
|
|
|
|
/* We must have an itl an itlq and a conversation */
|
|
if (!cdata || !cdata->itl || !cdata->itl->conversation || !cdata->itlq) {
|
|
return;
|
|
}
|
|
/* make sure we have a conversation info for this */
|
|
conv_info = (scsi_osd_conv_info_t *)conversation_get_proto_data(cdata->itl->conversation, proto_scsi_osd);
|
|
if (!conv_info) {
|
|
conv_info = wmem_new(wmem_file_scope(), scsi_osd_conv_info_t);
|
|
conv_info->luns = wmem_tree_new(wmem_file_scope());
|
|
conversation_add_proto_data(cdata->itl->conversation, proto_scsi_osd, conv_info);
|
|
}
|
|
/* make sure we have a lun_info structure for this */
|
|
lun_info = (scsi_osd_lun_info_t *)wmem_tree_lookup32(conv_info->luns, cdata->itlq->lun);
|
|
if (!lun_info) {
|
|
lun_info = wmem_new(wmem_file_scope(), scsi_osd_lun_info_t);
|
|
lun_info->partitions = wmem_tree_new(wmem_file_scope());
|
|
wmem_tree_insert32(conv_info->luns, cdata->itlq->lun, (void *)lun_info);
|
|
}
|
|
|
|
/* dissecting the CDB */
|
|
if (isreq && iscdb) {
|
|
proto_tree_add_item (tree, hf_scsi_control, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
/* 5 reserved bytes */
|
|
offset += 5;
|
|
|
|
proto_tree_add_item (tree, hf_scsi_osd_add_cdblen, tvb, offset, 1, ENC_BIG_ENDIAN);
|
|
offset += 1;
|
|
|
|
svcaction = tvb_get_ntohs(tvb, offset);
|
|
if (cdata && cdata->itlq) {
|
|
/* We must store the service action for this itlq
|
|
* so we can identify what the data contains
|
|
*/
|
|
if ((!pinfo->fd->visited) || (!cdata->itlq->extra_data)) {
|
|
scsi_osd_extra_data_t *extra_data;
|
|
|
|
extra_data = wmem_new0(wmem_file_scope(), scsi_osd_extra_data_t);
|
|
extra_data->svcaction = svcaction;
|
|
cdata->itlq->extra_data = extra_data;
|
|
}
|
|
}
|
|
proto_tree_add_item (tree, hf_scsi_osd_svcaction, tvb, offset, 2, ENC_BIG_ENDIAN);
|
|
offset += 2;
|
|
|
|
|
|
col_append_str(pinfo->cinfo, COL_INFO,
|
|
val_to_str_ext_const(svcaction, &scsi_osd_svcaction_vals_ext, "Unknown OSD Service Action"));
|
|
|
|
dissector = find_svcaction_dissector(svcaction);
|
|
if (dissector) {
|
|
(*dissector)(tvb, pinfo, tree, offset, isreq, iscdb, payload_len, cdata, conv_info, lun_info);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* If it was not a CDB, try to find the service action and pass it
|
|
* off to the service action dissector
|
|
*/
|
|
if (cdata && cdata->itlq && cdata->itlq->extra_data) {
|
|
scsi_osd_extra_data_t *extra_data = (scsi_osd_extra_data_t *)cdata->itlq->extra_data;
|
|
svcaction = extra_data->svcaction;
|
|
}
|
|
col_append_str(pinfo->cinfo, COL_INFO,
|
|
val_to_str_ext_const(svcaction, &scsi_osd_svcaction_vals_ext, "Unknown OSD Service Action"));
|
|
if (svcaction) {
|
|
proto_item *it;
|
|
it = proto_tree_add_uint_format_value(tree, hf_scsi_osd_svcaction, tvb, 0, 0, svcaction, "0x%04x", svcaction);
|
|
proto_item_set_generated(it);
|
|
}
|
|
dissector = find_svcaction_dissector(svcaction);
|
|
if (dissector) {
|
|
(*dissector)(tvb, pinfo, tree, offset, isreq, iscdb, payload_len, cdata, conv_info, lun_info);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* OSD Commands */
|
|
static const value_string scsi_osd_vals[] = {
|
|
/* 0x12 */ {SCSI_SPC_INQUIRY, "Inquiry"},
|
|
/* 0x4C */ {SCSI_SPC_LOGSELECT, "Log Select"},
|
|
/* 0x4D */ {SCSI_SPC_LOGSENSE, "Log Sense"},
|
|
/* 0x55 */ {SCSI_SPC_MODESELECT10, "Mode Select(10)"},
|
|
/* 0x5A */ {SCSI_SPC_MODESENSE10, "Mode Sense(10)"},
|
|
/* 0x5E */ {SCSI_SPC_PERSRESVIN, "Persistent Reserve In"},
|
|
/* 0x5F */ {SCSI_SPC_PERSRESVOUT, "Persistent Reserve Out"},
|
|
/* 0x7f */ {SCSI_OSD_OPCODE, "OSD Command" },
|
|
/* 0xA0 */ {SCSI_SPC_REPORTLUNS, "Report LUNs"},
|
|
/* 0xA3 */ {SCSI_SPC_MGMT_PROTOCOL_IN, "Mgmt Protocol In"},
|
|
{0, NULL},
|
|
};
|
|
value_string_ext scsi_osd_vals_ext = VALUE_STRING_EXT_INIT(scsi_osd_vals);
|
|
|
|
scsi_cdb_table_t scsi_osd_table[256] = {
|
|
/*OSD 0x00*/{NULL},
|
|
/*OSD 0x01*/{NULL},
|
|
/*OSD 0x02*/{NULL},
|
|
/*OSD 0x03*/{NULL},
|
|
/*OSD 0x04*/{NULL},
|
|
/*OSD 0x05*/{NULL},
|
|
/*OSD 0x06*/{NULL},
|
|
/*OSD 0x07*/{NULL},
|
|
/*OSD 0x08*/{NULL},
|
|
/*OSD 0x09*/{NULL},
|
|
/*OSD 0x0a*/{NULL},
|
|
/*OSD 0x0b*/{NULL},
|
|
/*OSD 0x0c*/{NULL},
|
|
/*OSD 0x0d*/{NULL},
|
|
/*OSD 0x0e*/{NULL},
|
|
/*OSD 0x0f*/{NULL},
|
|
/*OSD 0x10*/{NULL},
|
|
/*OSD 0x11*/{NULL},
|
|
/*OSD 0x12*/{dissect_spc_inquiry},
|
|
/*OSD 0x13*/{NULL},
|
|
/*OSD 0x14*/{NULL},
|
|
/*OSD 0x15*/{NULL},
|
|
/*OSD 0x16*/{NULL},
|
|
/*OSD 0x17*/{NULL},
|
|
/*OSD 0x18*/{NULL},
|
|
/*OSD 0x19*/{NULL},
|
|
/*OSD 0x1a*/{NULL},
|
|
/*OSD 0x1b*/{NULL},
|
|
/*OSD 0x1c*/{NULL},
|
|
/*OSD 0x1d*/{NULL},
|
|
/*OSD 0x1e*/{NULL},
|
|
/*OSD 0x1f*/{NULL},
|
|
/*OSD 0x20*/{NULL},
|
|
/*OSD 0x21*/{NULL},
|
|
/*OSD 0x22*/{NULL},
|
|
/*OSD 0x23*/{NULL},
|
|
/*OSD 0x24*/{NULL},
|
|
/*OSD 0x25*/{NULL},
|
|
/*OSD 0x26*/{NULL},
|
|
/*OSD 0x27*/{NULL},
|
|
/*OSD 0x28*/{NULL},
|
|
/*OSD 0x29*/{NULL},
|
|
/*OSD 0x2a*/{NULL},
|
|
/*OSD 0x2b*/{NULL},
|
|
/*OSD 0x2c*/{NULL},
|
|
/*OSD 0x2d*/{NULL},
|
|
/*OSD 0x2e*/{NULL},
|
|
/*OSD 0x2f*/{NULL},
|
|
/*OSD 0x30*/{NULL},
|
|
/*OSD 0x31*/{NULL},
|
|
/*OSD 0x32*/{NULL},
|
|
/*OSD 0x33*/{NULL},
|
|
/*OSD 0x34*/{NULL},
|
|
/*OSD 0x35*/{NULL},
|
|
/*OSD 0x36*/{NULL},
|
|
/*OSD 0x37*/{NULL},
|
|
/*OSD 0x38*/{NULL},
|
|
/*OSD 0x39*/{NULL},
|
|
/*OSD 0x3a*/{NULL},
|
|
/*OSD 0x3b*/{NULL},
|
|
/*OSD 0x3c*/{NULL},
|
|
/*OSD 0x3d*/{NULL},
|
|
/*OSD 0x3e*/{NULL},
|
|
/*OSD 0x3f*/{NULL},
|
|
/*OSD 0x40*/{NULL},
|
|
/*OSD 0x41*/{NULL},
|
|
/*OSD 0x42*/{NULL},
|
|
/*OSD 0x43*/{NULL},
|
|
/*OSD 0x44*/{NULL},
|
|
/*OSD 0x45*/{NULL},
|
|
/*OSD 0x46*/{NULL},
|
|
/*OSD 0x47*/{NULL},
|
|
/*OSD 0x48*/{NULL},
|
|
/*OSD 0x49*/{NULL},
|
|
/*OSD 0x4a*/{NULL},
|
|
/*OSD 0x4b*/{NULL},
|
|
/*OSD 0x4c*/{dissect_spc_logselect},
|
|
/*OSD 0x4d*/{dissect_spc_logsense},
|
|
/*OSD 0x4e*/{NULL},
|
|
/*OSD 0x4f*/{NULL},
|
|
/*OSD 0x50*/{NULL},
|
|
/*OSD 0x51*/{NULL},
|
|
/*OSD 0x52*/{NULL},
|
|
/*OSD 0x53*/{NULL},
|
|
/*OSD 0x54*/{NULL},
|
|
/*OSD 0x55*/{dissect_spc_modeselect10},
|
|
/*OSD 0x56*/{NULL},
|
|
/*OSD 0x57*/{NULL},
|
|
/*OSD 0x58*/{NULL},
|
|
/*OSD 0x59*/{NULL},
|
|
/*OSD 0x5a*/{dissect_spc_modesense10},
|
|
/*OSD 0x5b*/{NULL},
|
|
/*OSD 0x5c*/{NULL},
|
|
/*OSD 0x5d*/{NULL},
|
|
/*OSD 0x5e*/{dissect_spc_persistentreservein},
|
|
/*OSD 0x5f*/{dissect_spc_persistentreserveout},
|
|
/*OSD 0x60*/{NULL},
|
|
/*OSD 0x61*/{NULL},
|
|
/*OSD 0x62*/{NULL},
|
|
/*OSD 0x63*/{NULL},
|
|
/*OSD 0x64*/{NULL},
|
|
/*OSD 0x65*/{NULL},
|
|
/*OSD 0x66*/{NULL},
|
|
/*OSD 0x67*/{NULL},
|
|
/*OSD 0x68*/{NULL},
|
|
/*OSD 0x69*/{NULL},
|
|
/*OSD 0x6a*/{NULL},
|
|
/*OSD 0x6b*/{NULL},
|
|
/*OSD 0x6c*/{NULL},
|
|
/*OSD 0x6d*/{NULL},
|
|
/*OSD 0x6e*/{NULL},
|
|
/*OSD 0x6f*/{NULL},
|
|
/*OSD 0x70*/{NULL},
|
|
/*OSD 0x71*/{NULL},
|
|
/*OSD 0x72*/{NULL},
|
|
/*OSD 0x73*/{NULL},
|
|
/*OSD 0x74*/{NULL},
|
|
/*OSD 0x75*/{NULL},
|
|
/*OSD 0x76*/{NULL},
|
|
/*OSD 0x77*/{NULL},
|
|
/*OSD 0x78*/{NULL},
|
|
/*OSD 0x79*/{NULL},
|
|
/*OSD 0x7a*/{NULL},
|
|
/*OSD 0x7b*/{NULL},
|
|
/*OSD 0x7c*/{NULL},
|
|
/*OSD 0x7d*/{NULL},
|
|
/*OSD 0x7e*/{NULL},
|
|
/*OSD 0x7f*/{dissect_osd_opcode},
|
|
/*OSD 0x80*/{NULL},
|
|
/*OSD 0x81*/{NULL},
|
|
/*OSD 0x82*/{NULL},
|
|
/*OSD 0x83*/{NULL},
|
|
/*OSD 0x84*/{NULL},
|
|
/*OSD 0x85*/{NULL},
|
|
/*OSD 0x86*/{NULL},
|
|
/*OSD 0x87*/{NULL},
|
|
/*OSD 0x88*/{NULL},
|
|
/*OSD 0x89*/{NULL},
|
|
/*OSD 0x8a*/{NULL},
|
|
/*OSD 0x8b*/{NULL},
|
|
/*OSD 0x8c*/{NULL},
|
|
/*OSD 0x8d*/{NULL},
|
|
/*OSD 0x8e*/{NULL},
|
|
/*OSD 0x8f*/{NULL},
|
|
/*OSD 0x90*/{NULL},
|
|
/*OSD 0x91*/{NULL},
|
|
/*OSD 0x92*/{NULL},
|
|
/*OSD 0x93*/{NULL},
|
|
/*OSD 0x94*/{NULL},
|
|
/*OSD 0x95*/{NULL},
|
|
/*OSD 0x96*/{NULL},
|
|
/*OSD 0x97*/{NULL},
|
|
/*OSD 0x98*/{NULL},
|
|
/*OSD 0x99*/{NULL},
|
|
/*OSD 0x9a*/{NULL},
|
|
/*OSD 0x9b*/{NULL},
|
|
/*OSD 0x9c*/{NULL},
|
|
/*OSD 0x9d*/{NULL},
|
|
/*OSD 0x9e*/{NULL},
|
|
/*OSD 0x9f*/{NULL},
|
|
/*OSD 0xa0*/{dissect_spc_reportluns},
|
|
/*OSD 0xa1*/{NULL},
|
|
/*OSD 0xa2*/{NULL},
|
|
/*SPC 0xa3*/{dissect_spc_mgmt_protocol_in},
|
|
/*OSD 0xa4*/{NULL},
|
|
/*OSD 0xa5*/{NULL},
|
|
/*OSD 0xa6*/{NULL},
|
|
/*OSD 0xa7*/{NULL},
|
|
/*OSD 0xa8*/{NULL},
|
|
/*OSD 0xa9*/{NULL},
|
|
/*OSD 0xaa*/{NULL},
|
|
/*OSD 0xab*/{NULL},
|
|
/*OSD 0xac*/{NULL},
|
|
/*OSD 0xad*/{NULL},
|
|
/*OSD 0xae*/{NULL},
|
|
/*OSD 0xaf*/{NULL},
|
|
/*OSD 0xb0*/{NULL},
|
|
/*OSD 0xb1*/{NULL},
|
|
/*OSD 0xb2*/{NULL},
|
|
/*OSD 0xb3*/{NULL},
|
|
/*OSD 0xb4*/{NULL},
|
|
/*OSD 0xb5*/{NULL},
|
|
/*OSD 0xb6*/{NULL},
|
|
/*OSD 0xb7*/{NULL},
|
|
/*OSD 0xb8*/{NULL},
|
|
/*OSD 0xb9*/{NULL},
|
|
/*OSD 0xba*/{NULL},
|
|
/*OSD 0xbb*/{NULL},
|
|
/*OSD 0xbc*/{NULL},
|
|
/*OSD 0xbd*/{NULL},
|
|
/*OSD 0xbe*/{NULL},
|
|
/*OSD 0xbf*/{NULL},
|
|
/*OSD 0xc0*/{NULL},
|
|
/*OSD 0xc1*/{NULL},
|
|
/*OSD 0xc2*/{NULL},
|
|
/*OSD 0xc3*/{NULL},
|
|
/*OSD 0xc4*/{NULL},
|
|
/*OSD 0xc5*/{NULL},
|
|
/*OSD 0xc6*/{NULL},
|
|
/*OSD 0xc7*/{NULL},
|
|
/*OSD 0xc8*/{NULL},
|
|
/*OSD 0xc9*/{NULL},
|
|
/*OSD 0xca*/{NULL},
|
|
/*OSD 0xcb*/{NULL},
|
|
/*OSD 0xcc*/{NULL},
|
|
/*OSD 0xcd*/{NULL},
|
|
/*OSD 0xce*/{NULL},
|
|
/*OSD 0xcf*/{NULL},
|
|
/*OSD 0xd0*/{NULL},
|
|
/*OSD 0xd1*/{NULL},
|
|
/*OSD 0xd2*/{NULL},
|
|
/*OSD 0xd3*/{NULL},
|
|
/*OSD 0xd4*/{NULL},
|
|
/*OSD 0xd5*/{NULL},
|
|
/*OSD 0xd6*/{NULL},
|
|
/*OSD 0xd7*/{NULL},
|
|
/*OSD 0xd8*/{NULL},
|
|
/*OSD 0xd9*/{NULL},
|
|
/*OSD 0xda*/{NULL},
|
|
/*OSD 0xdb*/{NULL},
|
|
/*OSD 0xdc*/{NULL},
|
|
/*OSD 0xdd*/{NULL},
|
|
/*OSD 0xde*/{NULL},
|
|
/*OSD 0xdf*/{NULL},
|
|
/*OSD 0xe0*/{NULL},
|
|
/*OSD 0xe1*/{NULL},
|
|
/*OSD 0xe2*/{NULL},
|
|
/*OSD 0xe3*/{NULL},
|
|
/*OSD 0xe4*/{NULL},
|
|
/*OSD 0xe5*/{NULL},
|
|
/*OSD 0xe6*/{NULL},
|
|
/*OSD 0xe7*/{NULL},
|
|
/*OSD 0xe8*/{NULL},
|
|
/*OSD 0xe9*/{NULL},
|
|
/*OSD 0xea*/{NULL},
|
|
/*OSD 0xeb*/{NULL},
|
|
/*OSD 0xec*/{NULL},
|
|
/*OSD 0xed*/{NULL},
|
|
/*OSD 0xee*/{NULL},
|
|
/*OSD 0xef*/{NULL},
|
|
/*OSD 0xf0*/{NULL},
|
|
/*OSD 0xf1*/{NULL},
|
|
/*OSD 0xf2*/{NULL},
|
|
/*OSD 0xf3*/{NULL},
|
|
/*OSD 0xf4*/{NULL},
|
|
/*OSD 0xf5*/{NULL},
|
|
/*OSD 0xf6*/{NULL},
|
|
/*OSD 0xf7*/{NULL},
|
|
/*OSD 0xf8*/{NULL},
|
|
/*OSD 0xf9*/{NULL},
|
|
/*OSD 0xfa*/{NULL},
|
|
/*OSD 0xfb*/{NULL},
|
|
/*OSD 0xfc*/{NULL},
|
|
/*OSD 0xfd*/{NULL},
|
|
/*OSD 0xfe*/{NULL},
|
|
/*OSD 0xff*/{NULL}
|
|
};
|
|
|
|
|
|
|
|
|
|
void
|
|
proto_register_scsi_osd(void)
|
|
{
|
|
expert_module_t *expert_scsi_osd;
|
|
|
|
static hf_register_info hf[] = {
|
|
{ &hf_scsi_osd_opcode,
|
|
{"OSD Opcode", "scsi_osd.opcode", FT_UINT8, BASE_HEX | BASE_EXT_STRING,
|
|
&scsi_osd_vals_ext, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_add_cdblen,
|
|
{"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 | BASE_EXT_STRING,
|
|
&scsi_osd_svcaction_vals_ext, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_option,
|
|
{"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,
|
|
TFS(&tfs_set_notset), 0x10, NULL, HFILL}},
|
|
{ &hf_scsi_osd_option_fua,
|
|
{"FUA", "scsi_osd.option.fua", FT_BOOLEAN, 8,
|
|
TFS(&tfs_set_notset), 0x08, NULL, HFILL}},
|
|
{ &hf_scsi_osd_getsetattrib,
|
|
{"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,
|
|
VALS(scsi_osd_timestamps_control_vals), 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_formatted_capacity,
|
|
{"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,
|
|
NULL, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_get_attributes_list_length,
|
|
{"Get Attributes List Length", "scsi_osd.get_attributes_list_length", FT_UINT32, BASE_DEC_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,
|
|
NULL, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_set_attributes_list_length,
|
|
{"Set Attributes List Length", "scsi_osd.set_attributes_list_length", FT_UINT32, BASE_DEC_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,
|
|
NULL, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_get_attributes_allocation_length,
|
|
{"Get Attributes Allocation Length", "scsi_osd.get_attributes_allocation_length", FT_UINT32, BASE_DEC_HEX,
|
|
NULL, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_retrieved_attributes_offset,
|
|
{"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,
|
|
NULL, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_set_attribute_length,
|
|
{"Set Attribute Length", "scsi_osd.set_attribute_length", FT_UINT32, BASE_DEC_HEX,
|
|
NULL, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_set_attribute_number,
|
|
{"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,
|
|
NULL, 0x0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_capability_format,
|
|
{"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,
|
|
NULL, 0xf0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_icva,
|
|
{"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,
|
|
NULL, 0x0f, NULL, HFILL}},
|
|
{ &hf_scsi_osd_capability_expiration_time,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_capability_discriminator,
|
|
{"Capability Discriminator", "scsi_osd.capability_discriminator", 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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_object_type,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_read,
|
|
{"READ", "scsi_osd.permissions.read", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x8000, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_write,
|
|
{"WRITE", "scsi_osd.permissions.write", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x4000, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_get_attr,
|
|
{"GET_ATTR", "scsi_osd.permissions.get_attr", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x2000, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_set_attr,
|
|
{"SET_ATTR", "scsi_osd.permissions.set_attr", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x1000, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_create,
|
|
{"CREATE", "scsi_osd.permissions.create", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x0800, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_remove,
|
|
{"REMOVE", "scsi_osd.permissions.remove", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x0400, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_obj_mgmt,
|
|
{"OBJ_MGMT", "scsi_osd.permissions.obj_mgmt", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x0200, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_append,
|
|
{"APPEND", "scsi_osd.permissions.append", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x0100, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_dev_mgmt,
|
|
{"DEV_MGMT", "scsi_osd.permissions.dev_mgmt", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x0080, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_global,
|
|
{"GLOBAL", "scsi_osd.permissions.global", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x0040, NULL, HFILL}},
|
|
{ &hf_scsi_osd_permissions_pol_sec,
|
|
{"POL/SEC", "scsi_osd.permissions.pol_sec", FT_BOOLEAN, 16,
|
|
TFS(&tfs_set_notset), 0x0020, NULL, HFILL}},
|
|
|
|
{ &hf_scsi_osd_object_descriptor_type,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_ricv,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_diicvo,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_requested_partition_id,
|
|
{"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,
|
|
VALS(scsi_osd_sort_order_vals), 0x0f, NULL, HFILL}},
|
|
{ &hf_scsi_osd_partition_id,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_allocation_length,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_starting_byte_address,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_additional_length,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_user_object_id,
|
|
{"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,
|
|
TFS(&list_lstchg_tfs), 0x02, NULL, HFILL}},
|
|
{ &hf_scsi_osd_list_flags_root,
|
|
{"ROOT", "scsi_osd.list.root", FT_BOOLEAN, 8,
|
|
TFS(&list_root_tfs), 0x01, NULL, HFILL}},
|
|
{ &hf_scsi_osd_list_collection_flags_coltn,
|
|
{"COLTN", "scsi_osd.list_collection.coltn", FT_BOOLEAN, 8,
|
|
TFS(&list_coltn_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,
|
|
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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_key_to_set,
|
|
{"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,
|
|
NULL, 0x0f, NULL, HFILL}},
|
|
{ &hf_scsi_osd_key_identifier,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_collection_fcr,
|
|
{"FCR", "scsi_osd.collection.fcr", FT_BOOLEAN, 8,
|
|
TFS(&tfs_set_notset), 0x01, NULL, HFILL}},
|
|
{ &hf_scsi_osd_collection_object_id,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_partition_created_in,
|
|
{ "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,
|
|
NULL, 0x0, "The frame this partition was removed", HFILL }},
|
|
|
|
{ &hf_scsi_osd_flush_scope,
|
|
{"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,
|
|
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,
|
|
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,
|
|
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,
|
|
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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_attributes_page,
|
|
{"Attributes Page", "scsi_osd.attributes.page", FT_UINT32, BASE_HEX | BASE_EXT_STRING,
|
|
&attributes_page_vals_ext, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_attribute_number,
|
|
{"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,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_attributes_list_length,
|
|
{"Attributes List Length", "scsi_osd2.attributes_list.length", FT_UINT32, BASE_DEC,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_attrval_user_object_logical_length,
|
|
{"User Object Logical Length", "scsi_osd.user_object.logical_length", FT_UINT64, BASE_DEC,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_attrval_object_type,
|
|
{"Object Type", "scsi_osd.attr.object_type", FT_UINT8, BASE_HEX, VALS(scsi_osd_object_type_vals), 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_attrval_partition_id,
|
|
{"Partition ID", "scsi_osd.attr.partition_id", FT_UINT64, BASE_HEX,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd_attrval_object_id,
|
|
{"Object ID", "scsi_osd.attr.object_id", FT_UINT64, BASE_HEX,
|
|
NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_set_attribute_value,
|
|
{"Set Attributes Value", "scsi_osd.set_attribute_value", FT_BYTES, BASE_NONE, 0, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_isolation,
|
|
{"Isolation", "scsi_osd2.isolation", FT_UINT8, BASE_HEX, VALS(scsi_osd2_isolation_val), 0x0F, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_list_attr,
|
|
{"LIST ATTR flag", "scsi_osd2.list_attr", FT_BOOLEAN, 8, 0, 0x40, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_object_descriptor_format,
|
|
{"Object Descriptor Format", "scsi_osd2.object_descriptor_format", FT_UINT8, BASE_HEX, VALS(scsi_osd2_object_descriptor_format_val), 0xFC, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_immed_tr,
|
|
{"Immed TR", "scsi_osd2.immed_tr", FT_UINT8, BASE_DEC, 0, 0x80, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_remove_scope,
|
|
{"Remove scope", "scsi_osd2.remove_scope", FT_UINT8, BASE_HEX, VALS(scsi_osd2_remove_scope), 0x07, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_source_collection_object_id,
|
|
{"Source Collection Object ID", "scsi_osd2.source_collection_object_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_matches_collection_object_id,
|
|
{"Matches Collection Object ID", "scsi_osd2.matches_collection_object_id", FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_cdb_continuation_length,
|
|
{"CDB Continuation Length", "scsi_osd2.cdb_continuation.length", FT_UINT32, BASE_DEC, 0, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_cdb_continuation_format,
|
|
{"CDB Continuation Format", "scsi_osd2.cdb_continuation.format", FT_UINT8, BASE_HEX, VALS(scsi_osd2_cdb_continuation_format_val), 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_continued_service_action,
|
|
{"Continued Service Action", "scsi_osd2.cdb_continuation.sa", FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_cdb_continuation_descriptor_type,
|
|
{"Descriptor Type", "scsi_osd2.cdb_continuation.desc.type", FT_UINT16, BASE_HEX, VALS(scsi_osd2_cdb_continuation_descriptor_type_val), 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_cdb_continuation_descriptor_pad_length,
|
|
{"Descriptor Pad Length", "scsi_osd2.cdb_continuation.desc.padlen", FT_UINT8, BASE_DEC, NULL, 0x7, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_cdb_continuation_descriptor_length,
|
|
{"Descriptor Length", "scsi_osd2.cdb_continuation.desc.length", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_query_type,
|
|
{"Query Type", "scsi_osd2.query.type", FT_UINT8, BASE_HEX, VALS(scsi_osd2_query_type_vals), 0x0f, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_query_entry_length,
|
|
{"Entry Length", "scsi_osd2.query.entry.length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_query_attributes_page,
|
|
{"Attributes Page", "scsi_osd2.query.entry.page", FT_UINT32, BASE_HEX | BASE_EXT_STRING, &attributes_page_vals_ext, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_query_attribute_number,
|
|
{"Attribute Number", "scsi_osd2.query.entry.number", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_query_minimum_attribute_value_length,
|
|
{"Minimum Attribute Value Length", "scsi_osd2.query.entry.min_length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}},
|
|
{ &hf_scsi_osd2_query_maximum_attribute_value_length,
|
|
{"Maximum Attribute Value Length", "scsi_osd2.query.entry.max_length", FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL}},
|
|
};
|
|
|
|
/* Setup protocol subtree array */
|
|
static gint *ett[] = {
|
|
&ett_osd_option,
|
|
&ett_osd_partition,
|
|
&ett_osd_attribute_parameters,
|
|
&ett_osd_capability,
|
|
&ett_osd_permission_bitmask,
|
|
&ett_osd_security_parameters,
|
|
&ett_osd_get_attributes,
|
|
&ett_osd_set_attributes,
|
|
&ett_osd_multi_object,
|
|
&ett_osd_attribute,
|
|
&ett_osd2_query_criteria_entry,
|
|
};
|
|
|
|
/* Setup expert info */
|
|
static ei_register_info ei[] = {
|
|
{ &ei_osd_attr_unknown, { "scsi_osd.attr_unknown", PI_UNDECODED, PI_NOTE, "Unknown attribute, cannot decode attribute value", EXPFILL }},
|
|
{ &ei_osd2_invalid_offset, { "scsi_osd2.invalid_offset", PI_UNDECODED, PI_ERROR, "Invalid offset exponent", EXPFILL }},
|
|
{ &ei_osd2_invalid_object_descriptor_format, { "scsi_osd2.object_descriptor_format.invalid", PI_UNDECODED, PI_ERROR, "Invalid list format", EXPFILL }},
|
|
{ &ei_osd_unknown_attributes_list_type, { "scsi_osd.attributes_list.type.invalid", PI_UNDECODED, PI_ERROR, "Unknown attribute list type", EXPFILL }},
|
|
{ &ei_osd2_cdb_continuation_format_unknown, { "scsi_osd2.cdb_continuation.format.unknown", PI_UNDECODED, PI_ERROR, "Unknown CDB Continuation Format", EXPFILL }},
|
|
{ &ei_osd2_continued_service_action_mismatch, { "scsi_osd2.cdb_continuation.sa.mismatch", PI_PROTOCOL, PI_WARN, "CONTINUED SERVICE ACTION and SERVICE ACTION do not match", EXPFILL }},
|
|
{ &ei_osd2_cdb_continuation_descriptor_type_unknown, { "scsi_osd2.cdb_continuation.desc.type.unknown", PI_UNDECODED, PI_WARN, "Unknown descriptor type", EXPFILL }},
|
|
{ &ei_osd2_cdb_continuation_descriptor_length_invalid, { "scsi_osd2.cdb_continuation.desc.length.invalid", PI_PROTOCOL, PI_ERROR, "Invalid descriptor length (not a multiple of 8)", EXPFILL }},
|
|
{ &ei_osd2_cdb_continuation_length_invalid, { "scsi_osd2.cdb_continuation.length.invalid", PI_PROTOCOL, PI_ERROR, "Invalid CDB continuation length", EXPFILL }},
|
|
{ &ei_osd_attr_length_invalid, { "scsi_osd.attribute_length.invalid", PI_PROTOCOL, PI_ERROR, "Invalid Attribute Length", EXPFILL }},
|
|
{ &ei_osd2_query_values_equal, { "scsi_osd2.query.entry.equal", PI_PROTOCOL, PI_NOTE, "The minimum and maximum values are equal", EXPFILL }},
|
|
};
|
|
|
|
/* Register the protocol name and description */
|
|
proto_scsi_osd = proto_register_protocol("SCSI_OSD", "SCSI_OSD", "scsi_osd");
|
|
|
|
/* Required function calls to register the header fields and subtrees used */
|
|
proto_register_field_array(proto_scsi_osd, hf, array_length(hf));
|
|
proto_register_subtree_array(ett, array_length(ett));
|
|
|
|
/* Register expert info */
|
|
expert_scsi_osd = expert_register_protocol(proto_scsi_osd);
|
|
expert_register_field_array(expert_scsi_osd, ei, array_length(ei));
|
|
}
|
|
|
|
/*
|
|
* Editor modelines
|
|
*
|
|
* Local Variables:
|
|
* c-basic-offset: 4
|
|
* tab-width: 8
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*
|
|
* ex: set shiftwidth=4 tabstop=8 expandtab:
|
|
* :indentSize=4:tabSize=8:noTabs=true:
|
|
*/
|