TargetSenderWorker

package org.jscsi.target.connection;


import java.io.IOException;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SocketChannel;
import java.security.DigestException;

import org.jscsi.exception.InternetSCSIException;
import org.jscsi.parser.BasicHeaderSegment;
import org.jscsi.parser.InitiatorMessageParser;
import org.jscsi.parser.OperationCode;
import org.jscsi.parser.ProtocolDataUnit;
import org.jscsi.parser.ProtocolDataUnitFactory;
import org.jscsi.parser.TargetMessageParser;
import org.jscsi.parser.scsi.SCSICommandParser;
import org.jscsi.target.scsi.cdb.ScsiOperationCode;
import org.jscsi.target.settings.Settings;
import org.jscsi.target.settings.SettingsException;
import org.jscsi.target.settings.TextKeyword;
import org.jscsi.target.util.Debug;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * Instances of this class are used by {@link Connection} objects for sending and receiving {@link ProtocolDataUnit}
 * objects.
 *
 * @author Andreas Ergenzinger, University of Konstanz
 */
public class TargetSenderWorker {

    private static final Logger LOGGER = LoggerFactory.getLogger(TargetSenderWorker.class);

    /**
     * The connection which uses this object for sending and receiving PDUs.
     */
    final private Connection connection;

    /**
     * The session to which {@link #connection} belongs to.
     */
    private TargetSession session;

    /**
     * Used for writing serialized PDUs to and reading serialized PDUs from.
     */
    final private SocketChannel socketChannel;

    /**
     * Will be used to create {@link ProtocolDataUnit} objects from the byte stream read from the {@link #socketChannel}
     * .
     */
    final private ProtocolDataUnitFactory protocolDataUnitFactory;

    /**
     * If this is <code>true</code>, then the next PDU read from the {@link #socketChannel} will be the first PDU
     * received in the {@link #session}.
     * <p>
     * Will be initializes to <code>true</code> if and only if the {@link #connection} is the leading connection of its
     * session.
     * <p>
     * PDUs identified by this variable as the first PDU in a session will not have their counters (i.e. CmdSN and
     * ExpStatSN) checked. Instead the values of these counters will be used to initialize the targets local copies of
     * these counters that will be used to ensure that no PDUs have been lost in transit.
     */
    private boolean initialPdu;

    /**
     * Creates a new {@link TargetSenderWorker} object.
     *
     * @param connection the connection that will use this object for sending and receiving PDUs
     * @param socketChannel used for sending and receiving serialized PDU to and from the target
     */
    public TargetSenderWorker (final Connection connection, final SocketChannel socketChannel) {
        this.connection = connection;
        this.socketChannel = socketChannel;
        protocolDataUnitFactory = new ProtocolDataUnitFactory();
        initialPdu = connection.isLeadingConnection();
    }

    /**
     * Sets the {@link #session} variable.
     * <p>
     * During the time this object is initialized, the {@link Connection#getSession()} method will return
     * <code>null</code>. Therefore {@link #session} must be set manually once the {@link TargetSession} object has been
     * created.
     *
     * @param session the session of the {@link #connection}
     */
    void setSession (final TargetSession session) {
        this.session = session;
    }

    /**
     * This method does all the necessary steps, which are needed when a connection should be closed.
     *
     * @throws IOException if an I/O error occurs.
     */
    public final void close () throws IOException {
        socketChannel.close();
    }

    /**
     * Receives a <code>ProtocolDataUnit</code> from the socket and appends it to the end of the receiving queue of this
     * connection.
     *
     * @return Queue with the resulting units
     * @throws IOException if an I/O error occurs.
     * @throws InternetSCSIException if any violation of the iSCSI-Standard emerge.
     * @throws DigestException if a mismatch of the digest exists.
     * @throws SettingsException
     */
    ProtocolDataUnit receiveFromWire () throws DigestException , InternetSCSIException , IOException , SettingsException {

        ProtocolDataUnit pdu;
        if (initialPdu) {
            /*
             * The connection's ConnectionSettingsNegotiator has not been initialized, hence getSettings() would throw a
             * NullPointerException. Initialize PDU with default values, i.e. no digests.
             */
            pdu = protocolDataUnitFactory.create(TextKeyword.NONE,// header
                                                                  // digest
                    TextKeyword.NONE);// data digest
        } else {
            // use negotiated or (now available) default settings
            final Settings settings = connection.getSettings();
            pdu = protocolDataUnitFactory.create(settings.getHeaderDigest(), settings.getDataDigest());
        }

        try {
            pdu.read(socketChannel);
        } catch (ClosedChannelException e) {
            throw new InternetSCSIException(e);
        }

        if (LOGGER.isDebugEnabled()) LOGGER.debug("Receiving this PDU:\n" + pdu);

        // parse sequence counters
        final BasicHeaderSegment bhs = pdu.getBasicHeaderSegment();
        final InitiatorMessageParser parser = (InitiatorMessageParser) bhs.getParser();
        // final int commandSequenceNumber = parser.getCommandSequenceNumber();
        // final int expectedStatusSequenceNumber = parser.getExpectedStatusSequenceNumber();

        if (LOGGER.isDebugEnabled()) {
            // sharrajesh
            // Needed to debug, out of order receiving of StatusSN and ExpStatSN
            if (bhs.getOpCode() == OperationCode.SCSI_COMMAND) {
                final SCSICommandParser scsiParser = (SCSICommandParser) bhs.getParser();
                ScsiOperationCode scsiOpCode = ScsiOperationCode.valueOf(scsiParser.getCDB().get(0));
                LOGGER.debug("scsiOpCode = " + scsiOpCode);
                LOGGER.debug("CDB bytes: \n" + Debug.byteBufferToString(scsiParser.getCDB()));
            }
            // LOGGER.debug("parser.expectedStatusSequenceNumber: " + expectedStatusSequenceNumber);
            if (connection == null)
                LOGGER.debug("connection: null");
            else if (connection.getStatusSequenceNumber() == null)
                LOGGER.debug("connection.getStatusSequenceNumber: null");
            else
                LOGGER.debug("connection.getStatusSequenceNumber: " + connection.getStatusSequenceNumber().getValue());
        }

        // if this is the first PDU in the leading connection, then
        // initialize the session's ExpectedCommandSequenceNumber
        if (initialPdu) {
            initialPdu = false;
            // PDU is immediate Login PDU, checked in Target.main(),
            // ExpCmdSN of this PDU will be used to initialize the
            // respective session and connection parameters (sequence numbers)
            // see TargetSession and TargetConnection initialization in
            // Target.main()
        } else {
            // check sequence counters
            // if (session.getMaximumCommandSequenceNumber().lessThan(commandSequenceNumber))
            // throw new InternetSCSIException("received CmdSN > local MaxCmdSN");

            // verified, is working with Windows 8 initiator
            // if (!connection.getStatusSequenceNumber().equals(expectedStatusSequenceNumber)
            // && expectedStatusSequenceNumber != 0)// required by MS iSCSI
            // // initiator DATA-OUT
            // // PDU sequence
            // throw new InternetSCSIException("received ExpStatusSN != local StatusSN + 1");
        }

        // increment CmdSN if not immediate PDU (or Data-Out PDU)
        try {
            if (parser.incrementSequenceNumber()) session.getExpectedCommandSequenceNumber().increment();
        } catch (NullPointerException exc) {

        }

        return pdu;
    }

    /**
     * Sends the given <code>ProtocolDataUnit</code> instance over the socket to the connected iSCSI Target.
     *
     * @param pdu The <code>ProtocolDataUnit</code> instances to send.
     * @throws InternetSCSIException if any violation of the iSCSI-Standard emerge.
     * @throws IOException if an I/O error occurs.
     * @throws InterruptedException if another caller interrupted the current caller before or while the current caller
     *             was waiting for a notification. The interrupted status of the current caller is cleared when this
     *             exception is thrown.
     */

    final void sendOverWire (final ProtocolDataUnit pdu) throws InternetSCSIException , IOException , InterruptedException {

        // set sequence counters
        final TargetMessageParser parser = (TargetMessageParser) pdu.getBasicHeaderSegment().getParser();
        parser.setExpectedCommandSequenceNumber(session.getExpectedCommandSequenceNumber().getValue());
        parser.setMaximumCommandSequenceNumber(session.getMaximumCommandSequenceNumber().getValue());
        final boolean incrementSequenceNumber = parser.incrementSequenceNumber();
        if (incrementSequenceNumber) // set StatSN only if field is not reserved
        parser.setStatusSequenceNumber(connection.getStatusSequenceNumber().getValue());

        if (LOGGER.isDebugEnabled()) LOGGER.debug("Sending this PDU:\n" + pdu);

        // send pdu
        pdu.write(socketChannel);

        // increment StatusSN if this was a Response PDU (with status)
        // or if special cases apply
        if (incrementSequenceNumber) connection.getStatusSequenceNumber().increment();

    }
}