From 84123931970a8a0f1af281e7351eadabba3c0908 Mon Sep 17 00:00:00 2001 From: Guy Harris Date: Mon, 18 Jun 2001 02:18:27 +0000 Subject: From Joerg Mayer: explicitly fill in all members of a "header_field_info" structure, including the ones that are later set by the routines to register fields. svn path=/trunk/; revision=3561 --- packet-iscsi.c | 176 ++++++++++++++++++++++++++++----------------------------- 1 file changed, 88 insertions(+), 88 deletions(-) (limited to 'packet-iscsi.c') diff --git a/packet-iscsi.c b/packet-iscsi.c index ff8aae9718..fd5e1fe325 100644 --- a/packet-iscsi.c +++ b/packet-iscsi.c @@ -5,7 +5,7 @@ * Conforms to the protocol described in: draft-ietf-ips-iscsi-06.txt * Optionally, supports the protocol described in: draft-ietf-ips-iscsi-03.txt * - * $Id: packet-iscsi.c,v 1.5 2001/06/04 05:32:52 guy Exp $ + * $Id: packet-iscsi.c,v 1.6 2001/06/18 02:17:47 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs @@ -1236,439 +1236,439 @@ proto_register_iscsi(void) { &hf_iscsi_Payload, { "Payload", "iscsi.payload", FT_BYTES, BASE_HEX, NULL, 0, - "Payload (includes any header digest)" } + "Payload (includes any header digest)", HFILL } }, { &hf_iscsi_Opcode, { "Opcode", "iscsi.opcode", FT_UINT8, BASE_HEX, VALS(iscsi_opcodes), 0, - "Opcode" } + "Opcode", HFILL } }, { &hf_iscsi_Opcode_03, { "Opcode", "iscsi.opcode", FT_UINT8, BASE_HEX, VALS(iscsi_opcodes_03), 0, - "Opcode" } + "Opcode", HFILL } }, #if 0 { &hf_iscsi_X, { "X", "iscsi.x", FT_BOOLEAN, 8, TFS(&iscsi_meaning_X), 0x80, - "Command Retry" } + "Command Retry", HFILL } }, { &hf_iscsi_I, { "I", "iscsi.i", FT_BOOLEAN, 8, TFS(&iscsi_meaning_I), 0x40, - "Immediate delivery" } + "Immediate delivery", HFILL } }, #endif { &hf_iscsi_Flags, { "Flags", "iscsi.flags", FT_UINT8, BASE_HEX, NULL, 0, - "Opcode specific flags" } + "Opcode specific flags", HFILL } }, { &hf_iscsi_SCSICommand_X03, { "X", "iscsi.scsicommand.x", FT_BOOLEAN, 8, TFS(&iscsi_meaning_X), 0x80, - "Command Retry" } + "Command Retry", HFILL } }, { &hf_iscsi_SCSICommand_F, { "F", "iscsi.scsicommand.f", FT_BOOLEAN, 8, TFS(&iscsi_meaning_F), 0x80, - "PDU completes command" } + "PDU completes command", HFILL } }, { &hf_iscsi_SCSICommand_R, { "R", "iscsi.scsicommand.r", FT_BOOLEAN, 8, TFS(&iscsi_meaning_R), 0x40, - "Command reads from SCSI target" } + "Command reads from SCSI target", HFILL } }, { &hf_iscsi_SCSICommand_W, { "W", "iscsi.scsicommand.r", FT_BOOLEAN, 8, TFS(&iscsi_meaning_W), 0x20, - "Command writes to SCSI target" } + "Command writes to SCSI target", HFILL } }, { &hf_iscsi_SCSICommand_Attr, { "Attr", "iscsi.scsicommand.attr", FT_UINT8, BASE_HEX, VALS(iscsi_scsicommand_taskattrs), 0x07, - "SCSI task attributes" } + "SCSI task attributes", HFILL } }, { &hf_iscsi_SCSICommand_CRN, { "CRN", "iscsi.scsicommand.crn", FT_UINT8, BASE_HEX, NULL, 0, - "SCSI command reference number" } + "SCSI command reference number", HFILL } }, { &hf_iscsi_SCSICommand_AddCDB, { "AddCDB", "iscsi.scsicommand.addcdb", FT_UINT8, BASE_HEX, NULL, 0, - "Additional CDB length (in 4 byte units)" } + "Additional CDB length (in 4 byte units)", HFILL } }, { &hf_iscsi_Length03, { "Length", "iscsi.length", FT_UINT32, BASE_HEX, NULL, 0, - "Data length (bytes)" } + "Data length (bytes)", HFILL } }, { &hf_iscsi_DataSegmentLength, { "DataSegmentLength", "iscsi.datasegmentlength", FT_UINT32, BASE_HEX, NULL, 0, - "Data segment length (bytes)" } + "Data segment length (bytes)", HFILL } }, { &hf_iscsi_TotalAHSLength, { "TotalAHSLength", "iscsi.totalahslength", FT_UINT8, BASE_HEX, NULL, 0, - "Total additional header segment length (4 byte words)" } + "Total additional header segment length (4 byte words)", HFILL } }, { &hf_iscsi_LUN, { "LUN", "iscsi.lun", FT_BYTES, BASE_HEX, NULL, 0, - "Logical Unit Number" } + "Logical Unit Number", HFILL } }, { &hf_iscsi_InitiatorTaskTag, { "InitiatorTaskTag", "iscsi.initiatortasktag", FT_UINT32, BASE_HEX, NULL, 0, - "Initiator's task tag" } + "Initiator's task tag", HFILL } }, { &hf_iscsi_ExpectedDataTransferLength, { "ExpectedDataTransferLength", "iscsi.scsicommand.expecteddatatransferlength", FT_UINT32, BASE_HEX, NULL, 0, - "Expected length of data transfer" } + "Expected length of data transfer", HFILL } }, { &hf_iscsi_CmdSN, { "CmdSN", "iscsi.cmdsn", FT_UINT32, BASE_HEX, NULL, 0, - "Sequence number for this command (0 == immediate)" } + "Sequence number for this command (0 == immediate)", HFILL } }, { &hf_iscsi_ExpStatSN, { "ExpStatSN", "iscsi.expstatsn", FT_UINT32, BASE_HEX, NULL, 0, - "Next expected status sequence number" } + "Next expected status sequence number", HFILL } }, { &hf_iscsi_SCSICommand_CDB, { "CDB", "iscsi.scsicommand.cdb", FT_BYTES, BASE_HEX, NULL, 0, - "SCSI CDB" } + "SCSI CDB", HFILL } }, { &hf_iscsi_SCSICommand_CDB0, { "CDB", "iscsi.scsicommand.cdb0", FT_UINT8, BASE_HEX, VALS(iscsi_scsi_cdb0), 0, - "SCSI CDB[0]" } + "SCSI CDB[0]", HFILL } }, { &hf_iscsi_SCSIResponse_BasicResidualCount, { "BasicResidualCount", "iscsi.scsiresponse.basicresidualcount", FT_UINT32, BASE_HEX, NULL, 0, - "Residual count" } + "Residual count", HFILL } }, { &hf_iscsi_StatSN, { "StatSN", "iscsi.statsn", FT_UINT32, BASE_HEX, NULL, 0, - "Status sequence number" } + "Status sequence number", HFILL } }, { &hf_iscsi_ExpCmdSN, { "ExpCmdSN", "iscsi.expcmdsn", FT_UINT32, BASE_HEX, NULL, 0, - "Next expected command sequence number" } + "Next expected command sequence number", HFILL } }, { &hf_iscsi_MaxCmdSN, { "MaxCmdSN", "iscsi.maxcmdsn", FT_UINT32, BASE_HEX, NULL, 0, - "Maximum acceptable command sequence number" } + "Maximum acceptable command sequence number", HFILL } }, { &hf_iscsi_SCSIResponse_o03, { "o", "iscsi.scsiresponse.o", FT_BOOLEAN, 8, TFS(&iscsi_meaning_o), 0x08, - "Bi-directional read residual overflow" } + "Bi-directional read residual overflow", HFILL } }, { &hf_iscsi_SCSIResponse_u03, { "u", "iscsi.scsiresponse.u", FT_BOOLEAN, 8, TFS(&iscsi_meaning_u), 0x04, - "Bi-directional read residual underflow" } + "Bi-directional read residual underflow", HFILL } }, { &hf_iscsi_SCSIResponse_O03, { "O", "iscsi.scsiresponse.O", FT_BOOLEAN, 8, TFS(&iscsi_meaning_O), 0x02, - "Residual overflow" } + "Residual overflow", HFILL } }, { &hf_iscsi_SCSIResponse_U03, { "U", "iscsi.scsiresponse.U", FT_BOOLEAN, 8, TFS(&iscsi_meaning_U), 0x01, - "Residual underflow" } + "Residual underflow", HFILL } }, { &hf_iscsi_SCSIResponse_o, { "o", "iscsi.scsiresponse.o", FT_BOOLEAN, 8, TFS(&iscsi_meaning_o), 0x10, - "Bi-directional read residual overflow" } + "Bi-directional read residual overflow", HFILL } }, { &hf_iscsi_SCSIResponse_u, { "u", "iscsi.scsiresponse.u", FT_BOOLEAN, 8, TFS(&iscsi_meaning_u), 0x08, - "Bi-directional read residual underflow" } + "Bi-directional read residual underflow", HFILL } }, { &hf_iscsi_SCSIResponse_O, { "O", "iscsi.scsiresponse.O", FT_BOOLEAN, 8, TFS(&iscsi_meaning_O), 0x04, - "Residual overflow" } + "Residual overflow", HFILL } }, { &hf_iscsi_SCSIResponse_U, { "U", "iscsi.scsiresponse.U", FT_BOOLEAN, 8, TFS(&iscsi_meaning_U), 0x02, - "Residual underflow" } + "Residual underflow", HFILL } }, { &hf_iscsi_SCSIResponse_S, { "S", "iscsi.scsiresponse.S", FT_BOOLEAN, 8, TFS(&iscsi_meaning_scsiresponse_S), 0x01, - "Status/Response" } + "Status/Response", HFILL } }, { &hf_iscsi_CommandStatus03, { "CommandStatus", "iscsi.commandstatus", FT_UINT8, BASE_HEX, VALS(iscsi_scsi_statuses), 0, - "SCSI command status value" } + "SCSI command status value", HFILL } }, { &hf_iscsi_StatusResponse_is_status, { "Status/Response", "iscsi.scsiresponse.statusresponse", FT_UINT8, BASE_HEX, VALS(iscsi_scsi_statuses), 0, - "SCSI command status value" } + "SCSI command status value", HFILL } }, { &hf_iscsi_StatusResponse_is_response, { "Status/Response", "iscsi.scsiresponse.statusresponse", FT_UINT8, BASE_HEX, VALS(iscsi_scsi_responses), 0, - "iSCSI response value" } + "iSCSI response value", HFILL } }, { &hf_iscsi_SCSIResponse_SenseLength, { "SenseLength", "iscsi.scsiresponse.senselength", FT_UINT16, BASE_HEX, NULL, 0, - "SCSI sense data length" } + "SCSI sense data length", HFILL } }, { &hf_iscsi_SCSIResponse_BidiReadResidualCount, { "BidiReadResidualCount", "iscsi.scsiresponse.bidireadresidualcount", FT_UINT32, BASE_HEX, NULL, 0, - "Bi-directional read residual count" } + "Bi-directional read residual count", HFILL } }, { &hf_iscsi_SCSIData_F, { "F", "iscsi.scsidata.f", FT_BOOLEAN, 8, TFS(&iscsi_meaning_F), 0x80, - "Final PDU" } + "Final PDU", HFILL } }, { &hf_iscsi_SCSIData_P03, { "P", "iscsi.scsidata.p", FT_BOOLEAN, 8, TFS(&iscsi_meaning_P), 0x80, - "Poll requested" } + "Poll requested", HFILL } }, { &hf_iscsi_SCSIData_S03, { "S", "iscsi.scsidata.s", FT_BOOLEAN, 8, TFS(&iscsi_meaning_S), 0x04, - "PDU Contains SCSI command status" } + "PDU Contains SCSI command status", HFILL } }, { &hf_iscsi_SCSIData_O03, { "O", "iscsi.scsidata.O", FT_BOOLEAN, 8, TFS(&iscsi_meaning_O), 0x02, - "Residual overflow" } + "Residual overflow", HFILL } }, { &hf_iscsi_SCSIData_U03, { "U", "iscsi.scsidata.U", FT_BOOLEAN, 8, TFS(&iscsi_meaning_U), 0x01, - "Residual underflow" } + "Residual underflow", HFILL } }, { &hf_iscsi_SCSIData_S, { "S", "iscsi.scsidata.s", FT_BOOLEAN, 8, TFS(&iscsi_meaning_S), 0x01, - "PDU Contains SCSI command status" } + "PDU Contains SCSI command status", HFILL } }, { &hf_iscsi_SCSIData_U, { "U", "iscsi.scsidata.U", FT_BOOLEAN, 8, TFS(&iscsi_meaning_U), 0x02, - "Residual underflow" } + "Residual underflow", HFILL } }, { &hf_iscsi_SCSIData_O, { "O", "iscsi.scsidata.O", FT_BOOLEAN, 8, TFS(&iscsi_meaning_O), 0x04, - "Residual overflow" } + "Residual overflow", HFILL } }, { &hf_iscsi_TargetTransferTag, { "TargetTransferTag", "iscsi.targettransfertag", FT_UINT32, BASE_HEX, NULL, 0, - "Target transfer tag" } + "Target transfer tag", HFILL } }, { &hf_iscsi_BufferOffset, { "BufferOffset", "iscsi.bufferOffset", FT_UINT32, BASE_HEX, NULL, 0, - "Buffer offset" } + "Buffer offset", HFILL } }, { &hf_iscsi_SCSIData_ResidualCount, { "ResidualCount", "iscsi.scsidata.readresidualcount", FT_UINT32, BASE_HEX, NULL, 0, - "Residual count" } + "Residual count", HFILL } }, { &hf_iscsi_DataSN, { "DataSN", "iscsi.datasn", FT_UINT32, BASE_HEX, NULL, 0, - "Data sequence number" } + "Data sequence number", HFILL } }, { &hf_iscsi_VersionMax, { "VersionMax", "iscsi.versionmax", FT_UINT8, BASE_HEX, NULL, 0, - "Maximum supported protocol version" } + "Maximum supported protocol version", HFILL } }, { &hf_iscsi_VersionMin, { "VersionMin", "iscsi.versionmin", FT_UINT8, BASE_HEX, NULL, 0, - "Minimum supported protocol version" } + "Minimum supported protocol version", HFILL } }, { &hf_iscsi_CID, { "CID", "iscsi.cid", FT_UINT16, BASE_HEX, NULL, 0, - "Connection identifier" } + "Connection identifier", HFILL } }, { &hf_iscsi_ISID, { "ISID", "iscsi.isid", FT_UINT16, BASE_HEX, NULL, 0, - "Initiator part of session identifier" } + "Initiator part of session identifier", HFILL } }, { &hf_iscsi_TSID, { "TSID", "iscsi.tsid", FT_UINT16, BASE_HEX, NULL, 0, - "Target part of session identifier" } + "Target part of session identifier", HFILL } }, { &hf_iscsi_InitStatSN, { "InitStatSN", "iscsi.initstatsn", FT_UINT32, BASE_HEX, NULL, 0, - "Initial status sequence number" } + "Initial status sequence number", HFILL } }, { &hf_iscsi_InitCmdSN, { "InitCmdSN", "iscsi.initcmdsn", FT_UINT32, BASE_HEX, NULL, 0, - "Initial command sequence number" } + "Initial command sequence number", HFILL } }, { &hf_iscsi_Login_F, { "F", "iscsi.login.f", FT_BOOLEAN, 8, TFS(&iscsi_meaning_F), 0x80, - "Final PDU in login sequence" } + "Final PDU in login sequence", HFILL } }, { &hf_iscsi_Login_Status03, { "Status", "iscsi.login.status", FT_UINT8, BASE_HEX, VALS(iscsi_login_status03), 0, - "Status" } + "Status", HFILL } }, { &hf_iscsi_Login_Status, { "Status", "iscsi.login.status", FT_UINT16, BASE_HEX, VALS(iscsi_login_status), 0, - "Status class and detail" } + "Status class and detail", HFILL } }, { &hf_iscsi_KeyValue, { "KeyValue", "iscsi.keyvalue", FT_STRING, 0, NULL, 0, - "Key/value pair" } + "Key/value pair", HFILL } }, { &hf_iscsi_Text_F, { "F", "iscsi.text.f", FT_BOOLEAN, 8, TFS(&iscsi_meaning_F), 0x80, - "Final PDU in text sequence" } + "Final PDU in text sequence", HFILL } }, { &hf_iscsi_NOP_P, { "P", "iscsi.nop.p", FT_BOOLEAN, 8, TFS(&iscsi_meaning_P), 0x80, - "Poll requested" } + "Poll requested", HFILL } }, { &hf_iscsi_ExpDataSN, { "ExpCmdSN", "iscsi.expdatasn", FT_UINT32, BASE_HEX, NULL, 0, - "Next expected data sequence number" } + "Next expected data sequence number", HFILL } }, { &hf_iscsi_R2TExpDataSN, { "R2TExpCmdSN", "iscsi.r2texpdatasn", FT_UINT32, BASE_HEX, NULL, 0, - "Next expected R2T data sequence number" } + "Next expected R2T data sequence number", HFILL } }, { &hf_iscsi_SCSITask_Response, { "Response", "iscsi.scsitask.response", FT_UINT8, BASE_HEX, VALS(iscsi_task_responses), 0, - "Response" } + "Response", HFILL } }, { &hf_iscsi_SCSITask_ReferencedTaskTag, { "InitiatorTaskTag", "iscsi.scsitask.referencedtasktag", FT_UINT32, BASE_HEX, NULL, 0, - "Task's initiator task tag" } + "Task's initiator task tag", HFILL } }, { &hf_iscsi_SCSITask_Function, { "Function", "iscsi.scsitask.function", FT_UINT8, BASE_HEX, VALS(iscsi_task_functions), 0x7F, - "Requested task function" } + "Requested task function", HFILL } }, { &hf_iscsi_Logout_Reason03, { "Reason", "iscsi.logout.reason", FT_UINT8, BASE_HEX, VALS(iscsi_logout_reasons03), 0, - "Reason for logout" } + "Reason for logout", HFILL } }, { &hf_iscsi_Logout_Reason, { "Reason", "iscsi.logout.reason", FT_UINT8, BASE_HEX, VALS(iscsi_logout_reasons), 0, - "Reason for logout" } + "Reason for logout", HFILL } }, { &hf_iscsi_Logout_Response, { "Response", "iscsi.logout.response", FT_UINT8, BASE_HEX, VALS(iscsi_logout_response), 0, - "Logout response" } + "Logout response", HFILL } }, { &hf_iscsi_DesiredDataLength, { "DesiredDataLength", "iscsi.desireddatalength", FT_UINT32, BASE_HEX, NULL, 0, - "Desired data length (bytes)" } + "Desired data length (bytes)", HFILL } }, { &hf_iscsi_SCSIEvent03, { "SCSIEvent", "iscsi.scsievent", FT_UINT8, BASE_HEX, VALS(iscsi_scsievents03), 0, - "SCSI event indicator" } + "SCSI event indicator", HFILL } }, { &hf_iscsi_iSCSIEvent03, { "iSCSIEvent", "iscsi.iscsievent", FT_UINT8, BASE_HEX, VALS(iscsi_iscsievents03), 0, - "iSCSI event indicator" } + "iSCSI event indicator", HFILL } }, { &hf_iscsi_Parameter1, { "Parameter1", "iscsi.parameter1", FT_UINT16, BASE_HEX, NULL, 0, - "Parameter 1" } + "Parameter 1", HFILL } }, { &hf_iscsi_Parameter2, { "Parameter2", "iscsi.parameter2", FT_UINT16, BASE_HEX, NULL, 0, - "Parameter 2" } + "Parameter 2", HFILL } }, { &hf_iscsi_Reject_Reason, { "Reason", "iscsi.reject.reason", FT_UINT8, BASE_HEX, VALS(iscsi_reject_reasons), 0, - "Reason for command rejection" } + "Reason for command rejection", HFILL } }, { &hf_iscsi_Reject_FirstBadByte, { "FirstBadByte", "iscsi.reject.firstbadbyte", FT_UINT16, BASE_HEX, NULL, 0, - "Offset of first bad byte in PDU when reason is 'format error'" } + "Offset of first bad byte in PDU when reason is 'format error'", HFILL } }, { &hf_iscsi_Reject_Reason03, { "Reason", "iscsi.reject.reason", FT_UINT8, BASE_HEX, VALS(iscsi_reject_reasons03), 0, - "Reason for command rejection" } + "Reason for command rejection", HFILL } }, { &hf_iscsi_SNACK_S, { "S", "iscsi.snack.s", FT_BOOLEAN, 8, TFS(&iscsi_meaning_SNACK_S), 0x01, - "Status not data SNACK requested" } + "Status not data SNACK requested", HFILL } }, { &hf_iscsi_AddRuns, { "AddRuns", "iscsi.snack.addruns", FT_UINT8, BASE_HEX, NULL, 0, - "Number of additional runs" } + "Number of additional runs", HFILL } }, { &hf_iscsi_BegRun, { "BegRun", "iscsi.snack.begrun", FT_UINT32, BASE_HEX, NULL, 0, - "First missed DataSN or StatSN" } + "First missed DataSN or StatSN", HFILL } }, { &hf_iscsi_RunLength, { "RunLength", "iscsi.snack.runlength", FT_UINT32, BASE_HEX, NULL, 0, - "Number of additional missing status PDUs in this run" } + "Number of additional missing status PDUs in this run", HFILL } }, { &hf_iscsi_AdditionalRuns, { "AdditionalRuns", "iscsi.snack.additionalruns", FT_BYTES, BASE_HEX, NULL, 0, - "Additional runs of missing status PDUs" } + "Additional runs of missing status PDUs", HFILL } }, }; -- cgit v1.2.1