diff --git a/AUTHORS b/AUTHORS index e1c6ce322f..c4aa62c3c0 100644 --- a/AUTHORS +++ b/AUTHORS @@ -982,6 +982,11 @@ Irfan Khan { Jayaram V.R { PPP multiplexing support } + +Dinesh Dutt { + SCSI dissector, for use by iSCSI and other protocols that + transport SCSI operations +} Alain Magloire was kind enough to give his permission to use his version of snprintf.c. diff --git a/Makefile.am b/Makefile.am index 2b3add5f99..0002a5cfd2 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,7 +1,7 @@ # Makefile.am # Automake file for Ethereal # -# $Id: Makefile.am,v 1.403 2002/01/09 02:51:46 itojun Exp $ +# $Id: Makefile.am,v 1.404 2002/01/10 01:28:43 guy Exp $ # # Ethereal - Network traffic analyzer # By Gerald Combs @@ -239,7 +239,8 @@ DISSECTOR_SRC = \ packet-rwall.c \ packet-rx.c \ packet-sap.c \ - packet-sctp.c \ + packet-scsi.c \ + packet-sctp.c \ packet-sdp.c \ packet-sip.c \ packet-skinny.c \ @@ -407,6 +408,7 @@ noinst_HEADERS = \ packet-rtp.h \ packet-rwall.h \ packet-rx.h \ + packet-scsi.h \ packet-sll.h \ packet-smb-browse.h \ packet-smb-common.h \ diff --git a/Makefile.nmake b/Makefile.nmake index 09bce8592e..d2314a0121 100644 --- a/Makefile.nmake +++ b/Makefile.nmake @@ -1,7 +1,7 @@ ## Makefile for building ethereal.exe with Microsoft C and nmake ## Use: $(MAKE) /$(MAKEFLAGS) -f makefile.nmake # -# $Id: Makefile.nmake,v 1.163 2002/01/09 02:55:38 guy Exp $ +# $Id: Makefile.nmake,v 1.164 2002/01/10 01:28:43 guy Exp $ include config.nmake include @@ -190,7 +190,8 @@ DISSECTOR_SRC = \ packet-rwall.c \ packet-rx.c \ packet-sap.c \ - packet-sctp.c \ + packet-scsi.c \ + packet-sctp.c \ packet-sdp.c \ packet-sip.c \ packet-skinny.c \ diff --git a/doc/ethereal.pod.template b/doc/ethereal.pod.template index 7ff225b3cd..d051eae9ce 100644 --- a/doc/ethereal.pod.template +++ b/doc/ethereal.pod.template @@ -1277,6 +1277,7 @@ B. Heinz Prantner Irfan Khan Jayaram V.R + Dinesh Dutt Alain Magloire was kind enough to give his permission to use his version of snprintf.c. diff --git a/packet-iscsi.c b/packet-iscsi.c index 2908976780..668068ebde 100644 --- a/packet-iscsi.c +++ b/packet-iscsi.c @@ -4,7 +4,7 @@ * * Conforms to the protocol described in: draft-ietf-ips-iscsi-08.txt * - * $Id: packet-iscsi.c,v 1.18 2001/12/10 00:25:29 guy Exp $ + * $Id: packet-iscsi.c,v 1.19 2002/01/10 01:28:43 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs @@ -55,6 +55,8 @@ #include "packet.h" #include "prefs.h" +#include "conversation.h" +#include "packet-scsi.h" static gboolean iscsi_desegment = TRUE; @@ -79,7 +81,6 @@ static int hf_iscsi_AHS = -1; static int hf_iscsi_Padding = -1; static int hf_iscsi_ping_data = -1; static int hf_iscsi_immediate_data = -1; -static int hf_iscsi_sense_data = -1; static int hf_iscsi_write_data = -1; static int hf_iscsi_read_data = -1; static int hf_iscsi_error_pdu_data = -1; @@ -104,8 +105,6 @@ static int hf_iscsi_InitiatorTaskTag = -1; static int hf_iscsi_ExpectedDataTransferLength = -1; static int hf_iscsi_CmdSN = -1; static int hf_iscsi_ExpStatSN = -1; -static int hf_iscsi_SCSICommand_CDB = -1; -static int hf_iscsi_SCSICommand_CDB0 = -1; static int hf_iscsi_StatSN = -1; static int hf_iscsi_ExpCmdSN = -1; static int hf_iscsi_MaxCmdSN = -1; @@ -166,6 +165,22 @@ static gint ett_iscsi_KeyValues = -1; static gint ett_iscsi_CDB = -1; static gint ett_iscsi_Flags = -1; +typedef struct _iscsi_conv_key { + guint32 conv_idx; + guint32 itt; +} iscsi_conv_key_t; + +typedef struct _iscsi_conv_data { + guint32 iscsi_dl; + guint32 abs_secs; + guint32 abs_usecs; +} iscsi_conv_data_t; + +static GHashTable *iscsi_req_hash = NULL; +static GMemChunk *iscsi_req_keys = NULL; +static GMemChunk *iscsi_req_vals = NULL; +static guint32 iscsi_init_count = 25; + #define X_BIT 0x80 #define I_BIT 0x40 @@ -204,7 +219,7 @@ static const value_string iscsi_opcodes[] = { { ISCSI_OPCODE_TASK_MANAGEMENT_FUNCTION, "Task Management Function" }, { ISCSI_OPCODE_LOGIN_COMMAND, "Login Command" }, { ISCSI_OPCODE_TEXT_COMMAND, "Text Command" }, - { ISCSI_OPCODE_SCSI_DATA_OUT, "SCSI Write Data" }, + { ISCSI_OPCODE_SCSI_DATA_OUT, "SCSI Data Out" }, { ISCSI_OPCODE_LOGOUT_COMMAND, "Logout Command" }, { ISCSI_OPCODE_SNACK_REQUEST, "SNACK Request" }, @@ -213,7 +228,7 @@ static const value_string iscsi_opcodes[] = { { ISCSI_OPCODE_TASK_MANAGEMENT_FUNCTION_RESPONSE, "Task Management Function Response" }, { ISCSI_OPCODE_LOGIN_RESPONSE, "Login Response" }, { ISCSI_OPCODE_TEXT_RESPONSE, "Text Response" }, - { ISCSI_OPCODE_SCSI_DATA_IN, "SCSI Read Data" }, + { ISCSI_OPCODE_SCSI_DATA_IN, "SCSI Data In" }, { ISCSI_OPCODE_LOGOUT_RESPONSE, "Logout Response" }, { ISCSI_OPCODE_R2T, "Ready To Transfer" }, { ISCSI_OPCODE_ASYNC_MESSAGE, "Asynchronous Message" }, @@ -291,88 +306,6 @@ static const value_string iscsi_scsicommand_taskattrs[] = { {0, NULL}, }; -static const value_string iscsi_scsi_cdb0[] = { - {0x00, "TEST_UNIT_READY"}, - {0x01, "REZERO_UNIT"}, - {0x03, "REQUEST_SENSE"}, - {0x04, "FORMAT_UNIT"}, - {0x05, "READ_BLOCK_LIMITS"}, - {0x07, "REASSIGN_BLOCKS"}, - {0x08, "READ_6"}, - {0x0a, "WRITE_6"}, - {0x0b, "SEEK_6"}, - {0x0f, "READ_REVERSE"}, - {0x10, "WRITE_FILEMARKS"}, - {0x11, "SPACE"}, - {0x12, "INQUIRY"}, - {0x14, "RECOVER_BUFFERED_DATA"}, - {0x15, "MODE_SELECT"}, - {0x16, "RESERVE"}, - {0x17, "RELEASE"}, - {0x18, "COPY"}, - {0x19, "ERASE"}, - {0x1a, "MODE_SENSE"}, - {0x1b, "START_STOP"}, - {0x1c, "RECEIVE_DIAGNOSTIC"}, - {0x1d, "SEND_DIAGNOSTIC"}, - {0x1e, "ALLOW_MEDIUM_REMOVAL"}, - {0x24, "SET_WINDOW"}, - {0x25, "READ_CAPACITY"}, - {0x28, "READ_10"}, - {0x2a, "WRITE_10"}, - {0x2b, "SEEK_10"}, - {0x2e, "WRITE_VERIFY"}, - {0x2f, "VERIFY"}, - {0x30, "SEARCH_HIGH"}, - {0x31, "SEARCH_EQUAL"}, - {0x32, "SEARCH_LOW"}, - {0x33, "SET_LIMITS"}, - {0x34, "PRE_FETCH"}, - {0x34, "READ_POSITION"}, - {0x35, "SYNCHRONIZE_CACHE"}, - {0x36, "LOCK_UNLOCK_CACHE"}, - {0x37, "READ_DEFECT_DATA"}, - {0x38, "MEDIUM_SCAN"}, - {0x39, "COMPARE"}, - {0x3a, "COPY_VERIFY"}, - {0x3b, "WRITE_BUFFER"}, - {0x3c, "READ_BUFFER"}, - {0x3d, "UPDATE_BLOCK"}, - {0x3e, "READ_LONG"}, - {0x3f, "WRITE_LONG"}, - {0x40, "CHANGE_DEFINITION"}, - {0x41, "WRITE_SAME"}, - {0x43, "READ_TOC"}, - {0x4c, "LOG_SELECT"}, - {0x4d, "LOG_SENSE"}, - {0x55, "MODE_SELECT_10"}, - {0x5a, "MODE_SENSE_10"}, - {0xa5, "MOVE_MEDIUM"}, - {0xa8, "READ_12"}, - {0xaa, "WRITE_12"}, - {0xae, "WRITE_VERIFY_12"}, - {0xb0, "SEARCH_HIGH_12"}, - {0xb1, "SEARCH_EQUAL_12"}, - {0xb2, "SEARCH_LOW_12"}, - {0xb8, "READ_ELEMENT_STATUS"}, - {0xb6, "SEND_VOLUME_TAG"}, - {0xea, "WRITE_LONG_2"}, - {0, NULL}, -}; - -static const value_string iscsi_scsi_statuses[] = { - {0x00, "Good"}, - {0x02, "Check condition"}, - {0x04, "Condition good"}, - {0x08, "Busy"}, - {0x10, "Intermediate good"}, - {0x14, "Intermediate c good"}, - {0x18, "Reservation conflict"}, - {0x22, "Command terminated"}, - {0x28, "Queue full"}, - {0, NULL}, -}; - static const value_string iscsi_task_responses[] = { {0, "Function complete"}, {1, "Task not in task set"}, @@ -555,6 +488,53 @@ static guint32 crc32Table[256] = { #define CRC32C_PRELOAD 0xffffffff +/* + * Hash Functions + */ +static gint +iscsi_equal(gconstpointer v, gconstpointer w) +{ + iscsi_conv_key_t *v1 = (iscsi_conv_key_t *)v; + iscsi_conv_key_t *v2 = (iscsi_conv_key_t *)w; + + return (v1->conv_idx == v2->conv_idx); +} + +static guint +iscsi_hash (gconstpointer v) +{ + iscsi_conv_key_t *key = (iscsi_conv_key_t *)v; + guint val; + + val = key->conv_idx; + + return val; +} + +/* + * Protocol initialization + */ +static void +iscsi_init_protocol(void) +{ + if (iscsi_req_keys) + g_mem_chunk_destroy(iscsi_req_keys); + if (iscsi_req_vals) + g_mem_chunk_destroy(iscsi_req_vals); + if (iscsi_req_hash) + g_hash_table_destroy(iscsi_req_hash); + + iscsi_req_hash = g_hash_table_new(iscsi_hash, iscsi_equal); + iscsi_req_keys = g_mem_chunk_new("iscsi_req_keys", + sizeof(iscsi_conv_key_t), + iscsi_init_count * sizeof(iscsi_conv_key_t), + G_ALLOC_AND_FREE); + iscsi_req_vals = g_mem_chunk_new("iscsi_req_vals", + sizeof(iscsi_conv_data_t), + iscsi_init_count * sizeof(iscsi_conv_data_t), + G_ALLOC_AND_FREE); +} + static guint32 calculateCRC32(const void *buf, int len, guint32 crc) { guint8 *p = (guint8 *)buf; @@ -678,52 +658,99 @@ handleDataSegmentAsTextKeys(proto_item *ti, tvbuff_t *tvb, guint offset, guint d /* Code to actually dissect the packets */ static void dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint offset, guint8 opcode, const char *opcode_str, guint32 data_segment_len) { + guint original_offset = offset; proto_item *ti; char *scsi_command_name = NULL; + guint8 scsi_status = 0; guint cdb_offset = offset + 32; /* offset of CDB from start of PDU */ guint end_offset = offset + tvb_length_remaining(tvb, offset); + guint32 del_usecs = 0; + conversation_t *conversation = NULL; + iscsi_conv_data_t *cdata = NULL; + iscsi_conv_key_t ckey, *req_key; /* Make entries in Protocol column and Info column on summary display */ if (check_col(pinfo->cinfo, COL_PROTOCOL)) col_set_str(pinfo->cinfo, COL_PROTOCOL, "iSCSI"); + if (opcode == ISCSI_OPCODE_SCSI_RESPONSE) { + scsi_status = tvb_get_guint8 (tvb, offset+3); + } + + if ((opcode == ISCSI_OPCODE_SCSI_RESPONSE) || + (opcode == ISCSI_OPCODE_SCSI_DATA_IN) || + (opcode == ISCSI_OPCODE_SCSI_DATA_OUT)) { + conversation = find_conversation (&pinfo->src, &pinfo->dst, + pinfo->ptype, pinfo->srcport, + pinfo->destport, 0); + if (conversation) { + ckey.conv_idx = conversation->index; + ckey.itt = tvb_get_ntohl (tvb, offset+16); + + cdata = (iscsi_conv_data_t *)g_hash_table_lookup (iscsi_req_hash, + &ckey); + } + pinfo->private_data = cdata; + + if (cdata) { + del_usecs = (pinfo->fd->abs_secs - cdata->abs_secs)* 1000000 + + (pinfo->fd->abs_usecs - cdata->abs_usecs); + } + } + else if (opcode == ISCSI_OPCODE_SCSI_COMMAND) { + conversation = find_conversation (&pinfo->src, &pinfo->dst, + pinfo->ptype, pinfo->srcport, + pinfo->destport, 0); + if (!conversation) { + conversation = conversation_new (&pinfo->src, &pinfo->dst, + pinfo->ptype, pinfo->srcport, + pinfo->destport, 0); + } + + ckey.conv_idx = conversation->index; + ckey.itt = tvb_get_ntohl (tvb, offset+16); + + cdata = (iscsi_conv_data_t *)g_hash_table_lookup (iscsi_req_hash, + &ckey); + if (cdata) { + /* Since we never free the memory used by an exchange, this maybe a + * case of another request using the same exchange as a previous + * req. + */ + cdata->abs_usecs = pinfo->fd->abs_usecs; + cdata->abs_secs = pinfo->fd->abs_secs; + /* The SCSI protocol uses this as the key to detect a + * SCSI-level conversation. */ + } + else { + req_key = g_mem_chunk_alloc (iscsi_req_keys); + req_key->conv_idx = conversation->index; + req_key->itt = tvb_get_ntohl (tvb, offset+16); + + cdata = g_mem_chunk_alloc (iscsi_req_vals); + cdata->abs_usecs = pinfo->fd->abs_usecs; + cdata->abs_secs = pinfo->fd->abs_secs; + + g_hash_table_insert (iscsi_req_hash, req_key, cdata); + /* The SCSI protocol uses this as the key to detect a + * SCSI-level conversation. */ + } + pinfo->private_data = cdata; + } + else { + pinfo->private_data = NULL; + } + if (check_col(pinfo->cinfo, COL_INFO)) { - col_append_str(pinfo->cinfo, COL_INFO, (char *)opcode_str); - - if((opcode & ~(X_BIT | I_BIT)) == ISCSI_OPCODE_SCSI_COMMAND) { - /* SCSI Command */ - guint8 cdb0 = tvb_get_guint8(tvb, cdb_offset); - scsi_command_name = match_strval(cdb0, iscsi_scsi_cdb0); - if(cdb0 == 0x08 || cdb0 == 0x0a) { - /* READ_6 and WRITE_6 */ - guint lba = tvb_get_ntohl(tvb, cdb_offset) & 0x1fffff; - guint len = tvb_get_guint8(tvb, cdb_offset + 4); - col_append_fstr(pinfo->cinfo, COL_INFO, " (%s LBA 0x%06x len 0x%02x)", scsi_command_name, lba, len); - } - else if(cdb0 == 0x28 || cdb0 == 0x2a) { - /* READ_10 and WRITE_10 */ - guint lba = tvb_get_ntohl(tvb, cdb_offset + 2); - guint len = tvb_get_ntohs(tvb, cdb_offset + 7); - col_append_fstr(pinfo->cinfo, COL_INFO, " (%s LBA 0x%08x len 0x%04x)", scsi_command_name, lba, len); - } - else if(scsi_command_name != NULL) - col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", scsi_command_name); - } - else if(opcode == ISCSI_OPCODE_SCSI_RESPONSE) { - /* SCSI Command Response */ - const char *blurb = NULL; - /* look at response byte */ - if(tvb_get_guint8(tvb, offset + 2) == 0) { - /* command completed at target */ - blurb = match_strval(tvb_get_guint8(tvb, offset + 3), iscsi_scsi_statuses); - } - else - blurb = "Target Failure"; - if(blurb != NULL) - col_append_fstr(pinfo->cinfo, COL_INFO, " (%s)", blurb); - } + if (opcode != ISCSI_OPCODE_SCSI_COMMAND) { + col_append_str(pinfo->cinfo, COL_INFO, (char *)opcode_str); + } + if (opcode == ISCSI_OPCODE_SCSI_RESPONSE) { + col_append_fstr (pinfo->cinfo, COL_INFO, " %s", + val_to_str (scsi_status, scsi_status_val, "0x%x")); + } } /* In the interest of speed, if "tree" is NULL, don't do any @@ -774,7 +801,7 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off else if(opcode == ISCSI_OPCODE_SCSI_COMMAND) { /* SCSI Command */ guint32 ahsLen = tvb_get_guint8(tvb, offset + 4) * 4; - { + { gint b = tvb_get_guint8(tvb, offset + 1); proto_item *tf = proto_tree_add_uint(ti, hf_iscsi_Flags, tvb, offset + 1, 1, b); proto_tree *tt = proto_item_add_subtree(tf, ett_iscsi_Flags); @@ -793,32 +820,6 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off proto_tree_add_item(ti, hf_iscsi_CmdSN, tvb, offset + 24, 4, FALSE); proto_tree_add_item(ti, hf_iscsi_ExpStatSN, tvb, offset + 28, 4, FALSE); { - /* dissect a little of the CDB for the most common - * commands */ - guint8 cdb0 = tvb_get_guint8(tvb, cdb_offset); - gint cdb_len = 16; - proto_item *tf; - /* FIXME - extended CDB */ - if(scsi_command_name == NULL) - scsi_command_name = match_strval(cdb0, iscsi_scsi_cdb0); - if(cdb0 == 0x08 || cdb0 == 0x0a) { - /* READ_6 and WRITE_6 */ - guint lba = tvb_get_ntohl(tvb, cdb_offset) & 0x1fffff; - guint len = tvb_get_guint8(tvb, cdb_offset + 4); - tf = proto_tree_add_uint_format(ti, hf_iscsi_SCSICommand_CDB0, tvb, cdb_offset, cdb_len, cdb0, "CDB: %s LBA 0x%06x len 0x%02x", scsi_command_name, lba, len); - } - else if(cdb0 == 0x28 || cdb0 == 0x2a) { - /* READ_10 and WRITE_10 */ - guint lba = tvb_get_ntohl(tvb, cdb_offset + 2); - guint len = tvb_get_ntohs(tvb, cdb_offset + 7); - tf = proto_tree_add_uint_format(ti, hf_iscsi_SCSICommand_CDB0, tvb, cdb_offset, cdb_len, cdb0, "CDB: %s LBA 0x%08x len 0x%04x", scsi_command_name, lba, len); - } - else - tf = proto_tree_add_uint(ti, hf_iscsi_SCSICommand_CDB0, tvb, cdb_offset, cdb_len, cdb0); - { - proto_tree *tt = proto_item_add_subtree(tf, ett_iscsi_CDB); - proto_tree_add_item(tt, hf_iscsi_SCSICommand_CDB, tvb, cdb_offset, cdb_len, FALSE); - } if(ahsLen > 0) { /* FIXME - disssect AHS? */ proto_tree_add_item(ti, hf_iscsi_AHS, tvb, offset + 48, ahsLen, FALSE); @@ -829,6 +830,16 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off } else if(opcode == ISCSI_OPCODE_SCSI_RESPONSE) { /* SCSI Response */ + if (del_usecs) { + if (del_usecs > 1000) + proto_tree_add_text (ti, tvb, offset, 0, + "Cmd Response Time: %d msecs", + del_usecs/1000); + else + proto_tree_add_text (ti, tvb, offset, 0, + "Cmd Response Time: %d usecs", + del_usecs); + } { gint b = tvb_get_guint8(tvb, offset + 1); proto_item *tf = proto_tree_add_uint(ti, hf_iscsi_Flags, tvb, offset + 1, 1, b); @@ -850,7 +861,6 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off proto_tree_add_item(ti, hf_iscsi_ExpDataSN, tvb, offset + 36, 4, FALSE); proto_tree_add_item(ti, hf_iscsi_SCSIResponse_BidiReadResidualCount, tvb, offset + 44, 4, FALSE); offset = handleHeaderDigest(ti, tvb, offset, 48); - offset = handleDataSegment(ti, tvb, offset, data_segment_len, end_offset, hf_iscsi_sense_data); } else if(opcode == ISCSI_OPCODE_TASK_MANAGEMENT_FUNCTION) { /* Task Management Function */ @@ -993,7 +1003,6 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off proto_tree_add_item(ti, hf_iscsi_DataSN, tvb, offset + 36, 4, FALSE); proto_tree_add_item(ti, hf_iscsi_BufferOffset, tvb, offset + 40, 4, FALSE); offset = handleHeaderDigest(ti, tvb, offset, 48); - offset = handleDataSegment(ti, tvb, offset, data_segment_len, end_offset, hf_iscsi_write_data); } else if(opcode == ISCSI_OPCODE_SCSI_DATA_IN) { /* SCSI Data In (read) */ @@ -1017,7 +1026,6 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off proto_tree_add_item(ti, hf_iscsi_DataSN, tvb, offset + 36, 4, FALSE); proto_tree_add_item(ti, hf_iscsi_BufferOffset, tvb, offset + 40, 4, FALSE); offset = handleHeaderDigest(ti, tvb, offset, 48); - offset = handleDataSegment(ti, tvb, offset, data_segment_len, end_offset, hf_iscsi_read_data); } else if(opcode == ISCSI_OPCODE_LOGOUT_COMMAND) { /* Logout Command */ @@ -1095,6 +1103,36 @@ dissect_iscsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint off proto_item_set_len(ti, offset - original_offset); } + if((opcode & ~(X_BIT | I_BIT)) == ISCSI_OPCODE_SCSI_COMMAND) { + /* SCSI Command */ + dissect_scsi_cdb (tvb, pinfo, tree, cdb_offset, 16); + } + else if (opcode == ISCSI_OPCODE_SCSI_RESPONSE) { + if (scsi_status == 0x2) { + /* A SCSI response with Check Condition contains sense data */ + /* offset is setup correctly by the iscsi code for response above */ + dissect_scsi_snsinfo (tvb, pinfo, tree, offset, + iscsi_min (data_segment_len, + end_offset-offset)); + } + else { + dissect_scsi_rsp (tvb, pinfo, tree); + } + if (cdata && tree) { + /* destroy the data structures for this SCSI task */ +#if 0 + g_mem_chunk_free (iscsi_req_vals, cdata); + g_hash_table_remove (iscsi_req_hash, &ckey); + pinfo->private_data = NULL; +#endif + } + } + else if ((opcode == ISCSI_OPCODE_SCSI_DATA_IN) || + (opcode == ISCSI_OPCODE_SCSI_DATA_OUT)) { + /* offset is setup correctly by the iscsi code for response above */ + dissect_scsi_payload (tvb, pinfo, tree, offset, FALSE, + iscsi_min (data_segment_len, end_offset-offset)); + } } static gboolean @@ -1281,11 +1319,6 @@ proto_register_iscsi(void) FT_BYTES, BASE_HEX, NULL, 0, "Immediate Data", HFILL } }, - { &hf_iscsi_sense_data, - { "SenseData", "iscsi.sensedata", - FT_BYTES, BASE_HEX, NULL, 0, - "Sense Data", HFILL } - }, { &hf_iscsi_write_data, { "WriteData", "iscsi.writedata", FT_BYTES, BASE_HEX, NULL, 0, @@ -1406,16 +1439,6 @@ proto_register_iscsi(void) FT_UINT32, BASE_HEX, NULL, 0, "Next expected status sequence number", HFILL } }, - { &hf_iscsi_SCSICommand_CDB, - { "CDB", "iscsi.scsicommand.cdb", - FT_BYTES, BASE_HEX, NULL, 0, - "SCSI CDB", HFILL } - }, - { &hf_iscsi_SCSICommand_CDB0, - { "CDB", "iscsi.scsicommand.cdb0", - FT_UINT8, BASE_HEX, VALS(iscsi_scsi_cdb0), 0, - "SCSI CDB[0]", HFILL } - }, { &hf_iscsi_SCSIResponse_ResidualCount, { "ResidualCount", "iscsi.scsiresponse.residualcount", FT_UINT32, BASE_HEX, NULL, 0, @@ -1458,7 +1481,7 @@ proto_register_iscsi(void) }, { &hf_iscsi_SCSIResponse_Status, { "Status", "iscsi.scsiresponse.status", - FT_UINT8, BASE_HEX, VALS(iscsi_scsi_statuses), 0, + FT_UINT8, BASE_HEX, VALS(scsi_status_val), 0, "SCSI command status value", HFILL } }, { &hf_iscsi_SCSIResponse_Response, @@ -1697,7 +1720,8 @@ proto_register_iscsi(void) * subtrees used */ proto_register_field_array(proto_iscsi, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); - + register_init_routine (&iscsi_init_protocol); + { module_t *iscsi_module = prefs_register_protocol(proto_iscsi, NULL); diff --git a/packet-scsi.c b/packet-scsi.c new file mode 100644 index 0000000000..a77fb8f0e9 --- /dev/null +++ b/packet-scsi.c @@ -0,0 +1,2485 @@ +/* packet-scsi.c + * Routines for decoding SCSI CDBs and responses + * Author: Dinesh G Dutt (ddutt@cisco.com) + * + * $Id: packet-scsi.c,v 1.1 2002/01/10 01:28:43 guy Exp $ + * + * Ethereal - Network traffic analyzer + * By Gerald Combs + * Copyright 2002 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +/* + * Some Notes on using the SCSI Decoder: + * + * The SCSI decoder has been built right now that it is invoked directly by the + * SCSI transport layers as compared to the standard mechanism of being invoked + * via a dissector chain. There are multiple reasons for this: + * - The SCSI CDB is typically embedded inside the transport alongwith other + * header fields that have nothing to do with SCSI. So, it is required to be + * invoked on a embedded subset of the packet. + * - Originally, Ethereal couldn't do filtering on protocol trees that were not + * on the top level. + * + * There are four main routines that are provided: + * o dissect_scsi_cdb - invoked on receiving a SCSI Command + * void dissect_scsi_cdb (tvbuff_t *, packet_info *, proto_tree *, guint, + * guint); + * o dissect_scsi_payload - invoked to decode SCSI responses + * void dissect_scsi_payload (tvbuff_t *, packet_info *, proto_tree *, guint, + * gboolean, guint32); + * The final parameter is the length of the response field that is negotiated + * as part of the SCSI transport layer. If this is not tracked by the + * transport, it can be set to 0. + * o dissect_scsi_rsp - invoked to destroy the data structures associated with a + * SCSI task. + * void dissect_scsi_rsp (tvbuff_t *, packet_info *, proto_tree *); + * o dissect_scsi_snsinfo - invoked to decode the sense data provided in case of + * an error. + * void dissect_scsi_snsinfo (tvbuff_t *, packet_info *, proto_tree *, guint, + * guint); + * + * In addition to this, the other requirement made from the transport is to + * provide a unique way to determine a SCSI task. In Fibre channel networks, + * this is the exchange ID pair alongwith the source/destination addresses; in + * iSCSI it is the initiator task tag along with the src/dst address and port + * numbers. This is to be provided to the SCSI decoder via the private_data + * field in the packet_info data structure. The private_data field is treated + * as a 32-bit field to uniquely identify a SCSI task. + * + * This decoder attempts to track the type of SCSI device based on the response + * to the Inquiry command. If the trace does not contain an Inquiry command, + * the decoding of the commands is done as per a user preference. Currently, + * only SBC (disks) and SSC (tapes) are the alternatives offered. The basic + * SCSI command set (SPC-2/3) is decoded for all SCSI devices. If there is a + * mixture of devices in the trace, some with Inquiry response and some + * without, the user preference is used only for those devices whose type the + * decoder has not been able to determine. + * + */ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#ifdef HAVE_SYS_TYPES_H +# include +#endif + +#include +#include +#include "strutil.h" +#include "conversation.h" +#include "prefs.h" +#include "packet-scsi.h" + +static int proto_scsi = -1; +static int hf_scsi_spcopcode = -1; +static int hf_scsi_sbcopcode = -1; +static int hf_scsi_control = -1; +static int hf_scsi_inquiry_flags = -1; +static int hf_scsi_inquiry_evpd_page = -1; +static int hf_scsi_inquiry_cmdt_page = -1; +static int hf_scsi_alloclen = -1; +static int hf_scsi_logsel_flags = -1; +static int hf_scsi_log_pc = -1; +static int hf_scsi_paramlen = -1; +static int hf_scsi_logsns_flags = -1; +static int hf_scsi_logsns_pagecode = -1; +static int hf_scsi_paramlen16 = -1; +static int hf_scsi_modesel_flags = -1; +static int hf_scsi_alloclen16 = -1; +static int hf_scsi_modesns_pc = -1; +static int hf_scsi_modesns_pagecode = -1; +static int hf_scsi_modesns_flags = -1; +static int hf_scsi_persresvin_svcaction = -1; +static int hf_scsi_persresvout_svcaction = -1; +static int hf_scsi_persresv_scope = -1; +static int hf_scsi_persresv_type = -1; +static int hf_scsi_release_flags = -1; +static int hf_scsi_release_thirdpartyid = -1; +static int hf_scsi_alloclen32 = -1; +static int hf_scsi_formatunit_flags = -1; +static int hf_scsi_formatunit_interleave = -1; +static int hf_scsi_formatunit_vendor = -1; +static int hf_scsi_rdwr6_lba = -1; +static int hf_scsi_rdwr6_xferlen = -1; +static int hf_scsi_rdwr10_lba = -1; +static int hf_scsi_read_flags = -1; +static int hf_scsi_rdwr12_xferlen = -1; +static int hf_scsi_rdwr16_lba = -1; +static int hf_scsi_readcapacity_flags = -1; +static int hf_scsi_readcapacity_lba = -1; +static int hf_scsi_readcapacity_pmi = -1; +static int hf_scsi_rdwr10_xferlen = -1; +static int hf_scsi_readdefdata_flags = -1; +static int hf_scsi_cdb_defectfmt = -1; +static int hf_scsi_reassignblks_flags = -1; +static int hf_scsi_inq_devtype = -1; +static int hf_scsi_inq_version = -1; +static int hf_scsi_rluns_lun = -1; +static int hf_scsi_rluns_multilun = -1; +static int hf_scsi_modesns_errrep = -1; +static int hf_scsi_modesns_tst = -1; +static int hf_scsi_modesns_qmod = -1; +static int hf_scsi_modesns_qerr = -1; +static int hf_scsi_modesns_rac = -1; +static int hf_scsi_modesns_tas = -1; +static int hf_scsi_protocol = -1; +static int hf_scsi_sns_errtype = -1; +static int hf_scsi_snskey = -1; +static int hf_scsi_snsinfo = -1; +static int hf_scsi_addlsnslen = -1; +static int hf_scsi_asc = -1; +static int hf_scsi_ascascq = -1; +static int hf_scsi_ascq = -1; +static int hf_scsi_fru = -1; +static int hf_scsi_sksv = -1; +static int hf_scsi_inq_normaca = -1; +static int hf_scsi_persresv_key = -1; +static int hf_scsi_persresv_scopeaddr = -1; +static int hf_scsi_sscopcode = -1; + + +static gint ett_scsi = -1; +static gint ett_scsi_page = -1; +static gint scsi_def_devtype = SCSI_DEV_SBC; + +/* The next two structures are used to track SCSI req/rsp */ +typedef struct _scsi_task_key { + guint32 conv_idx; +} scsi_task_key_t; + +typedef struct _scsi_task_data { + guint32 opcode; + scsi_device_type devtype; + guint8 flags; /* used by SCSI Inquiry */ +} scsi_task_data_t; + +/* The next two data structures are used to track SCSI device type */ +typedef struct _scsi_devtype_key { + address devid; +} scsi_devtype_key_t; + +typedef struct _scsi_devtype_data { + scsi_device_type devtype; +} scsi_devtype_data_t; + +static GHashTable *scsi_req_hash = NULL; +static GMemChunk *scsi_req_keys = NULL; +static GMemChunk *scsi_req_vals = NULL; +static guint32 scsi_init_count = 25; + +static GHashTable *scsidev_req_hash = NULL; +static GMemChunk *scsidev_req_keys = NULL; +static GMemChunk *scsidev_req_vals = NULL; +static guint32 scsidev_init_count = 25; + +static dissector_handle_t data_handle; + +/* + * Hash Functions + */ +static gint +scsi_equal(gconstpointer v, gconstpointer w) +{ + scsi_task_key_t *v1 = (scsi_task_key_t *)v; + scsi_task_key_t *v2 = (scsi_task_key_t *)w; + + return (v1->conv_idx == v2->conv_idx); +} + +static guint +scsi_hash (gconstpointer v) +{ + scsi_task_key_t *key = (scsi_task_key_t *)v; + guint val; + + val = key->conv_idx; + + return val; +} + +static gint +scsidev_equal (gconstpointer v, gconstpointer w) +{ + scsi_devtype_key_t *k1 = (scsi_devtype_key_t *)v; + scsi_devtype_key_t *k2 = (scsi_devtype_key_t *)w; + + if (ADDRESSES_EQUAL (&k1->devid, &k2->devid)) + return 1; + else + return 0; +} + +static guint +scsidev_hash (gconstpointer v) +{ + scsi_devtype_key_t *key = (scsi_devtype_key_t *)v; + guint val; + int i; + + val = 0; + for (i = 0; i < key->devid.len; i++) + val += key->devid.data[i]; + val += key->devid.type; + + return val; +} + +static scsi_task_data_t * +scsi_new_task (packet_info *pinfo) +{ + scsi_task_data_t *cdata = NULL; + scsi_task_key_t ckey, *req_key; + conversation_t *conversation; + + if ((pinfo != NULL) && (pinfo->private_data)) { + ckey.conv_idx = (guint32)pinfo->private_data; + + cdata = (scsi_task_data_t *)g_hash_table_lookup (scsi_req_hash, + &ckey); + if (!cdata) { + req_key = g_mem_chunk_alloc (scsi_req_keys); + req_key->conv_idx = (guint32 )pinfo->private_data; + + cdata = g_mem_chunk_alloc (scsi_req_vals); + + g_hash_table_insert (scsi_req_hash, req_key, cdata); + } + } + return (cdata); +} + +static scsi_task_data_t * +scsi_find_task (packet_info *pinfo) +{ + scsi_task_data_t *cdata = NULL; + scsi_task_key_t ckey, *req_key; + conversation_t *conversation; + + if ((pinfo != NULL) && (pinfo->private_data)) { + ckey.conv_idx = (guint32)pinfo->private_data; + + cdata = (scsi_task_data_t *)g_hash_table_lookup (scsi_req_hash, + &ckey); + } + return (cdata); +} + +static void +scsi_end_task (packet_info *pinfo) +{ + scsi_task_data_t *cdata = NULL; + scsi_task_key_t ckey, *req_key; + conversation_t *conversation; + + if ((pinfo != NULL) && (pinfo->private_data)) { + ckey.conv_idx = (guint32)pinfo->private_data; + cdata = (scsi_task_data_t *)g_hash_table_lookup (scsi_req_hash, + &ckey); + if (cdata) { + g_mem_chunk_free (scsi_req_vals, cdata); + g_hash_table_remove (scsi_req_hash, &ckey); + } + } +} + +/* + * Protocol initialization + */ +static void +scsi_init_protocol(void) +{ + if (scsi_req_keys) + g_mem_chunk_destroy(scsi_req_keys); + if (scsi_req_vals) + g_mem_chunk_destroy(scsi_req_vals); + if (scsidev_req_keys) + g_mem_chunk_destroy (scsidev_req_keys); + if (scsidev_req_vals) + g_mem_chunk_destroy (scsidev_req_vals); + if (scsi_req_hash) + g_hash_table_destroy(scsi_req_hash); + if (scsidev_req_hash) + g_hash_table_destroy (scsidev_req_hash); + + scsi_req_hash = g_hash_table_new(scsi_hash, scsi_equal); + scsi_req_keys = g_mem_chunk_new("scsi_req_keys", + sizeof(scsi_task_key_t), + scsi_init_count * + sizeof(scsi_task_key_t), + G_ALLOC_AND_FREE); + scsi_req_vals = g_mem_chunk_new("scsi_req_vals", + sizeof(scsi_task_data_t), + scsi_init_count * + sizeof(scsi_task_data_t), + G_ALLOC_AND_FREE); + scsidev_req_hash = g_hash_table_new (scsidev_hash, scsidev_equal); + scsidev_req_keys = g_mem_chunk_new("scsidev_req_keys", + sizeof(scsi_devtype_key_t), + scsidev_init_count * + sizeof(scsi_devtype_key_t), + G_ALLOC_AND_FREE); + scsidev_req_vals = g_mem_chunk_new("scsidev_req_vals", + sizeof(scsi_devtype_data_t), + scsidev_init_count * + sizeof(scsi_devtype_data_t), + G_ALLOC_AND_FREE); +} + +static void +dissect_scsi_evpd (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, guint tot_len) +{ + proto_tree *evpd_tree; + proto_item *ti; + guint pcode, plen, i, idlen; + guint8 flags; + char str[32]; + + if (tree) { + pcode = tvb_get_guint8 (tvb, offset+1); + plen = tvb_get_guint8 (tvb, offset+3); + ti = proto_tree_add_text (tree, tvb, offset, plen+4, "Page Code: %s", + val_to_str (pcode, scsi_evpd_pagecode_val, + "Unknown (0x%08x)")); + evpd_tree = proto_item_add_subtree (ti, ett_scsi_page); + + proto_tree_add_text (evpd_tree, tvb, offset, 1, + "Peripheral Qualifier: 0x%x", + (tvb_get_guint8 (tvb, offset) & 0xF0)>>4); + proto_tree_add_item (evpd_tree, hf_scsi_inq_devtype, tvb, offset, + 1, 0); + proto_tree_add_text (evpd_tree, tvb, offset+1, 1, + "Page Code: %s", + val_to_str (pcode, scsi_evpd_pagecode_val, + "Unknown (0x%02x)")); + proto_tree_add_text (evpd_tree, tvb, offset+3, 1, + "Page Length: %u", plen); + offset += 4; + switch (pcode) { + case SCSI_EVPD_SUPPPG: + for (i = 0; i < plen; i++) { + proto_tree_add_text (evpd_tree, tvb, offset+i, 1, + "Supported Page: %s", + val_to_str (tvb_get_guint8 (tvb, offset+i), + scsi_evpd_pagecode_val, + "Unknown (0x%02x)")); + } + break; + case SCSI_EVPD_DEVID: + while (plen > 0) { + flags = tvb_get_guint8 (tvb, offset); + proto_tree_add_text (evpd_tree, tvb, offset, 1, + "Code Set: %s", + val_to_str (plen & 0x0F, + scsi_devid_codeset_val, + "Unknown (0x%02x)")); + flags = tvb_get_guint8 (tvb, offset+1); + proto_tree_add_text (evpd_tree, tvb, offset+1, 1, + "Association: %s", + val_to_str ((flags & 0x30) >> 4, + scsi_devid_assoc_val, + "Unknown (0x%02x)")); + proto_tree_add_text (evpd_tree, tvb, offset+1, 1, + "Identifier Type: %s", + val_to_str ((flags & 0x0F), + scsi_devid_idtype_val, + "Unknown (0x%02x)")); + idlen = tvb_get_guint8 (tvb, offset+3); + proto_tree_add_text (evpd_tree, tvb, offset+3, 1, + "Identifier Length: %u", idlen); + proto_tree_add_text (evpd_tree, tvb, offset+4, idlen, + "Identifier: %s", + tvb_bytes_to_str (tvb, offset+4, + idlen)); + plen -= idlen; + offset += idlen; + } + break; + case SCSI_EVPD_DEVSERNUM: + str[0] = '\0'; + tvb_get_nstringz0 (tvb, offset, plen, str); + proto_tree_add_text (evpd_tree, tvb, offset, plen, + "Product Serial Number: %s", str); + break; + } + } +} + +static void +dissect_scsi_cmddt (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, guint tot_len) +{ + proto_tree *cmdt_tree; + proto_item *ti; + guint opcode, plen, i; + guint8 flags; + + if (tree) { + plen = tvb_get_guint8 (tvb, offset+5); + ti = proto_tree_add_text (tree, tvb, offset, plen, "Command Data"); + cmdt_tree = proto_item_add_subtree (ti, ett_scsi_page); + + proto_tree_add_text (cmdt_tree, tvb, offset, 1, + "Peripheral Qualifier: 0x%x", + (tvb_get_guint8 (tvb, offset) & 0xF0)>>4); + proto_tree_add_item (cmdt_tree, hf_scsi_inq_devtype, tvb, offset, + 1, 0); + proto_tree_add_text (cmdt_tree, tvb, offset+1, 1, "Support: %s", + match_strval (tvb_get_guint8 (tvb, offset+1) & 0x7, + scsi_cmdt_supp_val)); + proto_tree_add_text (cmdt_tree, tvb, offset+2, 1, "Version: %s", + val_to_str (tvb_get_guint8 (tvb, offset+2), + scsi_verdesc_val, + "Unknown (0x%02x)")); + proto_tree_add_text (cmdt_tree, tvb, offset+5, 1, "CDB Size: %u", + plen); + } +} + +void +dissect_scsi_inquiry (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb, + guint32 payload_len, scsi_task_data_t *cdata) +{ + guint8 flags, i; + gchar str[32]; + guint tot_len, pcode, plen, replen; + conversation_t *conversation; + scsi_device_type dev = 0; + scsi_devtype_data_t *devdata = NULL; + scsi_devtype_key_t dkey, *req_key; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + if (cdata != NULL) { + cdata->flags = flags; + } + + proto_tree_add_uint_format (tree, hf_scsi_inquiry_flags, tvb, offset, 1, + flags, "CMDT = %u, EVPD = %u", + flags & 0x2, flags & 0x1); + if (flags & 0x1) { + proto_tree_add_item (tree, hf_scsi_inquiry_evpd_page, tvb, offset+1, + 1, 0); + } + else if (flags & 0x2) { + proto_tree_add_item (tree, hf_scsi_inquiry_cmdt_page, tvb, offset+1, + 1, 0); + } + + proto_tree_add_uint (tree, hf_scsi_alloclen, tvb, offset+3, 1, 0); + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else if (!isreq) { + if (cdata && (cdata->flags & 0x1)) { + dissect_scsi_evpd (tvb, pinfo, tree, offset, payload_len); + return; + } + else if (cdata && (cdata->flags & 0x2)) { + dissect_scsi_cmddt (tvb, pinfo, tree, offset, payload_len); + return; + } + + /* Add device type to list of known devices & their types */ + COPY_ADDRESS (&(dkey.devid), &(pinfo->src)); + devdata = (scsi_devtype_data_t *)g_hash_table_lookup (scsidev_req_hash, + &dkey); + if (!devdata) { + req_key = g_mem_chunk_alloc (scsidev_req_keys); + COPY_ADDRESS (&(req_key->devid), &(pinfo->src)); + + devdata = g_mem_chunk_alloc (scsidev_req_vals); + devdata->devtype = tvb_get_guint8 (tvb, offset) & 0x10; + + g_hash_table_insert (scsidev_req_hash, req_key, devdata); + } + + proto_tree_add_text (tree, tvb, offset, 1, "Peripheral Qualifier: 0x%x", + (tvb_get_guint8 (tvb, offset) & 0xF0)>>4); + proto_tree_add_item (tree, hf_scsi_inq_devtype, tvb, offset, 1, 0); + proto_tree_add_item (tree, hf_scsi_inq_version, tvb, offset+2, 1, 0); + + flags = tvb_get_guint8 (tvb, offset+3); + proto_tree_add_item_hidden (tree, hf_scsi_inq_normaca, tvb, + offset+3, 1, 0); + proto_tree_add_text (tree, tvb, offset+3, 1, "NormACA: %u, HiSup: %u", + ((flags & 0x20) >> 5), ((flags & 0x10) >> 4)); + tot_len = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_text (tree, tvb, offset+4, 1, "Additional Length: %u", + tot_len); + flags = tvb_get_guint8 (tvb, offset+6); + proto_tree_add_text (tree, tvb, offset+6, 1, + "BQue: %u, SES: %u, MultiP: %u, Addr16: %u", + ((flags & 0x80) >> 7), (flags & 0x40) >> 6, + (flags & 10) >> 4, (flags & 0x01)); + flags = tvb_get_guint8 (tvb, offset+7); + proto_tree_add_text (tree, tvb, offset+7, 1, + "RelAdr: %u, Linked: %u, CmdQue: %u", + (flags & 0x80) >> 7, (flags & 0x08) >> 3, + (flags & 0x02) >> 1); + tvb_get_nstringz0 (tvb, offset+8, 8, str); + proto_tree_add_text (tree, tvb, offset+8, 8, "Vendor Id: %s", str); + tvb_get_nstringz0 (tvb, offset+16, 16, str); + proto_tree_add_text (tree, tvb, offset+16, 16, "Product ID: %s", str); + tvb_get_nstringz0 (tvb, offset+32, 4, str); + proto_tree_add_text (tree, tvb, offset+32, 4, "Product Revision: %s", + str); + + offset += 58; + if ((tot_len > 58) && tvb_bytes_exist (tvb, offset, 16)) { + for (i = 0; i < 8; i++) { + proto_tree_add_text (tree, tvb, offset, 2, + "Vendor Descriptor %u: %s", + i, + val_to_str (tvb_get_ntohs (tvb, offset), + scsi_verdesc_val, + "Unknown (0x%04x)")); + offset += 2; + } + } + } +} + +static void +dissect_scsi_extcopy (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + +} + +static void +dissect_scsi_logselect (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_logsel_flags, tvb, offset, 1, + flags, "PCR = %u, SP = %u", flags & 0x2, + flags & 0x1); + proto_tree_add_uint_format (tree, hf_scsi_log_pc, tvb, offset+1, 1, + tvb_get_guint8 (tvb, offset+1), + "PC: 0x%x", flags & 0xC0); + proto_tree_add_item (tree, hf_scsi_paramlen16, tvb, offset+6, 2, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else { + } +} + +static void +dissect_scsi_logsense (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_logsns_flags, tvb, offset, 1, + flags, "PPC = %u, SP = %u", flags & 0x2, + flags & 0x1); + proto_tree_add_uint_format (tree, hf_scsi_log_pc, tvb, offset+1, 1, + tvb_get_guint8 (tvb, offset+1), + "PC: 0x%x", flags & 0xC0); + proto_tree_add_item (tree, hf_scsi_logsns_pagecode, tvb, offset+1, + 1, 0); + proto_tree_add_text (tree, tvb, offset+4, 2, "Parameter Pointer: 0x%04x", + tvb_get_ntohs (tvb, offset+4)); + proto_tree_add_item (tree, hf_scsi_alloclen16, tvb, offset+6, 2, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else { + } +} + +static guint8 +dissect_scsi_modepage (tvbuff_t *tvb, packet_info *pinfo, proto_tree *scsi_tree, + guint offset) +{ + guint8 pcode, plen, flags, proto; + proto_tree *tree; + proto_item *ti; + + pcode = tvb_get_guint8 (tvb, offset); + plen = tvb_get_guint8 (tvb, offset+1); + + ti = proto_tree_add_text (scsi_tree, tvb, offset, plen+2, "%s Mode Page", + val_to_str (pcode & 0x3F, scsi_modesns_page_val, + "Unknown (0x%08x)")); + tree = proto_item_add_subtree (ti, ett_scsi_page); + proto_tree_add_text (tree, tvb, offset, 1, "PS: %u", (pcode & 0x80) >> 8); + + proto_tree_add_item (tree, hf_scsi_modesns_pagecode, tvb, offset, 1, 0); + proto_tree_add_text (tree, tvb, offset+1, 1, "Page Length: %u", + plen); + + if (!tvb_bytes_exist (tvb, offset, plen)) { + return (plen + 2); + } + + pcode &= 0x3F; + switch (pcode) { + case SCSI_MODEPAGE_CTL: + flags = tvb_get_guint8 (tvb, offset+2); + proto_tree_add_item (tree, hf_scsi_modesns_tst, tvb, offset+2, 1, 0); + proto_tree_add_text (tree, tvb, offset+2, 1, + "Global Logging Target Save Disable: %u, Report Log Exception Condition: %u", + (flags & 0x2) >> 1, (flags & 0x1)); + flags = tvb_get_guint8 (tvb, offset+3); + proto_tree_add_item (tree, hf_scsi_modesns_qmod, tvb, offset+3, 1, 0); + proto_tree_add_item (tree, hf_scsi_modesns_qerr, tvb, offset+3, 1, 0); + proto_tree_add_text (tree, tvb, offset+3, 1, "Disable Queuing: %u", + flags & 0x1); + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_item (tree, hf_scsi_modesns_rac, tvb, offset+4, 1, 0); + proto_tree_add_item (tree, hf_scsi_modesns_tas, tvb, offset+4, 1, 0); + proto_tree_add_text (tree, tvb, offset+4, 1, + "SWP: %u, RAERP: %u, UAAERP: %u, EAERP: %u", + (flags & 0x8) >> 3, (flags & 0x4) >> 2, + (flags & 0x2) >> 2, (flags & 0x1)); + proto_tree_add_text (tree, tvb, offset+5, 1, "Autoload Mode: 0x%x", + tvb_get_guint8 (tvb, offset+5) & 0x7); + proto_tree_add_text (tree, tvb, offset+6, 2, + "Ready AER Holdoff Period: %u ms", + tvb_get_ntohs (tvb, offset+6)); + proto_tree_add_text (tree, tvb, offset+8, 2, + "Busy Timeout Period: %u ms", + tvb_get_ntohs (tvb, offset+8)*100); + proto_tree_add_text (tree, tvb, offset+10, 2, + "Extended Self-Test Completion Time: %u", + tvb_get_ntohs (tvb, offset+10)); + break; + case SCSI_MODEPAGE_DISCON: + proto_tree_add_text (tree, tvb, offset+2, 1, "Buffer Full Ratio: %u", + tvb_get_guint8 (tvb, offset+2)); + proto_tree_add_text (tree, tvb, offset+3, 1, "Buffer Empty Ratio: %u", + tvb_get_guint8 (tvb, offset+3)); + proto_tree_add_text (tree, tvb, offset+4, 2, "Bus Inactivity Limit: %u", + tvb_get_ntohs (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+6, 2, "Disconnect Time Limit: %u", + tvb_get_ntohs (tvb, offset+6)); + proto_tree_add_text (tree, tvb, offset+8, 2, "Connect Time Limit: %u", + tvb_get_ntohs (tvb, offset+8)); + proto_tree_add_text (tree, tvb, offset+10, 2, + "Maximum Burst Size: %u bytes", + tvb_get_ntohs (tvb, offset+10)*512); + flags = tvb_get_guint8 (tvb, offset+12); + proto_tree_add_text (tree, tvb, offset+12, 1, + "EMDP: %u, FAA: %u, FAB: %u, FAC: %u", + (flags & 0x80) >> 7, (flags & 0x40) >> 6, + (flags & 0x20) >> 5, (flags & 0x10) >> 4); + proto_tree_add_text (tree, tvb, offset+14, 2, + "First Burst Size: %u bytes", + tvb_get_ntohs (tvb, offset+14)*512); + break; + case SCSI_MODEPAGE_INFOEXCP: + flags = tvb_get_guint8 (tvb, offset+2); + proto_tree_add_text (tree, tvb, offset+2, 1, + "Perf: %u, EBF: %u, EWasc: %u, DExcpt: %u, Test: %u, LogErr: %u", + (flags & 0x80) >> 7, (flags & 0x20) >> 5, + (flags & 0x10) >> 4, (flags & 0x08) >> 3, + (flags & 0x04) >> 2, (flags & 0x01)); + if (!((flags & 0x10) >> 4) && ((flags & 0x08) >> 3)) { + proto_tree_add_item_hidden (tree, hf_scsi_modesns_errrep, tvb, + offset+3, 1, 0); + } + else { + proto_tree_add_item (tree, hf_scsi_modesns_errrep, tvb, offset+3, 1, 0); + } + proto_tree_add_text (tree, tvb, offset+4, 4, "Interval Timer: %u", + tvb_get_ntohl (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+8, 4, "Report Count: %u", + tvb_get_ntohl (tvb, offset+8)); + break; + case SCSI_MODEPAGE_PWR: + flags = tvb_get_guint8 (tvb, offset+3); + proto_tree_add_text (tree, tvb, offset+3, 1, "Idle: %u, Standby: %u", + (flags & 0x2) >> 1, (flags & 0x1)); + proto_tree_add_text (tree, tvb, offset+4, 2, + "Idle Condition Timer: %u ms", + tvb_get_ntohs (tvb, offset+4) * 100); + proto_tree_add_text (tree, tvb, offset+6, 2, + "Standby Condition Timer: %u ms", + tvb_get_ntohs (tvb, offset+6) * 100); + break; + case SCSI_MODEPAGE_LUN: + break; + case SCSI_MODEPAGE_PORT: + proto = tvb_get_guint8 (tvb, offset+2) & 0x0F; + proto_tree_add_item (tree, hf_scsi_protocol, tvb, offset+2, 1, 0); + if (proto == SCSI_PROTO_FCP) { + flags = tvb_get_guint8 (tvb, offset+3); + proto_tree_add_text (tree, tvb, offset+3, 1, + "DTFD: %u, PLPB: %u, DDIS: %u, DLM: %u, RHA: %u, ALWI: %u, DTIPE: %u, DTOLI:%u", + (flags & 0x80) >> 7, (flags & 0x40) >> 6, + (flags & 0x20) >> 5, (flags & 0x10) >> 4, + (flags & 0x08) >> 3, (flags & 0x04) >> 2, + (flags & 0x02) >> 1, (flags & 0x1)); + proto_tree_add_text (tree, tvb, offset+6, 1, "RR_TOV Units: %s", + val_to_str (tvb_get_guint8 (tvb, offset+6) & 0x7, + scsi_fcp_rrtov_val, + "Unknown (0x%02x)")); + proto_tree_add_text (tree, tvb, offset+7, 1, "RR_TOV: %u", + tvb_get_guint8 (tvb, offset+7)); + } + else if (proto == SCSI_PROTO_iSCSI) { + } + else { + } + break; + case SCSI_MODEPAGE_FMTDEV: + proto_tree_add_text (tree, tvb, offset+2, 2, "Tracks Per Zone: %u", + tvb_get_ntohs (tvb, offset+2)); + proto_tree_add_text (tree, tvb, offset+4, 2, + "Alternate Sectors Per Zone: %u", + tvb_get_ntohs (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+6, 2, + "Alternate Tracks Per Zone: %u", + tvb_get_ntohs (tvb, offset+6)); + proto_tree_add_text (tree, tvb, offset+8, 2, + "Alternate Tracks Per LU: %u", + tvb_get_ntohs (tvb, offset+8)); + proto_tree_add_text (tree, tvb, offset+10, 2, "Sectors Per Track: %u", + tvb_get_ntohs (tvb, offset+10)); + proto_tree_add_text (tree, tvb, offset+12, 2, + "Data Bytes Per Physical Sector: %u", + tvb_get_ntohs (tvb, offset+12)); + proto_tree_add_text (tree, tvb, offset+14, 2, "Interleave: %u", + tvb_get_ntohs (tvb, offset+14)); + proto_tree_add_text (tree, tvb, offset+16, 2, "Track Skew Factor: %u", + tvb_get_ntohs (tvb, offset+16)); + proto_tree_add_text (tree, tvb, offset+18, 2, + "Cylinder Skew Factor: %u", + tvb_get_ntohs (tvb, offset+18)); + flags = tvb_get_guint8 (tvb, offset+20); + proto_tree_add_text (tree, tvb, offset+20, 1, + "SSEC: %u, HSEC: %u, RMB: %u, SURF: %u", + (flags & 0x80) >> 7, (flags & 0x40) >> 6, + (flags & 0x20) >> 5, (flags & 0x10) >> 4); + break; + case SCSI_MODEPAGE_RDWRERR: + flags = tvb_get_guint8 (tvb, offset+2); + proto_tree_add_text (tree, tvb, offset+2, 1, + "AWRE: %u, ARRE: %u, TB: %u, RC: %u, EER: %u, PER: %u, DTE: %u, DCR: %u", + (flags & 0x80) >> 7, (flags & 0x40) >> 6, + (flags & 0x20) >> 5, (flags & 0x10) >> 4, + (flags & 0x08) >> 3, (flags & 0x04) >> 2, + (flags & 0x02) >> 1, (flags & 0x01)); + proto_tree_add_text (tree, tvb, offset+3, 1, "Read Retry Count: %u", + tvb_get_guint8 (tvb, offset+3)); + proto_tree_add_text (tree, tvb, offset+4, 1, "Correction Span: %u", + tvb_get_guint8 (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+5, 1, "Head Offset Count: %u", + tvb_get_guint8 (tvb, offset+5)); + proto_tree_add_text (tree, tvb, offset+6, 1, + "Data Strobe Offset Count: %u", + tvb_get_guint8 (tvb, offset+6)); + proto_tree_add_text (tree, tvb, offset+8, 1, "Write Retry Count: %u", + tvb_get_guint8 (tvb, offset+8)); + proto_tree_add_text (tree, tvb, offset+10, 2, + "Recovery Time Limit: %u ms", + tvb_get_ntohs (tvb, offset+10)); + break; + case SCSI_MODEPAGE_DISKGEOM: + proto_tree_add_text (tree, tvb, offset+2, 3, "Number of Cylinders: %u", + tvb_get_ntoh24 (tvb, offset+2)); + proto_tree_add_text (tree, tvb, offset+5, 1, "Number of Heads: %u", + tvb_get_guint8 (tvb, offset+5)); + proto_tree_add_text (tree, tvb, offset+6, 3, + "Starting Cyl Pre-compensation: %u", + tvb_get_ntoh24 (tvb, offset+6)); + proto_tree_add_text (tree, tvb, offset+9, 3, + "Starting Cyl-reduced Write Current: %u", + tvb_get_ntoh24 (tvb, offset+9)); + proto_tree_add_text (tree, tvb, offset+12, 2, "Device Step Rate: %u", + tvb_get_ntohs (tvb, offset+12)); + proto_tree_add_text (tree, tvb, offset+14, 3, "Landing Zone Cyl: %u", + tvb_get_ntoh24 (tvb, offset+14)); + proto_tree_add_text (tree, tvb, offset+18, 1, "Rotational Offset: %u", + tvb_get_guint8 (tvb, offset+18)); + proto_tree_add_text (tree, tvb, offset+20, 2, + "Medium Rotation Rate: %u", + tvb_get_ntohs (tvb, offset+20)); + break; + case SCSI_MODEPAGE_FLEXDISK: + break; + case SCSI_MODEPAGE_VERERR: + break; + case SCSI_MODEPAGE_CACHE: + flags = tvb_get_guint8 (tvb, offset+2); + proto_tree_add_text (tree, tvb, offset+2, 1, + "IC: %u, ABPF: %u, CAP %u, Disc: %u, Size: %u, WCE: %u, MF: %u, RCD: %u", + (flags & 0x80) >> 7, (flags & 0x40) >> 6, + (flags & 0x20) >> 5, (flags & 0x10) >> 4, + (flags & 0x08) >> 3, (flags & 0x04) >> 2, + (flags & 0x02) >> 1, (flags & 0x01)); + flags = tvb_get_guint8 (tvb, offset+3); + proto_tree_add_text (tree, tvb, offset+3, 1, + "Demand Read Retention Priority: %u, Write Retention Priority: %u", + (flags & 0xF0) >> 4, (flags & 0x0F)); + proto_tree_add_text (tree, tvb, offset+4, 2, + "Disable Pre-fetch Xfer Len: %u", + tvb_get_ntohs (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+6, 2, "Minimum Pre-Fetch: %u", + tvb_get_ntohs (tvb, offset+6)); + proto_tree_add_text (tree, tvb, offset+8, 2, "Maximum Pre-Fetch: %u", + tvb_get_ntohs (tvb, offset+8)); + proto_tree_add_text (tree, tvb, offset+10, 2, + "Maximum Pre-Fetch Ceiling: %u", + tvb_get_ntohs (tvb, offset+10)); + flags = tvb_get_guint8 (tvb, offset+12); + proto_tree_add_text (tree, tvb, offset+12, 1, + "FSW: %u, LBCSS: %u, DRA: %u, Vendor Specific: %u", + (flags & 0x80) >> 7, (flags & 0x40) >> 6, + (flags & 0x20) >> 5, (flags & 0x1F) >> 4); + proto_tree_add_text (tree, tvb, offset+13, 1, + "Number of Cache Segments: %u", + tvb_get_guint8 (tvb, offset+13)); + proto_tree_add_text (tree, tvb, offset+14, 2, "Cache Segment Size: %u", + tvb_get_ntohs (tvb, offset+14)); + proto_tree_add_text (tree, tvb, offset+17, 3, + "Non-Cache Segment Size: %u", + tvb_get_ntoh24 (tvb, offset+17)); + break; + case SCSI_MODEPAGE_PERDEV: + break; + case SCSI_MODEPAGE_MEDTYPE: + break; + case SCSI_MODEPAGE_NOTPART: + break; + case SCSI_MODEPAGE_XORCTL: + break; + default: + proto_tree_add_text (tree, tvb, offset, plen, + "Unknown Page"); + break; + } + return (plen+2); +} + +static void +dissect_scsi_modeselect6 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb, + guint payload_len) +{ + guint8 flags, pcode; + guint tot_len, desclen, plen; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_modesel_flags, tvb, offset, 1, + flags, "PF = %u, SP = %u", flags & 0x10, + flags & 0x1); + proto_tree_add_item (tree, hf_scsi_paramlen, tvb, offset+3, 1, 0); + + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else { + /* Mode Parameter has the following format: + * Mode Parameter Header + * - Mode Data Len, Medium Type, Dev Specific Parameter, + * Blk Desc Len + * Block Descriptor (s) + * - Number of blocks, density code, block length + * Page (s) + * - Page code, Page length, Page Parameters + */ + tot_len = tvb_get_guint8 (tvb, offset); + proto_tree_add_text (tree, tvb, offset, 1, "Mode Data Length: %u", + tot_len); + proto_tree_add_text (tree, tvb, offset+1, 1, "Medium Type: 0x%02x", + tvb_get_guint8 (tvb, offset+1)); + proto_tree_add_text (tree, tvb, offset+2, 1, + "Device-Specific Parameter: 0x%02x", + tvb_get_guint8 (tvb, offset+2)); + desclen = tvb_get_guint8 (tvb, offset+3); + proto_tree_add_text (tree, tvb, offset+3, 1, + "Block Descriptor Length: %u", desclen); + offset = 4; + tot_len -= 3; /* tot_len does not include the len field */ + if (desclen) { + proto_tree_add_text (tree, tvb, offset, 4, "No. of Blocks: %u", + tvb_get_ntohl (tvb, offset)); + proto_tree_add_text (tree, tvb, offset+4, 1, "Density Code: 0x%02x", + tvb_get_guint8 (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+5, 3, "Block Length: %u", + tvb_get_ntoh24 (tvb, offset+5)); + offset += 8; /* increment the offset by 8 */ + tot_len -= 8; /* subtract by the block desc len */ + } + /* offset points to the start of the mode page */ + while ((tot_len > offset) && tvb_bytes_exist (tvb, offset, 2)) { + plen = dissect_scsi_modepage (tvb, pinfo, tree, offset); + offset += plen; + } + } +} + +static void +dissect_scsi_modeselect10 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb, + guint payload_len) +{ + guint8 flags, pcode; + gboolean longlba; + guint tot_len, desclen, plen; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_modesel_flags, tvb, offset, 1, + flags, "PF = %u, SP = %u", flags & 0x10, + flags & 0x1); + proto_tree_add_item (tree, hf_scsi_paramlen16, tvb, offset+6, 2, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else { + /* Mode Parameter has the following format: + * Mode Parameter Header + * - Mode Data Len, Medium Type, Dev Specific Parameter, + * Blk Desc Len + * Block Descriptor (s) + * - Number of blocks, density code, block length + * Page (s) + * - Page code, Page length, Page Parameters + */ + tot_len = tvb_get_ntohs (tvb, offset); + proto_tree_add_text (tree, tvb, offset, 2, "Mode Data Length: %u", + tot_len); + proto_tree_add_text (tree, tvb, offset+2, 1, "Medium Type: 0x%02x", + tvb_get_guint8 (tvb, offset+2)); + proto_tree_add_text (tree, tvb, offset+3, 1, + "Device-Specific Parameter: 0x%02x", + tvb_get_guint8 (tvb, offset+3)); + longlba = tvb_get_guint8 (tvb, offset+4) & 0x1; + proto_tree_add_text (tree, tvb, offset+4, 1, "LongLBA: %u", longlba); + desclen = tvb_get_guint8 (tvb, offset+6); + proto_tree_add_text (tree, tvb, offset+6, 1, + "Block Descriptor Length: %u", desclen); + offset = 8; + tot_len -= 6; /* tot_len does not include the len field */ + if (desclen) { + proto_tree_add_text (tree, tvb, offset, 8, "No. of Blocks: %s", + bytes_to_str (tvb_get_ptr (tvb, offset, 8), + 8)); + proto_tree_add_text (tree, tvb, offset+8, 1, "Density Code: 0x%02x", + tvb_get_guint8 (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+12, 4, "Block Length: %u", + tvb_get_ntohl (tvb, offset+12)); + offset += 16; /* increment the offset by 8 */ + tot_len -= 16; /* subtract by the block desc len */ + } + /* offset points to the start of the mode page */ + while ((tot_len > offset) && tvb_bytes_exist (tvb, offset, 2)) { + offset += dissect_scsi_modepage (tvb, pinfo, tree, offset); + } + } +} + +static void +dissect_scsi_modesense6 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb, + guint payload_len) +{ + guint8 flags, pcode; + guint tot_len, desclen, plen; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_modesns_flags, tvb, offset, 1, + flags, "DBD = %u", flags & 0x8); + proto_tree_add_item (tree, hf_scsi_modesns_pc, tvb, offset+1, 1, 0); + proto_tree_add_item (tree, hf_scsi_modesns_pagecode, tvb, offset+1, 1, + 0); + proto_tree_add_item (tree, hf_scsi_alloclen, tvb, offset+3, 1, 0); + + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else { + /* Mode sense response has the following format: + * Mode Parameter Header + * - Mode Data Len, Medium Type, Dev Specific Parameter, + * Blk Desc Len + * Block Descriptor (s) + * - Number of blocks, density code, block length + * Page (s) + * - Page code, Page length, Page Parameters + */ + tot_len = tvb_get_guint8 (tvb, offset); + proto_tree_add_text (tree, tvb, offset, 1, "Mode Data Length: %u", + tot_len); + proto_tree_add_text (tree, tvb, offset+1, 1, "Medium Type: 0x%02x", + tvb_get_guint8 (tvb, offset+1)); + proto_tree_add_text (tree, tvb, offset+2, 1, + "Device-Specific Parameter: 0x%02x", + tvb_get_guint8 (tvb, offset+2)); + desclen = tvb_get_guint8 (tvb, offset+3); + proto_tree_add_text (tree, tvb, offset+3, 1, + "Block Descriptor Length: %u", desclen); + offset = 4; + /* The actual payload is the min of the length in the response & the + * space allocated by the initiator as specified in the request. + */ + if (payload_len && (tot_len > payload_len)) + tot_len = payload_len; + if (desclen) { + proto_tree_add_text (tree, tvb, offset, 4, "No. of Blocks: %u", + tvb_get_ntohl (tvb, offset)); + proto_tree_add_text (tree, tvb, offset+4, 1, "Density Code: 0x%02x", + tvb_get_guint8 (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+5, 3, "Block Length: %u", + tvb_get_ntoh24 (tvb, offset+5)); + offset += 8; /* increment the offset by 8 */ + } + /* offset points to the start of the mode page */ + while ((tot_len > offset) && tvb_bytes_exist (tvb, offset, 2)) { + plen = dissect_scsi_modepage (tvb, pinfo, tree, offset); + offset += plen; + } + } +} + +static void +dissect_scsi_modesense10 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb, + guint payload_len) +{ + guint8 flags, pcode; + gboolean longlba; + guint tot_len, desclen, plen; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_modesns_flags, tvb, offset, 1, + flags, "LLBAA = %u, DBD = %u", flags & 0x10, + flags & 0x8); + proto_tree_add_item (tree, hf_scsi_modesns_pc, tvb, offset+1, 1, 0); + proto_tree_add_item (tree, hf_scsi_modesns_pagecode, tvb, offset+1, 1, + 0); + proto_tree_add_item (tree, hf_scsi_alloclen16, tvb, offset+6, 2, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else { + /* Mode sense response has the following format: + * Mode Parameter Header + * - Mode Data Len, Medium Type, Dev Specific Parameter, + * Blk Desc Len + * Block Descriptor (s) + * - Number of blocks, density code, block length + * Page (s) + * - Page code, Page length, Page Parameters + */ + tot_len = tvb_get_ntohs (tvb, offset); + proto_tree_add_text (tree, tvb, offset, 2, "Mode Data Length: %u", + tot_len); + proto_tree_add_text (tree, tvb, offset+2, 1, "Medium Type: 0x%02x", + tvb_get_guint8 (tvb, offset+2)); + proto_tree_add_text (tree, tvb, offset+3, 1, + "Device-Specific Parameter: 0x%02x", + tvb_get_guint8 (tvb, offset+3)); + longlba = tvb_get_guint8 (tvb, offset+4) & 0x1; + proto_tree_add_text (tree, tvb, offset+4, 1, "LongLBA: %u", longlba); + desclen = tvb_get_guint8 (tvb, offset+6); + proto_tree_add_text (tree, tvb, offset+6, 1, + "Block Descriptor Length: %u", desclen); + offset = 8; + tot_len -= 6; /* tot_len does not include the len field */ + if (desclen) { + proto_tree_add_text (tree, tvb, offset, 8, "No. of Blocks: %s", + bytes_to_str (tvb_get_ptr (tvb, offset, 8), + 8)); + proto_tree_add_text (tree, tvb, offset+8, 1, "Density Code: 0x%02x", + tvb_get_guint8 (tvb, offset+4)); + proto_tree_add_text (tree, tvb, offset+12, 4, "Block Length: %u", + tvb_get_ntohl (tvb, offset+12)); + offset += 16; /* increment the offset by 8 */ + tot_len -= 16; /* subtract by the block desc len */ + } + /* offset points to the start of the mode page */ + while ((tot_len > offset) && tvb_bytes_exist (tvb, offset, 2)) { + offset += dissect_scsi_modepage (tvb, pinfo, tree, offset); + } + } +} + +static void +dissect_scsi_persresvin (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb, + scsi_task_data_t *cdata, guint payload_len) +{ + guint8 flags; + int numrec, i; + guint len; + + if (!tree) + return; + + if (isreq && iscdb) { + proto_tree_add_item (tree, hf_scsi_persresvin_svcaction, tvb, offset+1, + 1, 0); + proto_tree_add_item (tree, hf_scsi_alloclen16, tvb, offset+6, 2, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + /* We store the service action since we want to interpret the data */ + cdata->flags = tvb_get_guint8 (tvb, offset+1); + } + else { + if (cdata) { + flags = cdata->flags; + } + else { + flags = 0xFF; + } + proto_tree_add_text (tree, tvb, offset, 4, "Generation Number: 0x%08x", + tvb_get_ntohl (tvb, offset)); + len = tvb_get_ntohl (tvb, offset+4); + proto_tree_add_text (tree, tvb, offset, 4, "Additional Length: %u", + len); + len = (payload_len > len) ? len : payload_len; + + if ((flags & 0x1F) == SCSI_SPC2_RESVIN_SVCA_RDKEYS) { + /* XXX - what if len is < 8? That may be illegal, but + that doesn't make it impossible.... */ + numrec = (len - 8)/8; + offset += 8; + + for (i = 0; i < numrec; i++) { + proto_tree_add_item (tree, hf_scsi_persresv_key, tvb, offset, + 8, 0); + offset -= 8; + } + } + else if ((flags & 0x1F) == SCSI_SPC2_RESVIN_SVCA_RDRESV) { + proto_tree_add_item (tree, hf_scsi_persresv_key, tvb, offset+8, + 8, 0); + proto_tree_add_item (tree, hf_scsi_persresv_scopeaddr, tvb, + offset+8, 4, 0); + proto_tree_add_item (tree, hf_scsi_persresv_scope, tvb, offset+13, + 1, 0); + proto_tree_add_item (tree, hf_scsi_persresv_type, tvb, offset+13, + 1, 0); + } + } +} + +static void +dissect_scsi_persresvout (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb, + scsi_task_data_t *cdata, guint payload_len) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + proto_tree_add_item (tree, hf_scsi_persresvin_svcaction, tvb, offset, + 1, 0); + proto_tree_add_item (tree, hf_scsi_persresv_scope, tvb, offset+1, 1, 0); + proto_tree_add_item (tree, hf_scsi_persresv_type, tvb, offset+1, 1, 0); + proto_tree_add_item (tree, hf_scsi_paramlen16, tvb, offset+6, 2, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else { + } +} + +static void +dissect_scsi_release6 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_release10 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_release_flags, tvb, offset, 1, + flags, + "Flags: 3rd Party ID = %u, LongID = %u", + flags & 0x10, flags & 0x2); + if ((flags & 0x12) == 0x10) { + proto_tree_add_item (tree, hf_scsi_release_thirdpartyid, tvb, + offset+2, 1, 0); + } + proto_tree_add_item (tree, hf_scsi_paramlen16, tvb, offset+6, 2, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_reportdeviceid (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + +} + +static void +dissect_scsi_reportluns (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + guint numelem, i; + + if (!tree) + return; + + if (isreq && iscdb) { + proto_tree_add_item (tree, hf_scsi_alloclen32, tvb, offset+5, 4, 0); + + flags = tvb_get_guint8 (tvb, offset+10); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+10, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else if (!isreq) { + numelem = tvb_get_ntohl (tvb, offset); + proto_tree_add_text (tree, tvb, offset, 4, "LUN List Length: %u", + numelem); + offset += 8; + for (i = 0; i < numelem/8; i++) { + if (!tvb_get_guint8 (tvb, offset)) + proto_tree_add_item (tree, hf_scsi_rluns_lun, tvb, offset+1, 1, + 0); + else + proto_tree_add_item (tree, hf_scsi_rluns_multilun, tvb, offset, + 8, 0); + offset += 8; + } + } +} + +static void +dissect_scsi_reqsense (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + proto_tree_add_item (tree, hf_scsi_alloclen, tvb, offset+3, 1, 0); + + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_reserve6 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_reserve10 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_release_flags, tvb, offset, 1, + flags, + "Flags: 3rd Party ID = %u, LongID = %u", + flags & 0x10, flags & 0x2); + if ((flags & 0x12) == 0x10) { + proto_tree_add_item (tree, hf_scsi_release_thirdpartyid, tvb, + offset+2, 1, 0); + } + proto_tree_add_item (tree, hf_scsi_paramlen16, tvb, offset+6, 2, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_testunitrdy (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_formatunit (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + proto_tree_add_uint_format (tree, hf_scsi_formatunit_flags, tvb, offset, + 1, flags, + "Flags: Longlist = %u, FMTDATA = %u, CMPLIST = %u", + flags & 0x20, flags & 0x8, flags & 0x4); + proto_tree_add_item (tree, hf_scsi_cdb_defectfmt, tvb, offset, 1, 0); + proto_tree_add_item (tree, hf_scsi_formatunit_vendor, tvb, offset+1, + 1, 0); + proto_tree_add_item (tree, hf_scsi_formatunit_interleave, tvb, offset+2, + 2, 0); + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_rdwr6 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (isreq) { + if (check_col (pinfo->cinfo, COL_INFO)) + col_append_fstr (pinfo->cinfo, COL_INFO, "(LBA: 0x%06x, Len: %u)", + tvb_get_ntoh24 (tvb, offset), + tvb_get_guint8 (tvb, offset+3)); + } + + if (tree && isreq && iscdb) { + proto_tree_add_item (tree, hf_scsi_rdwr6_lba, tvb, offset, 3, 0); + proto_tree_add_item (tree, hf_scsi_rdwr6_xferlen, tvb, offset+3, 1, 0); + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_rdwr10 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (isreq) { + if (check_col (pinfo->cinfo, COL_INFO)) + col_append_fstr (pinfo->cinfo, COL_INFO, "(LBA: 0x%08x, Len: %u)", + tvb_get_ntohl (tvb, offset+1), + tvb_get_ntohs (tvb, offset+6)); + } + + if (tree && isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_read_flags, tvb, offset, 1, + flags, + "DPO = %u, FUA = %u, RelAddr = %u", + flags & 0x10, flags & 0x8, flags & 0x1); + proto_tree_add_item (tree, hf_scsi_rdwr10_lba, tvb, offset+1, 4, 0); + proto_tree_add_item (tree, hf_scsi_rdwr10_xferlen, tvb, offset+6, 2, 0); + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_rdwr12 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (isreq) { + if (check_col (pinfo->cinfo, COL_INFO)) + col_append_fstr (pinfo->cinfo, COL_INFO, "(LBA: 0x%08x, Len: %u)", + tvb_get_ntohl (tvb, offset+1), + tvb_get_ntohl (tvb, offset+5)); + } + + if (tree && isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_read_flags, tvb, offset, 1, + flags, + "DPO = %u, FUA = %u, RelAddr = %u", + flags & 0x10, flags & 0x8, flags & 0x1); + proto_tree_add_item (tree, hf_scsi_rdwr10_lba, tvb, offset+1, 4, 0); + proto_tree_add_item (tree, hf_scsi_rdwr12_xferlen, tvb, offset+5, 4, 0); + flags = tvb_get_guint8 (tvb, offset+10); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+10, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_rdwr16 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (tree && isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_read_flags, tvb, offset, 1, + flags, + "DPO = %u, FUA = %u, RelAddr = %u", + flags & 0x10, flags & 0x8, flags & 0x1); + proto_tree_add_item (tree, hf_scsi_rdwr16_lba, tvb, offset+1, 8, 0); + proto_tree_add_item (tree, hf_scsi_rdwr12_xferlen, tvb, offset+9, 4, 0); + flags = tvb_get_guint8 (tvb, offset+14); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+14, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_readcapacity (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + guint len; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_readcapacity_flags, tvb, + offset, 1, flags, + "LongLBA = %u, RelAddr = %u", + flags & 0x2, flags & 0x1); + proto_tree_add_item (tree, hf_scsi_readcapacity_lba, tvb, offset+1, + 4, 0); + proto_tree_add_item (tree, hf_scsi_readcapacity_pmi, tvb, offset+7, + 1, 0); + + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } + else if (!iscdb) { + len = tvb_get_ntohl (tvb, offset); + proto_tree_add_text (tree, tvb, offset, 4, "LBA: %u (%u MB)", + len, len/(1024*1024)); + proto_tree_add_text (tree, tvb, offset+4, 4, "Block Length: %u bytes", + tvb_get_ntohl (tvb, offset+4)); + } +} + +static void +dissect_scsi_readdefdata10 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_readdefdata_flags, tvb, + offset, 1, flags, "PLIST = %u, GLIST = %u", + flags & 0x10, flags & 0x8); + proto_tree_add_item (tree, hf_scsi_cdb_defectfmt, tvb, offset, 1, 0); + proto_tree_add_item (tree, hf_scsi_alloclen16, tvb, offset+6, 2, 0); + flags = tvb_get_guint8 (tvb, offset+8); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+8, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_readdefdata12 (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_readdefdata_flags, tvb, + offset, 1, flags, "PLIST = %u, GLIST = %u", + flags & 0x10, flags & 0x8); + proto_tree_add_item (tree, hf_scsi_cdb_defectfmt, tvb, offset, 1, 0); + proto_tree_add_item (tree, hf_scsi_alloclen32, tvb, offset+5, 4, 0); + flags = tvb_get_guint8 (tvb, offset+10); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+10, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +static void +dissect_scsi_reassignblks (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, gboolean iscdb) +{ + guint8 flags; + + if (!tree) + return; + + if (isreq && iscdb) { + flags = tvb_get_guint8 (tvb, offset); + + proto_tree_add_uint_format (tree, hf_scsi_reassignblks_flags, tvb, + offset, 1, flags, + "LongLBA = %u, LongList = %u", + flags & 0x2, flags & 0x1); + flags = tvb_get_guint8 (tvb, offset+4); + proto_tree_add_uint_format (tree, hf_scsi_control, tvb, offset+4, 1, + flags, + "Vendor Unique = %u, NACA = %u, Link = %u", + flags & 0xC0, flags & 0x4, flags & 0x1); + } +} + +void +dissect_scsi_rsp (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + /* Nothing to do here, just blow up the data structures for this SCSI + * transaction + if (tree) + scsi_end_task (pinfo); + */ +} + +void +dissect_scsi_snsinfo (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, guint snslen) +{ + guint8 flags; + proto_item *ti; + proto_tree *sns_tree; + scsi_device_type dev = 0; + scsi_devtype_key_t dkey; + scsi_devtype_data_t *devdata; + + scsi_end_task (pinfo); + + if (tree) { + ti = proto_tree_add_protocol_format (tree, proto_scsi, tvb, offset, + snslen, "SCSI: SNS Info"); + sns_tree = proto_item_add_subtree (ti, ett_scsi); + + flags = tvb_get_guint8 (tvb, offset); + proto_tree_add_text (sns_tree, tvb, offset, 1, "Valid: %u", + (flags & 0x80) >> 7); + proto_tree_add_item (sns_tree, hf_scsi_sns_errtype, tvb, offset, 1, 0); + flags = tvb_get_guint8 (tvb, offset+2); + proto_tree_add_text (sns_tree, tvb, offset+2, 1, + "Filemark: %u, EOM: %u, ILI: %u", + (flags & 0x80) >> 7, (flags & 0x40) >> 6, + (flags & 0x20) >> 5); + proto_tree_add_item (sns_tree, hf_scsi_snskey, tvb, offset+2, 1, 0); + proto_tree_add_item (sns_tree, hf_scsi_snsinfo, tvb, offset+3, 4, 0); + proto_tree_add_item (sns_tree, hf_scsi_addlsnslen, tvb, offset+7, 1, 0); + proto_tree_add_text (sns_tree, tvb, offset+8, 4, + "Command-Specific Information: %s", + tvb_bytes_to_str (tvb, offset+8, 4)); + proto_tree_add_item (sns_tree, hf_scsi_ascascq, tvb, offset+12, 2, 0); + proto_tree_add_item_hidden (sns_tree, hf_scsi_asc, tvb, offset+12, 1, 0); + proto_tree_add_item_hidden (sns_tree, hf_scsi_ascq, tvb, offset+13, + 1, 0); + proto_tree_add_item (sns_tree, hf_scsi_fru, tvb, offset+14, 1, 0); + proto_tree_add_item (sns_tree, hf_scsi_sksv, tvb, offset+15, 1, 0); + proto_tree_add_text (sns_tree, tvb, offset+15, 3, + "Sense Key Specific: %s", + tvb_bytes_to_str (tvb, offset+15, 3)); + } +} + +void +dissect_scsi_cdb (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint start, guint cdblen) +{ + int offset = start; + proto_item *ti; + proto_tree *scsi_tree = NULL; + guint8 opcode; + scsi_cmnd_type cmd = 0; /* 0 is undefined type */ + scsi_device_type devtype = 0; + gchar *valstr; + conversation_t *conversation; + scsi_task_data_t *cdata; + scsi_task_key_t ckey, *req_key; + scsi_devtype_key_t dkey; + scsi_devtype_data_t *devdata; + + opcode = tvb_get_guint8 (tvb, offset); + + /* Identify target if possible */ + COPY_ADDRESS (&(dkey.devid), &pinfo->dst); + + devdata = (scsi_devtype_data_t *)g_hash_table_lookup (scsidev_req_hash, + &dkey); + if (devdata != NULL) { + devtype = devdata->devtype; + } + else { + devtype = (scsi_device_type)scsi_def_devtype; + } + + if ((valstr = match_strval (opcode, scsi_spc2_val)) == NULL) { + if (devtype == SCSI_DEV_SBC) { + valstr = match_strval (opcode, scsi_sbc2_val); + cmd = SCSI_CMND_SBC2; + } + else { + /* Right now, the only choices are SBC or SSC. If we ever expand + * this to decode other device types, this piece of code needs to + * be modified. + */ + valstr = match_strval (opcode, scsi_ssc2_val); + cmd = SCSI_CMND_SSC2; + } + } + else { + cmd = SCSI_CMND_SPC2; + } + + if (valstr != NULL) { + if (check_col (pinfo->cinfo, COL_INFO)) { + col_add_fstr (pinfo->cinfo, COL_INFO, "SCSI: %s", valstr); + } + } + else { + if (check_col (pinfo->cinfo, COL_INFO)) { + col_add_fstr (pinfo->cinfo, COL_INFO, "SCSI Command: 0x%02x", opcode); + } + } + + cdata = scsi_new_task (pinfo); + + if (cdata) { + cdata->opcode = opcode; + cdata->devtype = cmd; + } + + if (tree) { + ti = proto_tree_add_protocol_format (tree, proto_scsi, tvb, start, + cdblen, "SCSI CDB"); + scsi_tree = proto_item_add_subtree (ti, ett_scsi); + + if (valstr != NULL) { + if (cmd == SCSI_CMND_SPC2) { + proto_tree_add_uint_format (scsi_tree, hf_scsi_spcopcode, tvb, + offset, 1, + tvb_get_guint8 (tvb, offset), + "Opcode: %s (0x%02x)", valstr, + opcode); + } + else if (cmd == SCSI_CMND_SBC2) { + proto_tree_add_uint_format (scsi_tree, hf_scsi_sbcopcode, tvb, + offset, 1, + tvb_get_guint8 (tvb, offset), + "Opcode: %s (0x%02x)", valstr, + opcode); + } + else { + proto_tree_add_uint_format (scsi_tree, hf_scsi_sscopcode, tvb, + offset, 1, + tvb_get_guint8 (tvb, offset), + "Opcode: %s (0x%02x)", valstr, + opcode); + } + } + else { + proto_tree_add_item (scsi_tree, hf_scsi_sbcopcode, tvb, offset, 1, 0); + } + } + + if (cmd == SCSI_CMND_SPC2) { + switch (opcode) { + case SCSI_SPC2_INQUIRY: + dissect_scsi_inquiry (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE, 0, cdata); + break; + + case SCSI_SPC2_EXTCOPY: + dissect_scsi_extcopy (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_LOGSELECT: + dissect_scsi_logselect (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_LOGSENSE: + dissect_scsi_logsense (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_MODESELECT6: + dissect_scsi_modeselect6 (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE, 0); + break; + + case SCSI_SPC2_MODESELECT10: + dissect_scsi_modeselect10 (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE, 0); + break; + + case SCSI_SPC2_MODESENSE6: + dissect_scsi_modesense6 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE, 0); + break; + + case SCSI_SPC2_MODESENSE10: + dissect_scsi_modesense10 (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE, 0); + break; + + case SCSI_SPC2_PERSRESVIN: + dissect_scsi_persresvin (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE, cdata, 0); + break; + + case SCSI_SPC2_PERSRESVOUT: + dissect_scsi_persresvout (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE, cdata, 0); + break; + + case SCSI_SPC2_RELEASE6: + dissect_scsi_release6 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_RELEASE10: + dissect_scsi_release10 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_REPORTDEVICEID: + dissect_scsi_reportdeviceid (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE); + break; + + case SCSI_SPC2_REPORTLUNS: + dissect_scsi_reportluns (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_REQSENSE: + dissect_scsi_reqsense (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_RESERVE6: + dissect_scsi_reserve6 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_RESERVE10: + dissect_scsi_reserve10 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SPC2_TESTUNITRDY: + dissect_scsi_testunitrdy (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE); + break; + + default: + call_dissector (data_handle, tvb, pinfo, scsi_tree); + break; + } + } + else if (cmd == SCSI_CMND_SBC2) { + switch (opcode) { + + case SCSI_SBC2_FORMATUNIT: + dissect_scsi_formatunit (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SBC2_READ6: + dissect_scsi_rdwr6 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SBC2_READ10: + dissect_scsi_rdwr10 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SBC2_READ12: + dissect_scsi_rdwr12 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SBC2_READ16: + dissect_scsi_rdwr16 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SBC2_READCAPACITY: + dissect_scsi_readcapacity (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE); + break; + + case SCSI_SBC2_READDEFDATA10: + dissect_scsi_readdefdata10 (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE); + break; + + case SCSI_SBC2_READDEFDATA12: + dissect_scsi_readdefdata12 (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE); + break; + + case SCSI_SBC2_REASSIGNBLKS: + dissect_scsi_reassignblks (tvb, pinfo, scsi_tree, offset+1, + TRUE, TRUE); + break; + + case SCSI_SBC2_WRITE6: + dissect_scsi_rdwr6 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SBC2_WRITE10: + dissect_scsi_rdwr10 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SBC2_WRITE12: + dissect_scsi_rdwr12 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + case SCSI_SBC2_WRITE16: + dissect_scsi_rdwr16 (tvb, pinfo, scsi_tree, offset+1, TRUE, + TRUE); + break; + + default: + call_dissector (data_handle, tvb, pinfo, scsi_tree); + break; + } + } + else if (cmd == SCSI_CMND_SSC2) { + call_dissector (data_handle, tvb, pinfo, scsi_tree); + } +} + +static void +dissect_scsi (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ +} + +void +dissect_scsi_payload (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint offset, gboolean isreq, guint32 payload_len) +{ + proto_item *ti; + proto_tree *scsi_tree; + guint8 opcode = 0xFF; + scsi_cmnd_type cmd = 0; /* 0 is undefined type */ + gchar *valstr; + scsi_device_type dev = 0; + scsi_task_data_t *cdata = NULL; + scsi_devtype_key_t dkey; + scsi_devtype_data_t *devdata; + + cdata = scsi_find_task (pinfo); + + if (!cdata) { + /* we have no record of this exchange and so we can't dissect the + * payload + */ + return; + } + + opcode = cdata->opcode; + cmd = cdata->devtype; + + if (tree) { + if (cmd == SCSI_CMND_SPC2) { + ti = proto_tree_add_protocol_format (tree, proto_scsi, tvb, offset, + tvb_length (tvb), + "SCSI Payload (%s %s)", + val_to_str (opcode, + scsi_spc2_val, + "0x%02x"), + isreq ? "Request" : "Response"); + } + else if (cmd == SCSI_CMND_SBC2) { + ti = proto_tree_add_protocol_format (tree, proto_scsi, tvb, offset, + tvb_length (tvb), + "SCSI Payload (%s %s)", + val_to_str (opcode, + scsi_sbc2_val, + "0x%02x"), + isreq ? "Request" : "Response"); + } + else { + ti = proto_tree_add_protocol_format (tree, proto_scsi, tvb, offset, + tvb_length (tvb), + "SCSI Payload (0x%02x %s)", + opcode, + isreq ? "Request" : "Response"); + } + + scsi_tree = proto_item_add_subtree (ti, ett_scsi); + + if (cmd == SCSI_CMND_SPC2) { + switch (opcode) { + case SCSI_SPC2_INQUIRY: + dissect_scsi_inquiry (tvb, pinfo, scsi_tree, offset, isreq, + FALSE, payload_len, cdata); + break; + + case SCSI_SPC2_EXTCOPY: + dissect_scsi_extcopy (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_LOGSELECT: + dissect_scsi_logselect (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_LOGSENSE: + dissect_scsi_logsense (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_MODESELECT6: + dissect_scsi_modeselect6 (tvb, pinfo, scsi_tree, offset, + isreq, FALSE, payload_len); + break; + + case SCSI_SPC2_MODESELECT10: + dissect_scsi_modeselect10 (tvb, pinfo, scsi_tree, offset, + isreq, FALSE, payload_len); + break; + + case SCSI_SPC2_MODESENSE6: + dissect_scsi_modesense6 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE, payload_len); + break; + + case SCSI_SPC2_MODESENSE10: + dissect_scsi_modesense10 (tvb, pinfo, scsi_tree, offset, + isreq, FALSE, payload_len); + break; + + case SCSI_SPC2_PERSRESVIN: + dissect_scsi_persresvin (tvb, pinfo, scsi_tree, offset, isreq, + FALSE, cdata, payload_len); + break; + + case SCSI_SPC2_PERSRESVOUT: + dissect_scsi_persresvout (tvb, pinfo, scsi_tree, offset, + isreq, FALSE, cdata, payload_len); + break; + + case SCSI_SPC2_RELEASE6: + dissect_scsi_release6 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_RELEASE10: + dissect_scsi_release10 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_REPORTDEVICEID: + dissect_scsi_reportdeviceid (tvb, pinfo, scsi_tree, offset, + isreq, FALSE); + break; + + case SCSI_SPC2_REPORTLUNS: + dissect_scsi_reportluns (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_REQSENSE: + dissect_scsi_reqsense (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_RESERVE6: + dissect_scsi_reserve6 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_RESERVE10: + dissect_scsi_reserve10 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SPC2_TESTUNITRDY: + dissect_scsi_testunitrdy (tvb, pinfo, scsi_tree, offset, + isreq, FALSE); + break; + + default: + call_dissector (data_handle, tvb, pinfo, scsi_tree); + break; + } + } + else if (cmd == SCSI_CMND_SBC2) { + switch (opcode) { + + case SCSI_SBC2_FORMATUNIT: + dissect_scsi_formatunit (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SBC2_READ6: + dissect_scsi_rdwr6 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SBC2_READ10: + dissect_scsi_rdwr10 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SBC2_READ12: + dissect_scsi_rdwr12 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SBC2_READ16: + dissect_scsi_rdwr16 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SBC2_READCAPACITY: + dissect_scsi_readcapacity (tvb, pinfo, scsi_tree, offset, + isreq, FALSE); + break; + + case SCSI_SBC2_READDEFDATA10: + dissect_scsi_readdefdata10 (tvb, pinfo, scsi_tree, offset, + isreq, FALSE); + break; + + case SCSI_SBC2_READDEFDATA12: + dissect_scsi_readdefdata12 (tvb, pinfo, scsi_tree, offset, + isreq, FALSE); + break; + + case SCSI_SBC2_REASSIGNBLKS: + dissect_scsi_reassignblks (tvb, pinfo, scsi_tree, offset, + isreq, FALSE); + break; + + case SCSI_SBC2_WRITE6: + dissect_scsi_rdwr6 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SBC2_WRITE10: + dissect_scsi_rdwr10 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SBC2_WRITE12: + dissect_scsi_rdwr12 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + case SCSI_SBC2_WRITE16: + dissect_scsi_rdwr16 (tvb, pinfo, scsi_tree, offset, isreq, + FALSE); + break; + + default: + call_dissector (data_handle, tvb, pinfo, scsi_tree); + break; + } + } + else { + call_dissector (data_handle, tvb, pinfo, scsi_tree); + } + } +} + +void +proto_register_scsi (void) +{ + /* Setup list of header fields See Section 1.6.1 for details*/ + static hf_register_info hf[] = { + { &hf_scsi_spcopcode, + {"SPC-2 Opcode", "scsi.spc.opcode", FT_UINT8, BASE_HEX, + VALS (scsi_spc2_val), 0x0, "", HFILL}}, + { &hf_scsi_sbcopcode, + {"SBC-2 Opcode", "scsi.sbc.opcode", FT_UINT8, BASE_HEX, + VALS (scsi_sbc2_val), 0x0, "", HFILL}}, + { &hf_scsi_sscopcode, + {"SSC-2 Opcode", "scsi.ssc.opcode", FT_UINT8, BASE_HEX, + VALS (scsi_ssc2_val), 0x0, "", HFILL}}, + { &hf_scsi_control, + {"Control", "scsi.cdb.control", FT_UINT8, BASE_HEX, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_inquiry_flags, + {"Flags", "scsi.inquiry.flags", FT_UINT8, BASE_BIN, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_inquiry_evpd_page, + {"EVPD Page Code", "scsi.inquiry.evpd.pagecode", FT_UINT8, BASE_HEX, + VALS (scsi_evpd_pagecode_val), 0x0, "", HFILL}}, + { &hf_scsi_inquiry_cmdt_page, + {"CMDT Page Code", "scsi.inquiry.cmdt.pagecode", FT_UINT8, BASE_HEX, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_alloclen, + {"Allocation Length", "scsi.cdb.alloclen", FT_UINT8, BASE_DEC, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_logsel_flags, + {"Flags", "scsi.logsel.flags", FT_UINT8, BASE_BIN, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_log_pc, + {"Page Control", "scsi.log.pc", FT_UINT8, BASE_BIN, + VALS (scsi_logsel_pc_val), 0xC0, "", HFILL}}, + { &hf_scsi_paramlen, + {"Parameter Length", "scsi.cdb.paramlen", FT_UINT8, BASE_DEC, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_logsns_flags, + {"Flags", "scsi.logsns.flags", FT_UINT16, BASE_BIN, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_logsns_pagecode, + {"Page Code", "scsi.logsns.pagecode", FT_UINT8, BASE_HEX, + VALS (scsi_logsns_page_val), 0x3F0, "", HFILL}}, + { &hf_scsi_paramlen16, + {"Parameter Length", "scsi.cdb.paramlen16", FT_UINT16, BASE_DEC, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_modesel_flags, + {"Mode Sense/Select Flags", "scsi.cdb.mode.flags", FT_UINT8, BASE_BIN, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_alloclen16, + {"Allocation Length", "scsi.cdb.alloclen16", FT_UINT16, BASE_DEC, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_modesns_pc, + {"Page Control", "scsi.mode.pc", FT_UINT8, BASE_BIN, + VALS (scsi_modesns_pc_val), 0xC0, "", HFILL}}, + { &hf_scsi_modesns_pagecode, + {"Page Code", "scsi.mode.pagecode", FT_UINT8, BASE_HEX, + VALS (scsi_modesns_page_val), 0x3F, "", HFILL}}, + { &hf_scsi_modesns_flags, + {"Flags", "scsi.mode.flags", FT_UINT8, BASE_HEX, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_persresvin_svcaction, + {"Service Action", "scsi.persresvin.svcaction", FT_UINT8, BASE_HEX, + VALS (scsi_persresvin_svcaction_val), 0x0F, "", HFILL}}, + { &hf_scsi_persresvout_svcaction, + {"Service Action", "scsi.persresvout.svcaction", FT_UINT8, BASE_HEX, + VALS (scsi_persresvout_svcaction_val), 0x0F, "", HFILL}}, + { &hf_scsi_persresv_scope, + {"Reservation Scope", "scsi.persresv.scope", FT_UINT8, BASE_HEX, + VALS (scsi_persresv_scope_val), 0xF0, "", HFILL}}, + { &hf_scsi_persresv_type, + {"Reservation Type", "scsi.persresv.type", FT_UINT8, BASE_HEX, + VALS (scsi_persresv_type_val), 0x0F, "", HFILL}}, + { &hf_scsi_release_flags, + {"Release Flags", "scsi.release.flags", FT_UINT8, BASE_BIN, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_release_thirdpartyid, + {"Third-Party ID", "scsi.release.thirdpartyid", FT_BYTES, BASE_HEX, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_alloclen32, + {"Allocation Length", "scsi.cdb.alloclen32", FT_UINT32, BASE_DEC, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_formatunit_flags, + {"Flags", "scsi.formatunit.flags", FT_UINT8, BASE_BIN, NULL, 0xF8, + "", HFILL}}, + { &hf_scsi_cdb_defectfmt, + {"Defect List Format", "scsi.cdb.defectfmt", FT_UINT8, BASE_BIN, + NULL, 0x7, "", HFILL}}, + { &hf_scsi_formatunit_interleave, + {"Interleave", "scsi.formatunit.interleave", FT_UINT16, BASE_HEX, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_formatunit_vendor, + {"Vendor Unique", "scsi.formatunit.vendor", FT_UINT8, BASE_HEX, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_rdwr6_lba, + {"Logical Block Address (LBA)", "scsi.rdwr6.lba", FT_UINT24, BASE_DEC, + NULL, 0x0FFFFF, "", HFILL}}, + { &hf_scsi_rdwr6_xferlen, + {"Transfer Length", "scsi.rdwr6.xferlen", FT_UINT8, BASE_DEC, NULL, 0x0, + "", HFILL}}, + { &hf_scsi_rdwr10_lba, + {"Logical Block Address (LBA)", "scsi.rdwr10.lba", FT_UINT32, BASE_DEC, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_rdwr10_xferlen, + {"Transfer Length", "scsi.rdwr10.xferlen", FT_UINT16, BASE_DEC, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_read_flags, + {"Flags", "scsi.read.flags", FT_UINT8, BASE_HEX, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_rdwr12_xferlen, + {"Transfer Length", "scsi.rdwr12.xferlen", FT_UINT32, BASE_DEC, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_rdwr16_lba, + {"Logical Block Address (LBA)", "scsi.rdwr16.lba", FT_BYTES, BASE_DEC, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_readcapacity_flags, + {"Flags", "scsi.readcapacity.flags", FT_UINT8, BASE_BIN, NULL, 0x0, + "", HFILL}}, + { &hf_scsi_readcapacity_lba, + {"Logical Block Address", "scsi.readcapacity.lba", FT_UINT32, BASE_DEC, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_readcapacity_pmi, + {"PMI", "scsi.readcapacity.pmi", FT_UINT8, BASE_BIN, NULL, 0x1, "", + HFILL}}, + { &hf_scsi_readdefdata_flags, + {"Flags", "scsi.readdefdata.flags", FT_UINT8, BASE_BIN, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_reassignblks_flags, + {"Flags", "scsi.reassignblks.flags", FT_UINT8, BASE_BIN, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_inq_devtype, + {"Device Type", "scsi.inquiry.devtype", FT_UINT8, BASE_HEX, + VALS (scsi_devtype_val), 0x0F, "", HFILL}}, + { & hf_scsi_inq_version, + {"Version", "scsi.inquiry.version", FT_UINT8, BASE_HEX, + VALS (scsi_inquiry_vers_val), 0x0, "", HFILL}}, + { &hf_scsi_inq_normaca, + {"NormACA", "scsi.inquiry.normaca", FT_UINT8, BASE_HEX, NULL, 0x20, + "", HFILL}}, + { &hf_scsi_rluns_lun, + {"LUN", "scsi.reportluns.lun", FT_UINT8, BASE_DEC, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_rluns_multilun, + {"Multi-level LUN", "scsi.reportluns.mlun", FT_BYTES, BASE_HEX, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_modesns_errrep, + {"MRIE", "scsi.mode.mrie", FT_UINT8, BASE_HEX, + VALS (scsi_modesns_mrie_val), 0x0F, "", HFILL}}, + { &hf_scsi_modesns_tst, + {"Task Set Type", "scsi.mode.tst", FT_UINT8, BASE_BIN, + VALS (scsi_modesns_tst_val), 0xE0, "", HFILL}}, + { &hf_scsi_modesns_qmod, + {"Queue Algorithm Modifier", "scsi.mode.qmod", FT_UINT8, BASE_HEX, + VALS (scsi_modesns_qmod_val), 0xF0, "", HFILL}}, + { &hf_scsi_modesns_qerr, + {"Queue Error Management", "scsi.mode.qerr", FT_BOOLEAN, BASE_HEX, + TFS (&scsi_modesns_qerr_val), 0x2, "", HFILL}}, + { &hf_scsi_modesns_tas, + {"Task Aborted Status", "scsi.mode.tac", FT_BOOLEAN, BASE_HEX, + TFS (&scsi_modesns_tas_val), 0x80, "", HFILL}}, + { &hf_scsi_modesns_rac, + {"Report a Check", "ssci.mode.rac", FT_BOOLEAN, BASE_HEX, + TFS (&scsi_modesns_rac_val), 0x40, "", HFILL}}, + { &hf_scsi_protocol, + {"Protocol", "scsi.proto", FT_UINT8, BASE_DEC, VALS (scsi_proto_val), + 0x0F, "", HFILL}}, + { &hf_scsi_sns_errtype, + {"SNS Error Type", "scsi.sns.errtype", FT_UINT8, BASE_HEX, + VALS (scsi_sns_errtype_val), 0x7F, "", HFILL}}, + { &hf_scsi_snskey, + {"Sense Key", "scsi.sns.key", FT_UINT8, BASE_HEX, + VALS (scsi_sensekey_val), 0x0F, "", HFILL}}, + { &hf_scsi_snsinfo, + {"Sense Info", "scsi.sns.info", FT_UINT32, BASE_HEX, NULL, 0x0, "", + HFILL}}, + { &hf_scsi_addlsnslen, + {"Additional Sense Length", "scsi.sns.addlen", FT_UINT8, BASE_DEC, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_asc, + {"Additional Sense Code", "scsi.sns.asc", FT_UINT8, BASE_HEX, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_ascq, + {"Additional Sense Code Qualifier", "scsi.sns.ascq", FT_UINT8, + BASE_HEX, NULL, 0x0, "", HFILL}}, + { &hf_scsi_ascascq, + {"Additional Sense Code+Qualifier", "scsi.sns.ascascq", FT_UINT16, + BASE_HEX, VALS (scsi_asc_val), 0x0, "", HFILL}}, + { &hf_scsi_fru, + {"Field Replaceable Unit Code", "scsi.sns.fru", FT_UINT8, BASE_HEX, + NULL, 0x0, "", HFILL}}, + { &hf_scsi_sksv, + {"SKSV", "scsi.sns.sksv", FT_BOOLEAN, BASE_HEX, NULL, 0x80, "", + HFILL}}, + { &hf_scsi_persresv_key, + {"Reservation Key", "scsi.spc2.resv.key", FT_BYTES, BASE_HEX, NULL, + 0x0, "", HFILL}}, + { &hf_scsi_persresv_scopeaddr, + {"Scope Address", "scsi.spc2.resv.scopeaddr", FT_BYTES, BASE_HEX, NULL, + 0x0, "", HFILL}}, + }; + + /* Setup protocol subtree array */ + static gint *ett[] = { + &ett_scsi, + &ett_scsi_page, + }; + module_t *scsi_module; + + /* Register the protocol name and description */ + proto_scsi = proto_register_protocol("SCSI", "SCSI", "scsi"); + + /* Required function calls to register the header fields and subtrees used */ + proto_register_field_array(proto_scsi, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + register_init_routine (&scsi_init_protocol); + register_dissector ("SCSI", dissect_scsi, proto_scsi); + data_handle = find_dissector ("data"); + + /* add preferences to decode SCSI message */ + scsi_module = prefs_register_protocol (proto_scsi, NULL); + prefs_register_enum_preference (scsi_module, "decode_scsi_messages_as", + "Decode SCSI Messages As", + "When Target Cannot Be Identified, Decode SCSI Messages As", + &scsi_def_devtype, scsi_devtype_options, TRUE); +} diff --git a/packet-scsi.h b/packet-scsi.h new file mode 100644 index 0000000000..69b72674f7 --- /dev/null +++ b/packet-scsi.h @@ -0,0 +1,960 @@ +/* packet-scsi.h + * Author: Dinesh G Dutt (ddutt@cisco.com) + * + * $Id: packet-scsi.h,v 1.1 2002/01/10 01:28:43 guy Exp $ + * + * Ethereal - Network traffic analyzer + * By Gerald Combs + * Copyright 2002 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __PACKET_SCSI_H_ +#define __PACKET_SCSI_H_ + +typedef guint32 scsi_cmnd_type; +typedef guint32 scsi_device_type; + +/* Valid SCSI Device Types */ +#define SCSI_CMND_SPC2 1 +#define SCSI_CMND_SBC2 2 +#define SCSI_CMND_SSC2 3 + +/* SPC-2 Commands */ + +#define SCSI_SPC2_INQUIRY 0x12 +#define SCSI_SPC2_EXTCOPY 0x83 +#define SCSI_SPC2_LOGSELECT 0x4C +#define SCSI_SPC2_LOGSENSE 0x4D +#define SCSI_SPC2_MODESELECT6 0x15 +#define SCSI_SPC2_MODESELECT10 0x55 +#define SCSI_SPC2_MODESENSE6 0x1A +#define SCSI_SPC2_MODESENSE10 0x5A +#define SCSI_SPC2_PERSRESVIN 0x5E +#define SCSI_SPC2_PERSRESVOUT 0x5F +#define SCSI_SPC2_PREVMEDREMOVAL 0x1E +#define SCSI_SPC2_READBUFFER 0x3C +#define SCSI_SPC2_RCVCOPYRESULTS 0x84 +#define SCSI_SPC2_RCVDIAGRESULTS 0x1C +#define SCSI_SPC2_RELEASE6 0x17 +#define SCSI_SPC2_RELEASE10 0x57 +#define SCSI_SPC2_REPORTDEVICEID 0xA3 +#define SCSI_SPC2_REPORTLUNS 0xA0 +#define SCSI_SPC2_REQSENSE 0x03 +#define SCSI_SPC2_RESERVE6 0x16 +#define SCSI_SPC2_RESERVE10 0x56 +#define SCSI_SPC2_SENDDIAG 0x1D +#define SCSI_SPC2_SETDEVICEID 0xA4 +#define SCSI_SPC2_TESTUNITRDY 0x00 +#define SCSI_SPC2_WRITEBUFFER 0x3B + +static const value_string scsi_spc2_val[] = { + {SCSI_SPC2_EXTCOPY , "Extended Copy"}, + {SCSI_SPC2_INQUIRY , "Inquiry"}, + {SCSI_SPC2_LOGSELECT , "Log Select"}, + {SCSI_SPC2_LOGSENSE , "Log Sense"}, + {SCSI_SPC2_MODESELECT6 , "Mode Select (6)"}, + {SCSI_SPC2_MODESELECT10 , "Mode Select (10)"}, + {SCSI_SPC2_MODESENSE6 , "Mode Sense (6)"}, + {SCSI_SPC2_MODESENSE10 , "Mode Sense (10)"}, + {SCSI_SPC2_PERSRESVIN , "Persistent Reserve In"}, + {SCSI_SPC2_PERSRESVOUT , "Persistent Reserve Out"}, + {SCSI_SPC2_PREVMEDREMOVAL , "Prevent Allow Medium Removal"}, + {SCSI_SPC2_RCVCOPYRESULTS , "Receive Copy Results"}, + {SCSI_SPC2_RCVDIAGRESULTS , "Receive Diagnostics Results"}, + {SCSI_SPC2_READBUFFER , "Read Buffer"}, + {SCSI_SPC2_RELEASE6 , "Release (6)"}, + {SCSI_SPC2_RELEASE10 , "Release (10)"}, + {SCSI_SPC2_REPORTDEVICEID , "Report Device ID"}, + {SCSI_SPC2_REPORTLUNS , "Report LUNs"}, + {SCSI_SPC2_REQSENSE , "Request Sense"}, + {SCSI_SPC2_RESERVE6 , "Reserve (6)"}, + {SCSI_SPC2_RESERVE10 , "Reserve (10)"}, + {SCSI_SPC2_TESTUNITRDY , "Test Unit Ready"}, + {SCSI_SPC2_WRITEBUFFER , "Write Buffer"}, + {0, NULL}, +}; + +/* SBC-2 Commands */ +#define SCSI_SBC2_FORMATUNIT 0x04 +#define SCSI_SBC2_LOCKUNLKCACHE10 0x36 +#define SCSI_SPC2_LOCKUNLKCACHE16 0x92 +#define SCSI_SBC2_PREFETCH10 0x34 +#define SCSI_SBC2_PREFETCH16 0x90 +#define SCSI_SBC2_READ6 0x08 +#define SCSI_SBC2_READ10 0x28 +#define SCSI_SBC2_READ12 0xA8 +#define SCSI_SBC2_READ16 0x88 +#define SCSI_SBC2_READCAPACITY 0x25 +#define SCSI_SBC2_READDEFDATA10 0x37 +#define SCSI_SBC2_READDEFDATA12 0xB7 +#define SCSI_SBC2_READLONG 0x3E +#define SCSI_SBC2_REASSIGNBLKS 0x07 +#define SCSI_SBC2_REBUILD16 0x81 +#define SCSI_SBC2_REBUILD32 0x7F +#define SCSI_SBC2_REGENERATE16 0x82 +#define SCSI_SBC2_REGENERATE32 0x7F +#define SCSI_SBC2_SEEK10 0x2B +#define SCSI_SBC2_SETLIMITS10 0x33 +#define SCSI_SBC2_SETLIMITS12 0xB3 +#define SCSI_SBC2_STARTSTOPUNIT 0x1B +#define SCSI_SBC2_SYNCCACHE10 0x35 +#define SCSI_SBC2_SYNCCACHE16 0x91 +#define SCSI_SBC2_VERIFY10 0x2F +#define SCSI_SBC2_VERIFY12 0xAF +#define SCSI_SBC2_VERIFY16 0x8F +#define SCSI_SBC2_WRITE6 0x0A +#define SCSI_SBC2_WRITE10 0x2A +#define SCSI_SBC2_WRITE12 0xAA +#define SCSI_SBC2_WRITE16 0x8A +#define SCSI_SBC2_WRITENVERIFY10 0x2E +#define SCSI_SBC2_WRITENVERIFY12 0xAE +#define SCSI_SBC2_WRITENVERIFY16 0x8E +#define SCSI_SBC2_WRITELONG 0x3F +#define SCSI_SBC2_WRITESAME10 0x41 +#define SCSI_SBC2_WRITESAME16 0x93 +#define SCSI_SBC2_XDREAD10 0x52 +#define SCSI_SBC2_XDREAD32 0x7F +#define SCSI_SBC2_XDWRITE10 0x50 +#define SCSI_SBC2_XDWRITE32 0x7F +#define SCSI_SBC2_XDWRITEREAD10 0x53 +#define SCSI_SBC2_XDWRITEREAD32 0x7F +#define SCSI_SBC2_XDWRITEEXTD16 0x80 +#define SCSI_SBC2_XDWRITEEXTD32 0x7F +#define SCSI_SBC2_XPWRITE10 0x51 +#define SCSI_SBC2_XPWRITE32 0x7F + + +static const value_string scsi_sbc2_val[] = { + {SCSI_SBC2_FORMATUNIT , "Format Unit"}, + {SCSI_SBC2_LOCKUNLKCACHE10, "Lock Unlock Cache (10)"}, + {SCSI_SPC2_LOCKUNLKCACHE16, "Lock Unlock Cache (16)"}, + {SCSI_SBC2_PREFETCH10, "Pre-Fetch (10)"}, + {SCSI_SBC2_PREFETCH16, "Pre-Fetch (16)"}, + {SCSI_SBC2_READ6 , "Read (6)"}, + {SCSI_SBC2_READ10 , "Read (10)"}, + {SCSI_SBC2_READ12 , "Read (12)"}, + {SCSI_SBC2_READ16 , "Read (16)"}, + {SCSI_SBC2_READCAPACITY , "Read Capacity"}, + {SCSI_SBC2_READDEFDATA10 , "Read Defect Data (10)"}, + {SCSI_SBC2_READDEFDATA12 , "Read Defect Data (12)"}, + {SCSI_SBC2_READLONG, "Read Long"}, + {SCSI_SBC2_REASSIGNBLKS , "Reassign Blocks"}, + {SCSI_SBC2_REBUILD16, "Rebuild (16)"}, + {SCSI_SBC2_REBUILD32, "Rebuild (32)"}, + {SCSI_SBC2_REGENERATE16, "Regenerate (16)"}, + {SCSI_SBC2_REGENERATE32, "Regenerate (32)"}, + {SCSI_SBC2_SEEK10, "Seek (10)"}, + {SCSI_SBC2_SETLIMITS10, "Set Limits (10)"}, + {SCSI_SBC2_SETLIMITS12, "Set Limits (12)"}, + {SCSI_SBC2_STARTSTOPUNIT, "Start Stop Unit"}, + {SCSI_SBC2_SYNCCACHE10, "Synchronize Cache (10)"}, + {SCSI_SBC2_SYNCCACHE16, "Synchronize Cache (16)"}, + {SCSI_SBC2_VERIFY10, "Verify (10)"}, + {SCSI_SBC2_VERIFY12, "Verify (12)"}, + {SCSI_SBC2_VERIFY16, "Verify (16)"}, + {SCSI_SBC2_WRITE6 , "Write (6)"}, + {SCSI_SBC2_WRITE10 , "Write (10)"}, + {SCSI_SBC2_WRITE12 , "Write (12)"}, + {SCSI_SBC2_WRITE16 , "Write (16)"}, + {SCSI_SBC2_WRITENVERIFY10, "Write & Verify (10)"}, + {SCSI_SBC2_WRITENVERIFY12, "Write & Verify (12)"}, + {SCSI_SBC2_WRITENVERIFY16, "Write & Verify (16)"}, + {SCSI_SBC2_WRITELONG, "Write Long"}, + {SCSI_SBC2_WRITESAME10, "Write Same (10)"}, + {SCSI_SBC2_WRITESAME16, "Write Same (16)"}, + {SCSI_SBC2_XDREAD10, "XdRead (10)"}, + {SCSI_SBC2_XDREAD32, "XdRead (32)"}, + {SCSI_SBC2_XDWRITE10, "XdWrite (10)"}, + {SCSI_SBC2_XDWRITE32, "XdWrite(32)"}, + {SCSI_SBC2_XDWRITEREAD10, "XdWriteRead (10)"}, + {SCSI_SBC2_XDWRITEREAD32, "XdWriteRead (32)"}, + {SCSI_SBC2_XDWRITEEXTD16, "XdWrite Extended (16)"}, + {SCSI_SBC2_XDWRITEEXTD32, "XdWrite Extended (32)"}, + {SCSI_SBC2_XPWRITE10, "XpWrite (10)"}, + {SCSI_SBC2_XPWRITE32, "XpWrite (32)"}, + {0, NULL}, +}; + +/* SSC2 Commands */ +#define SCSI_SSC2_ERASE_16 0x93 +#define SCSI_SSC2_FORMAT_MEDIUM 0x04 +#define SCSI_SSC2_LOAD_UNLOAD 0x1B +#define SCSI_SSC2_LOCATE_16 0x92 +#define SCSI_SSC2_MOVE_MEDIUM 0xA5 +#define SCSI_SSC2_MOVE_MEDIUM_ATTACHED 0xA7 +#define SCSI_SSC2_READ_16 0x88 +#define SCSI_SSC2_READ_BLOCK_LIMITS 0x05 +#define SCSI_SSC2_READ_ELEMENT_STATUS 0xB8 +#define SCSI_SSC2_READ_ELEMENT_STATUS_ATTACHED 0xB4 +#define SCSI_SSC2_READ_POSITION 0x34 +#define SCSI_SSC2_READ_REVERSE_16 0x81 +#define SCSI_SSC2_RECOVER_BUFFERED_DATA 0x14 +#define SCSI_SSC2_REPORT_DENSITY_SUPPORT 0x44 +#define SCSI_SSC2_REWIND 0x01 +#define SCSI_SSC2_SET_CAPACITY 0x0B +#define SCSI_SSC2_SPACE_16 0x91 +#define SCSI_SSC2_VERIFY_16 0x8F +#define SCSI_SSC2_WRITE_16 0x8A +#define SCSI_SSC2_WRITE_FILEMARKS_16 0x80 +#define SCSI_SSC2_ERASE_6 0x19 +#define SCSI_SSC2_LOCATE_10 0x2B +#define SCSI_SSC2_LOCATE_16 0x92 +#define SCSI_SSC2_READ_6 0x08 +#define SCSI_SSC2_READ_REVERSE_6 0x0F +#define SCSI_SSC2_SPACE_6 0x11 +#define SCSI_SSC2_VERIFY_6 0x13 +#define SCSI_SSC2_WRITE_6 0x0A +#define SCSI_SSC2_WRITE_FILEMARKS_6 0x10 + +static const value_string scsi_ssc2_val[] = { + {SCSI_SSC2_ERASE_16 , "Erase(16)"}, + {SCSI_SSC2_FORMAT_MEDIUM , "Format Medium"}, + {SCSI_SSC2_LOAD_UNLOAD , "Load Unload"}, + {SCSI_SSC2_LOCATE_16 , "Locate(16)"}, + {SCSI_SSC2_MOVE_MEDIUM , "Move Medium"}, + {SCSI_SSC2_MOVE_MEDIUM_ATTACHED , "Move Medium Attached"}, + {SCSI_SSC2_READ_16 , "Read(16)"}, + {SCSI_SSC2_READ_BLOCK_LIMITS , "Read Block Limits"}, + {SCSI_SSC2_READ_ELEMENT_STATUS , "Read Element Status"}, + {SCSI_SSC2_READ_ELEMENT_STATUS_ATTACHED, "Read Element Status Attached"}, + {SCSI_SSC2_READ_POSITION , "Read Position"}, + {SCSI_SSC2_READ_REVERSE_16 , "Read Reverse(16)"}, + {SCSI_SSC2_RECOVER_BUFFERED_DATA , "Recover Buffered Data"}, + {SCSI_SSC2_REPORT_DENSITY_SUPPORT , "Report Density Support"}, + {SCSI_SSC2_REWIND , "Rewind"}, + {SCSI_SSC2_SET_CAPACITY , "Set Capacity"}, + {SCSI_SSC2_SPACE_16 , "Space(16)"}, + {SCSI_SSC2_VERIFY_16 , "Verify(16)"}, + {SCSI_SSC2_WRITE_16 , "Write(16)"}, + {SCSI_SSC2_WRITE_FILEMARKS_16 , "Write Filemarks(16)"}, + {SCSI_SSC2_ERASE_6 , "Erase(6)"}, + {SCSI_SSC2_LOCATE_10 , "Locate(10)"}, + {SCSI_SSC2_LOCATE_16 , "Locate(16)"}, + {SCSI_SSC2_READ_6 , "Read(6)"}, + {SCSI_SSC2_READ_REVERSE_6 , "Read Reverse(6)"}, + {SCSI_SSC2_SPACE_6 , "Space(6)"}, + {SCSI_SSC2_VERIFY_6 , "Verify(6)"}, + {SCSI_SSC2_WRITE_6 , "Write(6)"}, + {SCSI_SSC2_WRITE_FILEMARKS_6 , "Write Filemarks(6)"}, +}; + +static const value_string scsi_evpd_pagecode_val[] = { + {0x00, "Supported Vital Data Product Pages"}, + {0x80, "Unit Serial Number Page"}, + {0x82, "ASCII Implemented Operating Definition Page"}, + {0x01, "ASCII Information Page"}, + {0x02, "ASCII Information Page"}, + {0x03, "ASCII Information Page"}, + {0x04, "ASCII Information Page"}, + {0x05, "ASCII Information Page"}, + {0x06, "ASCII Information Page"}, + {0x07, "ASCII Information Page"}, + {0x83, "Device Identification Page"}, + {0, NULL}, +}; + +static const value_string scsi_logsel_pc_val[] = { + {0, "Current Threshold Values"}, + {1, "Current Cumulative Values"}, + {2, "Default Threshold Values"}, + {3, "Default Cumulative Values"}, + {0, NULL}, +}; + +static const value_string scsi_logsns_pc_val[] = { + {0, "Threshold Values"}, + {1, "Cumulative Values"}, + {2, "Default Threshold Values"}, + {3, "Default Cumulative Values"}, + {0, NULL}, +}; + +static const value_string scsi_logsns_page_val[] = { + {0xF, "Application Client Page"}, + {0x1, "Buffer Overrun/Underrun Page"}, + {0x3, "Error Counter (read) Page"}, + {0x4, "Error Counter (read reverse) Page"}, + {0x5, "Error Counter (verify) Page"}, + {0x1, "Error Counter (write) Page"}, + {0xB, "Last n Deferred Errors or Async Events Page"}, + {0x7, "Last n Error Events Page"}, + {0x6, "Non-medium Error Page"}, + {0x10, "Self-test Results Page"}, + {0xE, "Start-Stop Cycle Counter Page"}, + {0x0, "Supported Log Pages"}, + {0xD, "Temperature Page"}, + {0, NULL}, +}; + +static const value_string scsi_modesns_pc_val[] = { + {0, "Current Values"}, + {1, "Changeable Values"}, + {2, "Default Values"}, + {3, "Saved Values"}, + {0, NULL}, +}; + +#define SCSI_MODEPAGE_VEND 0x0 +#define SCSI_MODEPAGE_CTL 0x0A +#define SCSI_MODEPAGE_DISCON 0x02 +#define SCSI_MODEPAGE_INFOEXCP 0x1C +#define SCSI_MODEPAGE_PWR 0x1A +#define SCSI_MODEPAGE_LUN 0x18 +#define SCSI_MODEPAGE_PORT 0x19 +#define SCSI_MODEPAGE_RDWRERR 0x01 +#define SCSI_MODEPAGE_FMTDEV 0x03 +#define SCSI_MODEPAGE_DISKGEOM 0x04 +#define SCSI_MODEPAGE_FLEXDISK 0x05 +#define SCSI_MODEPAGE_VERERR 0x07 +#define SCSI_MODEPAGE_CACHE 0x08 +#define SCSI_MODEPAGE_PERDEV 0x09 +#define SCSI_MODEPAGE_MEDTYPE 0x0B +#define SCSI_MODEPAGE_NOTPART 0x0C +#define SCSI_MODEPAGE_XORCTL 0x10 + +static const value_string scsi_modesns_page_val[] = { + {0, "Vendor Specific Page"}, + {0x0A, "Control"}, + {0x02, "Disconnect-Reconnect"}, + {0x1C, "Informational Exceptions Control"}, + {0x1A, "Power Condition"}, + {0x18, "Protocol Specific LUN"}, + {0x19, "Protocol-Specific Port"}, + {0x01, "Read/Write Error Recovery"}, + {0x03, "Format Device"}, + {0x04, "Rigid Disk Geometry"}, + {0x05, "Flexible Disk"}, + {0x07, "Verify Error Recovery"}, + {0x08, "Caching"}, + {0x09, "Peripheral Device"}, + {0x0B, "Medium Types Supported"}, + {0x0C, "Notch & Partition"}, + {0x10, "XOR Control"}, + {0x3F, "Return All Mode Pages"}, + {0, NULL}, +}; + +#define SCSI_SPC2_RESVIN_SVCA_RDKEYS 0 +#define SCSI_SPC2_RESVIN_SVCA_RDRESV 1 + +static const value_string scsi_persresvin_svcaction_val[] = { + {SCSI_SPC2_RESVIN_SVCA_RDKEYS, "Read Keys"}, + {SCSI_SPC2_RESVIN_SVCA_RDRESV, "Read Reservation"}, + {0, NULL}, +}; + +static const value_string scsi_persresvout_svcaction_val[] = { + {0, "Register"}, + {1, "Reserve"}, + {2, "Release"}, + {3, "Clear"}, + {4, "Preempt"}, + {5, "Preempt & Abort"}, + {6, "Register & Ignore Existing Key"}, + {0, NULL}, +}; + +static const value_string scsi_persresv_scope_val[] = { + {0, "LU Scope"}, + {1, "Obsolete"}, + {2, "Element Scope"}, + {0, NULL}, +}; + +static const value_string scsi_persresv_type_val[] = { + {1, "Write Excl"}, + {3, "Excl Access"}, + {5, "Write Excl, Registrants Only"}, + {7, "Excl Access, Registrants Only"}, + {0, NULL}, +}; + +/* SCSI Device Types */ +#define SCSI_DEV_SBC 0x0 +#define SCSI_DEV_SSC 0x1 +#define SCSI_DEV_PRNT 0x2 +#define SCSI_DEV_PROC 0x3 +#define SCSI_DEV_WORM 0x4 +#define SCSI_DEV_CDROM 0x5 +#define SCSI_DEV_SCAN 0x6 +#define SCSI_DEV_OPTMEM 0x7 +#define SCSI_DEV_SMC 0x8 +#define SCSI_DEV_COMM 0x9 +#define SCSI_DEV_RAID 0xC +#define SCSI_DEV_SES 0xD +#define SCSI_DEV_RBC 0xE +#define SCSI_DEV_OCRW 0xF +#define SCSI_DEV_OSD 0x11 + +static const value_string scsi_devtype_val[] = { + {SCSI_DEV_SBC , "Direct Access Device"}, + {SCSI_DEV_SSC , "Sequential Access Device"}, + {SCSI_DEV_PRNT , "Printer"}, + {SCSI_DEV_PROC , "Processor"}, + {SCSI_DEV_WORM , "WORM"}, + {SCSI_DEV_CDROM , "CD ROM"}, + {SCSI_DEV_SCAN , "Scanner"}, + {SCSI_DEV_OPTMEM, "Optical Memory"}, + {SCSI_DEV_SMC , "Medium Changer"}, + {SCSI_DEV_COMM , "Communication"}, + {SCSI_DEV_RAID , "Storage Array"}, + {SCSI_DEV_SES , "Enclosure Services"}, + {SCSI_DEV_RBC , "Simplified Block Device"}, + {SCSI_DEV_OCRW , "OCRW"}, + {SCSI_DEV_OSD , "OSD"}, + {0, NULL}, +}; + +static const enum_val_t scsi_devtype_options[] = { + {"Block Device", SCSI_DEV_SBC}, + {"Sequential Device", SCSI_DEV_SSC}, + {NULL, -1}, +}; + +static const value_string scsi_inquiry_vers_val[] = { + {0, "No Compliance to any Standard"}, + {2, "Compliance to ANSI X3.131:1994"}, + {3, "Compliance to ANSI X3.301:1997"}, + {4, "Compliance to SPC-2"}, + {0x80, "Compliance to ISO/IEC 9316:1995"}, + {0x82, "Compliance to ISO/IEC 9316:1995 and to ANSI X3.131:1994"}, + {0x83, "Compliance to ISO/IEC 9316:1995 and to ANSI X3.301:1997"}, + {0x84, "Compliance to ISO/IEC 9316:1995 and SPC-2"}, + {0, NULL}, +}; + +static const value_string scsi_modesense_medtype_val[] = { + {0, "Default"}, + {1, "Flexible Disk, Single-sided"}, + {2, "Flexible Disk, Double-sided"}, + {0, NULL}, +}; + +static const value_string scsi_verdesc_val[] = { + {0x0d40, "FC-AL (No Version)"}, + {0x0d5c, "FC-AL ANSI X3.272:1996"}, + {0x0d60, "FC-AL-2 (no version claimed)"}, + {0x0d7c, "FC-AL-2 ANSI NCITS.332:1999"}, + {0x0d61, "FC-AL-2 T11/1133 revision 7.0"}, + {0x1320, "FC-FLA (no version claimed)"}, + {0x133c, "FC-FLA ANSI NCITS TR-20:1998"}, + {0x133b, "FC-FLA T11/1235 revision 7"}, + {0x0da0, "FC-FS (no version claimed)"}, + {0x0db7, "FC-FS T11/1331 revision 1.2"}, + {0x08c0, "FCP (no version claimed)"}, + {0x08dc, "FCP ANSI X3.269:1996"}, + {0x08db, "FCP T10/0993 revision 12"}, + {0x1340, "FC-PLDA (no version claimed)"}, + {0x135c, "FC-PLDA ANSI NCITS TR-19:1998"}, + {0x135b, "FC-PLDA T11/1162 revision 2.1"}, + {0x0900, "FCP-2 (no version claimed)"}, + {0x0901, "FCP-2 T10/1144 revision 4"}, + {0x003c, "SAM ANSI X3.270:1996"}, + {0x003b, "SAM T10/0994 revision 18"}, + {0x0040, "SAM-2 (no version claimed)"}, + {0x0020, "SAM (no version claimed)"}, + {0x0180, "SBC (no version claimed)"}, + {0x019c, "SBC ANSI NCITS.306:1998"}, + {0x019b, "SBC T10/0996 revision 08c"}, + {0x0320, "SBC-2 (no version claimed)"}, + {0x01c0, "SES (no version claimed)"}, + {0x01dc, "SES ANSI NCITS.305:1998"}, + {0x01db, "SES T10/1212 revision 08b"}, + {0x01de, "SES ANSI NCITS.305:1998 w/ Amendment ANSI NCITS.305/AM1:2000"}, + {0x01dd, "SES T10/1212 revision 08b w/ Amendment ANSI NCITS.305/AM1:2000"}, + {0x0120, "SPC (no version claimed)"}, + {0x013c, "SPC ANSI X3.301:1997"}, + {0x013b, "SPC T10/0995 revision 11a"}, + {0x0260, "SPC-2 (no version claimed)"}, + {0x0267, "SPC-2 T10/1236 revision 12"}, + {0x0269, "SPC-2 T10/1236 revision 18"}, + {0x0300, "SPC-3 (no version claimed)"}, + {0x0960, "iSCSI (no version claimed)"}, + {0x0d80, "FC-PH-3 (no version claimed)"}, + {0x0d9c, "FC-PH-3 ANSI X3.303-1998"}, + {0x0d20, "FC-PH (no version claimed)"}, + {0, NULL}, +}; + +#define SCSI_EVPD_SUPPPG 0 +#define SCSI_EVPD_ASCIIOPER 0x82 +#define SCSI_EVPD_DEVID 0x83 +#define SCSI_EVPD_DEVSERNUM 0x80 + +static const value_string scsi_inq_evpd_val[] = { + {SCSI_EVPD_SUPPPG, "Supported Vital Product Data Page"}, + {SCSI_EVPD_ASCIIOPER, "ASCII Implemented Operating Definition Page"}, + {SCSI_EVPD_DEVID, "Device ID Page"}, + {SCSI_EVPD_DEVSERNUM, "Unit Serial Number Page"}, + {0x0, NULL}, +}; + +/* Command Support Data "Support" field definitions */ +static const value_string scsi_cmdt_supp_val[] = { + {0, "Data not currently available"}, + {1, "SCSI Command not supported"}, + {2, "Reserved"}, + {3, "SCSI Command supported in conformance with a SCSI standard"}, + {4, "Vendor Specific"}, + {5, "SCSI Command supported in a vendor specific manner"}, + {6, "Vendor Specific"}, + {7, "Reserved"}, + {0, NULL}, +}; + +static const value_string scsi_devid_codeset_val[] = { + {0, "Reserved"}, + {1, "Identifier field contains binary values"}, + {2, "Identifier field contains ASCII graphic codes"}, + {0, NULL}, +}; + +static const value_string scsi_devid_assoc_val[] = { + {0, "Identifier is associated with addressed logical/physical device"}, + {1, "Identifier is associated with the port that received the request"}, + {0, NULL}, +}; + +static const value_string scsi_devid_idtype_val[] = { + {0, "Vendor-specific ID (non-globally unique)"}, + {1, "Vendor-ID + vendor-specific ID (globally unique)"}, + {2, "EUI-64 ID"}, + {3, "WWN"}, + {4, "4-byte Binary Number/Reserved"}, + {0, NULL}, +}; + +static const value_string scsi_modesns_mrie_val[] = { + {0, "No Reporting of Informational Exception Condition"}, + {1, "Asynchronous Error Reporting"}, + {2, "Generate Unit Attention"}, + {3, "Conditionally Generate Recovered Error"}, + {4, "Unconditionally Generate Recovered Error"}, + {5, "Generate No Sense"}, + {6, "Only Report Informational Exception Condition on Request"}, + {0, NULL}, +}; + +static const value_string scsi_modesns_tst_val[] = { + {0, "Task Set Per LU For All Initiators"}, + {1, "Task Set Per Initiator Per LU"}, + {0, NULL}, +}; + +static const value_string scsi_modesns_qmod_val[] = { + {0, "Restricted reordering"}, + {1, "Unrestricted reordering"}, + {0, NULL}, +}; + +static const true_false_string scsi_modesns_qerr_val = { + "All blocked tasks shall be aborted on CHECK CONDITION", + "Blocked tasks shall resume after ACA/CA is cleared", +}; + +static const true_false_string scsi_modesns_tas_val = { + "Terminated tasks aborted without informing initiators", + "Tasks aborted by another initiator terminated with TASK ABORTED", +}; + +static const true_false_string scsi_modesns_rac_val = { + "Report a CHECK CONDITION Instead of Long Busy Condition", + "Long Busy Conditions Maybe Reported", +}; + +/* SCSI Transport Protocols */ +#define SCSI_PROTO_FCP 0 +#define SCSI_PROTO_iSCSI 5 + +static const value_string scsi_proto_val[] = { + {0, "FCP"}, + {5, "iSCSI"}, + {0, NULL}, +}; + +static const value_string scsi_fcp_rrtov_val[] = { + {0, "No Timer Specified"}, + {1, "0.001 secs"}, + {3, "0.1 secs"}, + {5, "10 secs"}, + {0, NULL}, +}; + +static const value_string scsi_sensekey_val[] = { + {0x0, "No Sense"}, + {0x1, "Recovered Error"}, + {0x2, "Not Ready"}, + {0x3, "Medium Error"}, + {0x4, "Hardware Error"}, + {0x5, "Illegal Request"}, + {0x6, "Unit Attention"}, + {0x7, "Data Protection"}, + {0x8, "Blank Check"}, + {0x9, "Vendor Specific"}, + {0xA, "Copy Aborted"}, + {0xB, "Command Aborted"}, + {0xC, "Obsolete Error Code"}, + {0xD, "Overflow Command"}, + {0xE, "Miscompare"}, + {0xF, "Reserved"}, + {0, NULL}, +}; + +static const value_string scsi_sns_errtype_val[] = { + {0x70, "Current Error"}, + {0x71, "Deferred Error"}, + {0x7F, "Vendor Specific"}, + {0, NULL}, +}; + +static const value_string scsi_asc_val[] = { + {0x0000, "No Additional Sense Information"}, + {0x0006, "I/O Process Terminated"}, + {0x0016, "Operation In Progress"}, + {0x0017, "Cleaning Requested"}, + {0x0100, "No Index/Sector Signal"}, + {0x0200, "No Seek Complete"}, + {0x0300, "Peripheral Device Write Fault"}, + {0x0400, "Logical Unit Not Ready, Cause Not Reportable"}, + {0x0401, "Logical Unit Is In Process Of Becoming Ready"}, + {0x0402, "Logical Unit Not Ready, Initializing Cmd. Required"}, + {0x0403, "Logical Unit Not Ready, Manual Intervention Required"}, + {0x0404, "Logical Unit Not Ready, Format In Progress"}, + {0x0405, "Logical Unit Not Ready, Rebuild In Progress"}, + {0x0406, "Logical Unit Not Ready, Recalculation In Progress"}, + {0x0407, "Logical Unit Not Ready, Operation In Progress"}, + {0x0409, "Logical Unit Not Ready, Self-Test In Progress"}, + {0x0500, "Logical Unit Does Not Respond To Selection"}, + {0x0600, "No Reference Position Found"}, + {0x0700, "Multiple Peripheral Devices Selected"}, + {0x0800, "Logical Unit Communication Failure"}, + {0x0801, "Logical Unit Communication Time-Out"}, + {0x0802, "Logical Unit Communication Parity Error"}, + {0x0803, "Logical Unit Communication Crc Error (Ultra-Dma/32)"}, + {0x0804, "Unreachable Copy Target"}, + {0x0900, "Track Following Error"}, + {0x0904, "Head Select Fault"}, + {0x0A00, "Error Log Overflow"}, + {0x0B00, "Warning"}, + {0x0B01, "Warning - Specified Temperature Exceeded"}, + {0x0B02, "Warning - Enclosure Degraded"}, + {0x0C02, "Write Error - Auto Reallocation Failed"}, + {0x0C03, "Write Error - Recommend Reassignment"}, + {0x0C04, "Compression Check Miscompare Error"}, + {0x0C05, "Data Expansion Occurred During Compression"}, + {0x0C06, "Block Not Compressible"}, + {0x0D00, "Error Detected By Third Party Temporary Initiator"}, + {0x0D01, "Third Party Device Failure"}, + {0x0D02, "Copy Target Device Not Reachable"}, + {0x0D03, "Incorrect Copy Target Device Type"}, + {0x0D04, "Copy Target Device Data Underrun"}, + {0x0D05, "Copy Target Device Data Overrun"}, + {0x1000, "Id Crc Or Ecc Error"}, + {0x1100, "Unrecovered Read Error"}, + {0x1101, "Read Retries Exhausted"}, + {0x1102, "Error Too Long To Correct"}, + {0x1103, "Multiple Read Errors"}, + {0x1104, "Unrecovered Read Error - Auto Reallocate Failed"}, + {0x110A, "Miscorrected Error"}, + {0x110B, "Unrecovered Read Error - Recommend Reassignment"}, + {0x110C, "Unrecovered Read Error - Recommend Rewrite The Data"}, + {0x110D, "De-Compression Crc Error"}, + {0x110E, "Cannot Decompress Using Declared Algorithm"}, + {0x1200, "Address Mark Not Found For Id Field"}, + {0x1300, "Address Mark Not Found For Data Field"}, + {0x1400, "Recorded Entity Not Found"}, + {0x1401, "Record Not Found"}, + {0x1405, "Record Not Found - Recommend Reassignment"}, + {0x1406, "Record Not Found - Data Auto-Reallocated"}, + {0x1500, "Random Positioning Error"}, + {0x1501, "Mechanical Positioning Error"}, + {0x1502, "Positioning Error Detected By Read Of Medium"}, + {0x1600, "Data Synchronization Mark Error"}, + {0x1601, "Data Sync Error - Data Rewritten"}, + {0x1602, "Data Sync Error - Recommend Rewrite"}, + {0x1603, "Data Sync Error - Data Auto-Reallocated"}, + {0x1604, "Data Sync Error - Recommend Reassignment"}, + {0x1700, "Recovered Data With No Error Correction Applied"}, + {0x1701, "Recovered Data With Retries"}, + {0x1702, "Recovered Data With Positive Head Offset"}, + {0x1703, "Recovered Data With Negative Head Offset"}, + {0x1705, "Recovered Data Using Previous Sector Id"}, + {0x1706, "Recovered Data Without Ecc - Data Auto-Reallocated"}, + {0x1707, "Recovered Data Without Ecc - Recommend Reassignment"}, + {0x1708, "Recovered Data Without Ecc - Recommend Rewrite"}, + {0x1709, "Recovered Data Without Ecc - Data Rewritten"}, + {0x1800, "Recovered Data With Error Correction Applied"}, + {0x1801, "Recovered Data With Error Corr. & Retries Applied"}, + {0x1802, "Recovered Data - Data Auto-Reallocated"}, + {0x1805, "Recovered Data - Recommend Reassignment"}, + {0x1806, "Recovered Data - Recommend Rewrite"}, + {0x1807, "Recovered Data With Ecc - Data Rewritten"}, + {0x1900, "List Error"}, + {0x1901, "List Not Available"}, + {0x1902, "List Error In Primary List"}, + {0x1903, "List Error In Grown List"}, + {0x1A00, "Parameter List Length Error"}, + {0x1B00, "Synchronous Data Transfer Error"}, + {0x1C00, "Defect List Not Found"}, + {0x1C01, "Primary Defect List Not Found"}, + {0x1C02, "Grown Defect List Not Found"}, + {0x1D00, "Miscompare During Verify Operation"}, + {0x1E00, "Recovered Id With Ecc Correction"}, + {0x1F00, "Defect List Transfer"}, + {0x2000, "Invalid Command Operation Code"}, + {0x2100, "Logical Block Address Out Of Range"}, + {0x2101, "Invalid Element Address"}, + {0x2400, "Invalid Field In Cdb"}, + {0x2401, "Cdb Decryption Error"}, + {0x2500, "Logical Unit Not Supported"}, + {0x2600, "Invalid Field In Parameter List"}, + {0x2601, "Parameter Not Supported"}, + {0x2602, "Parameter Value Invalid"}, + {0x2603, "Threshold Parameters Not Supported"}, + {0x2604, "Invalid Release Of Persistent Reservation"}, + {0x2605, "Data Decryption Error"}, + {0x2606, "Too Many Target Descriptors"}, + {0x2607, "Unsupported Target Descriptor Type Code"}, + {0x2608, "Too Many Segment Descriptors"}, + {0x2609, "Unsupported Segment Descriptor Type Code"}, + {0x260A, "Unexpected Inexact Segment"}, + {0x260B, "Inline Data Length Exceeded"}, + {0x260C, "Invalid Operation For Copy Source Or Destination"}, + {0x260D, "Copy Segment Granularity Violation"}, + {0x2700, "Write Protected"}, + {0x2701, "Hardware Write Protected"}, + {0x2702, "Logical Unit Software Write Protected"}, + {0x2800, "Not Ready To Ready Change, Medium May Have Changed"}, + {0x2801, "Import Or Export Element Accessed"}, + {0x2900, "Power On, Reset, Or Bus Device Reset Occurred"}, + {0x2901, "Power On Occurred"}, + {0x2902, "Scsi Bus Reset Occurred"}, + {0x2903, "Bus Device Reset Function Occurred"}, + {0x2904, "Device Internal Reset"}, + {0x2905, "Transceiver Mode Changed To Single-Ended"}, + {0x2906, "Transceiver Mode Changed To Lvd"}, + {0x2A00, "Parameters Changed"}, + {0x2A01, "Mode Parameters Changed"}, + {0x2A02, "Log Parameters Changed"}, + {0x2A03, "Reservations Preempted"}, + {0x2A04, "Reservations Released"}, + {0x2A05, "Registrations Preempted"}, + {0x2B00, "Copy Cannot Execute Since Host Cannot Disconnect"}, + {0x2C00, "Command Sequence Error"}, + {0x2F00, "Commands Cleared By Another Initiator"}, + {0x3000, "Incompatible Medium Installed"}, + {0x3001, "Cannot Read Medium - Unknown Format"}, + {0x3002, "Cannot Read Medium - Incompatible Format"}, + {0x3003, "Cleaning Cartridge Installed"}, + {0x3004, "Cannot Write Medium - Unknown Format"}, + {0x3005, "Cannot Write Medium - Incompatible Format"}, + {0x3006, "Cannot Format Medium - Incompatible Medium"}, + {0x3007, "Cleaning Failure"}, + {0x3100, "Medium Format Corrupted"}, + {0x3101, "Format Command Failed"}, + {0x3200, "No Defect Spare Location Available"}, + {0x3201, "Defect List Update Failure"}, + {0x3400, "Enclosure Failure"}, + {0x3500, "Enclosure Services Failure"}, + {0x3501, "Unsupported Enclosure Function"}, + {0x3502, "Enclosure Services Unavailable"}, + {0x3503, "Enclosure Services Transfer Failure"}, + {0x3504, "Enclosure Services Transfer Refused"}, + {0x3700, "Rounded Parameter"}, + {0x3900, "Saving Parameters Not Supported"}, + {0x3A00, "Medium Not Present"}, + {0x3A01, "Medium Not Present - Tray Closed"}, + {0x3A02, "Medium Not Present - Tray Open"}, + {0x3A03, "Medium Not Present - Loadable"}, + {0x3A04, "Medium Not Present - Medium Auxiliary Memory Accessible"}, + {0x3B0D, "Medium Destination Element Full"}, + {0x3B0E, "Medium Source Element Empty"}, + {0x3B11, "Medium Magazine Not Accessible"}, + {0x3B12, "Medium Magazine Removed"}, + {0x3B13, "Medium Magazine Inserted"}, + {0x3B14, "Medium Magazine Locked"}, + {0x3B15, "Medium Magazine Unlocked"}, + {0x3D00, "Invalid Bits In Identify Message"}, + {0x3E00, "Logical Unit Has Not Self-Configured Yet"}, + {0x3E01, "Logical Unit Failure"}, + {0x3E02, "Timeout On Logical Unit"}, + {0x3E03, "Logical Unit Failed Self-Test"}, + {0x3E04, "Logical Unit Unable To Update Self-Test Log"}, + {0x3F00, "Target Operating Conditions Have Changed"}, + {0x3F01, "Microcode Has Been Changed"}, + {0x3F02, "Changed Operating Definition"}, + {0x3F03, "Inquiry Data Has Changed"}, + {0x3F04, "Component Device Attached"}, + {0x3F05, "Device Identifier Changed"}, + {0x3F06, "Redundancy Group Created Or Modified"}, + {0x3F07, "Redundancy Group Deleted"}, + {0x3F08, "Spare Created Or Modified"}, + {0x3F09, "Spare Deleted"}, + {0x3F0A, "Volume Set Created Or Modified"}, + {0x3F0B, "Volume Set Deleted"}, + {0x3F0C, "Volume Set Deassigned"}, + {0x3F0D, "Volume Set Reassigned"}, + {0x3F0E, "Reported Luns Data Has Changed"}, + {0x3F0F, "Echo Buffer Overwritten"}, + {0x3F10, "Medium Loadable"}, + {0x3F11, "Medium Auxiliary Memory Accessible"}, + {0x4200, "Self-Test Failure (Should Use 40 Nn)"}, + {0x4300, "Message Error"}, + {0x4400, "Internal Target Failure"}, + {0x4500, "Select Or Reselect Failure"}, + {0x4600, "Unsuccessful Soft Reset"}, + {0x4700, "Scsi Parity Error"}, + {0x4701, "Data Phase Crc Error Detected"}, + {0x4702, "Scsi Parity Error Detected During St Data Phase"}, + {0x4703, "Information Unit Crc Error Detected"}, + {0x4704, "Asynchronous Information Protection Error Detected"}, + {0x4800, "Initiator Detected Error Message Received"}, + {0x4900, "Invalid Message Error"}, + {0x4A00, "Command Phase Error"}, + {0x4B00, "Data Phase Error"}, + {0x4C00, "Logical Unit Failed Self-Configuration"}, + {0x4D00, "Tagged Overlapped Commands (Nn = Queue Tag)"}, + {0x4E00, "Overlapped Commands Attempted"}, + {0x5300, "Media Load Or Eject Failed"}, + {0x5302, "Medium Removal Prevented"}, + {0x5501, "System Buffer Full"}, + {0x5502, "Insufficient Reservation Resources"}, + {0x5503, "Insufficient Resources"}, + {0x5504, "Insufficient Registration Resources"}, + {0x5A00, "Operator Request Or State Change Input"}, + {0x5A01, "Operator Medium Removal Request"}, + {0x5A02, "Operator Selected Write Protect"}, + {0x5A03, "Operator Selected Write Permit"}, + {0x5B00, "Log Exception"}, + {0x5B01, "Threshold Condition Met"}, + {0x5B02, "Log Counter At Maximum"}, + {0x5B03, "Log List Codes Exhausted"}, + {0x5C00, "Change"}, + {0x5C02, "Synchronized"}, + {0x5D00, "Failure Prediction Threshold Exceeded"}, + {0x5D10, "Failure General Hard Drive Failure"}, + {0x5D11, "Failure Drive Error Rate Too High"}, + {0x5D12, "Failure Data Error Rate Too High"}, + {0x5D13, "Failure Seek Error Rate Too High"}, + {0x5D14, "Failure Too Many Block Reassigns"}, + {0x5D15, "Failure Access Times Too High"}, + {0x5D16, "Failure Start Unit Times Too High"}, + {0x5D17, "Failure Channel Parametrics"}, + {0x5D18, "Failure Controller Detected"}, + {0x5D19, "Failure Throughput Performance"}, + {0x5D1A, "Failure Seek Time Performance"}, + {0x5D1B, "Failure Spin-Up Retry Count"}, + {0x5D1C, "Failure Drive Calibration Retry"}, + {0x5D20, "Failure General Hard Drive Failure"}, + {0x5D21, "Failure Drive Error Rate Too High"}, + {0x5D22, "Failure Data Error Rate Too High"}, + {0x5D23, "Failure Seek Error Rate Too High"}, + {0x5D24, "Failure Too Many Block Reassigns"}, + {0x5D25, "Failure Access Times Too High"}, + {0x5D26, "Failure Start Unit Times Too High"}, + {0x5D27, "Failure Channel Parametrics"}, + {0x5D28, "Failure Controller Detected"}, + {0x5D29, "Failure Throughput Performance"}, + {0x5D2A, "Failure Seek Time Performance"}, + {0x5D2B, "Failure Spin-Up Retry Count"}, + {0x5D2C, "Failure Drive Calibration Retry"}, + {0x5D30, "Impending Failure General Hard Drive"}, + {0x5D31, "Impending Failure Drive Error Rate Too High"}, + {0x5D32, "Impending Failure Data Error Rate Too High"}, + {0x5D33, "Impending Failure Seek Error Rate Too High"}, + {0x5D34, "Impending Failure Too Many Block Reassigns"}, + {0x5D35, "Impending Failure Access Times Too High"}, + {0x5D36, "Impending Failure Start Unit Times Too High"}, + {0x5D37, "Impending Failure Channel Parametrics"}, + {0x5D38, "Impending Failure Controller Detected"}, + {0x5D39, "Impending Failure Throughput Performance"}, + {0x5D3A, "Impending Failure Seek Time Performance"}, + {0x5D3B, "Impending Failure Spin-Up Retry Count"}, + {0x5D3C, "Impending Failure Drive Calibration Retry"}, + {0x5D40, "Failure General Hard Drive Failure"}, + {0x5D41, "Failure Drive Error Rate Too High"}, + {0x5D42, "Failure Data Error Rate Too High"}, + {0x5D43, "Failure Seek Error Rate Too High"}, + {0x5D44, "Failure Too Many Block Reassigns"}, + {0x5D45, "Failure Access Times Too High"}, + {0x5D46, "Failure Start Unit Times Too High"}, + {0x5D47, "Failure Channel Parametrics"}, + {0x5D48, "Failure Controller Detected"}, + {0x5D49, "Failure Throughput Performance"}, + {0x5D4A, "Failure Seek Time Performance"}, + {0x5D4B, "Failure Spin-Up Retry Count"}, + {0x5D4C, "Failure Drive Calibration Retry Count"}, + {0x5D50, "Failure General Hard Drive Failure"}, + {0x5D51, "Failure Drive Error Rate Too High"}, + {0x5D52, "Failure Data Error Rate Too High"}, + {0x5D53, "Failure Seek Error Rate Too High"}, + {0x5D54, "Failure Too Many Block Reassigns"}, + {0x5D55, "Failure Access Times Too High"}, + {0x5D56, "Failure Start Unit Times Too High"}, + {0x5D57, "Failure Channel Parametrics"}, + {0x5D58, "Failure Controller Detected"}, + {0x5D59, "Failure Throughput Performance"}, + {0x5D5A, "Failure Seek Time Performance"}, + {0x5D5B, "Failure Spin-Up Retry Count"}, + {0x5D5C, "Failure Drive Calibration Retry Count"}, + {0x5D60, "Failure General Hard Drive Failure"}, + {0x5D61, "Failure Drive Error Rate Too High"}, + {0x5D62, "Failure Data Error Rate Too High"}, + {0x5D63, "Failure Seek Error Rate Too High"}, + {0x5D64, "Failure Too Many Block Reassigns"}, + {0x5D65, "Failure Access Times Too High"}, + {0x5D66, "Failure Start Unit Times Too High"}, + {0x5D67, "Failure Channel Parametrics"}, + {0x5D68, "Failure Controller Detected"}, + {0x5D69, "Failure Throughput Performance"}, + {0x5D6A, "Failure Seek Time Performance"}, + {0x5D6B, "Failure Spin-Up Retry Count"}, + {0x5D6C, "Failure Drive Calibration Retry Count"}, + {0x5DFF, "Failure Prediction Threshold Exceeded (False)"}, + {0x5E00, "Low Power Condition On"}, + {0x5E01, "Idle Condition Activated By Timer"}, + {0x5E02, "Standby Condition Activated By Timer"}, + {0x5E03, "Idle Condition Activated By Command"}, + {0x5E04, "Standby Condition Activated By Command"}, + {0x6500, "Voltage Fault"}, + {0, NULL}, +}; + +/* SCSI Status Codes */ +static const value_string scsi_status_val[] = { + {0x00, "Good"}, + {0x02, "Check Condition"}, + {0x04, "Condition Met"}, + {0x08, "Busy"}, + {0x10, "Intermediate"}, + {0x14, "Intermediate Condition Met"}, + {0x18, "Reservation Conflict"}, + {0x28, "Task Set Full"}, + {0x30, "ACA Active"}, + {0x40, "Task Aborted"}, + {0, NULL}, +}; + +/* Function Decls; functions invoked by SAM-2 transport protocols such as + * FCP/iSCSI + */ +void dissect_scsi_cdb (tvbuff_t *, packet_info *, proto_tree *, guint, guint); +void dissect_scsi_rsp (tvbuff_t *, packet_info *, proto_tree *); +void dissect_scsi_payload (tvbuff_t *, packet_info *, proto_tree *, guint, + gboolean, guint32); +void dissect_scsi_snsinfo (tvbuff_t *, packet_info *, proto_tree *, guint, guint); +#endif