f355bfadcc
Show values that are sequence numbers, counts, lengths, and the like in decimal, with the hex value after it in parentheses for the benefit of those who count to 16 rather than 10.
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:
|
|
*/
|