this.sensorOwnerId = sensorOwnerId;
    }

    public AddressType getAddressType() {
        return addressType;
    }

    public void setAddressType(AddressType addressType) {
        this.addressType = addressType;
    }

    public byte getChannelNumber() {
        return channelNumber;
    }

    public void setChannelNumber(byte channelNumber) {
        this.channelNumber = channelNumber;
    }

    public byte getSensorOwnerLun() {
        return sensorOwnerLun;
    }

    public void setSensorOwnerLun(byte sensorOwnerLun) {
        this.sensorOwnerLun = sensorOwnerLun;
    }

    public byte getSensorNumber() {
        return sensorNumber;
    }

    public void setSensorNumber(byte sensorNumber) {
        this.sensorNumber = sensorNumber;
    }

    public EntityId getEntityId() {
        return entityId;
    }

    public void setEntityId(EntityId entityId) {
        this.entityId = entityId;
    }

    public boolean isEntityPhysical() {
        return entityPhysical;
    }

    public void setEntityPhysical(boolean entityPhysical) {
        this.entityPhysical = entityPhysical;
    }

    public byte getEntityInstanceNumber() {
        return entityInstanceNumber;
    }

    public void setEntityInstanceNumber(byte entityInstanceNumber) {
        this.entityInstanceNumber = entityInstanceNumber;
    }

    public boolean isHysteresisReadable() {
        return hysteresisReadable;
    }

    public void setHysteresisReadable(boolean hysteresisReadable) {
        this.hysteresisReadable = hysteresisReadable;
    }

    public boolean isThresholdsReadable() {
        return thresholdsReadable;
    }

    public void setThresholdsReadable(boolean thresholdsReadable) {
        this.thresholdsReadable = thresholdsReadable;
    }

    public SensorType getSensorType() {
        return sensorType;
    }

    public void setSensorType(SensorType sensorType) {
        this.sensorType = sensorType;
    }

    public int getEventReadingType() {
        return eventReadingType;
    }

    public void setEventReadingType(int eventReadingType) {
        this.eventReadingType = eventReadingType;
    }

    public RateUnit getRateUnit() {
        return rateUnit;
    }

    public void setRateUnit(RateUnit rateUnit) {
        this.rateUnit = rateUnit;
    }

    public ModifierUnitUsage getModifierUnitUsage() {
        return modifierUnitUsage;
    }

    public void setModifierUnitUsage(ModifierUnitUsage modifierUnitUsage) {
        this.modifierUnitUsage = modifierUnitUsage;
    }

    public SensorUnit getSensorBaseUnit() {
        return sensorBaseUnit;
    }

    public void setSensorBaseUnit(SensorUnit sensorBaseUnit) {
        this.sensorBaseUnit = sensorBaseUnit;
    }

    public SensorUnit getSensorModifierUnit() {
        return sensorModifierUnit;
    }

    public void setSensorModifierUnit(SensorUnit sensorModifierUnit) {
        this.sensorModifierUnit = sensorModifierUnit;
    }

}

    public byte getSensorOwnerId() {
        return sensorOwnerId;
    }

    public void setSensorOwnerId(byte sensorOwnerId) {
        this.sensorOwnerId = sensorOwnerId;
    }

    public AddressType getAddressType() {
        return addressType;
    }

    public void setAddressType(AddressType addressType) {
        this.addressType = addressType;
    }

    public byte getChannelNumber() {
        return channelNumber;
    }

    public void setChannelNumber(byte channelNumber) {
        this.channelNumber = channelNumber;
    }

    public byte getSensorOwnerLun() {
        return sensorOwnerLun;
    }

    public void setSensorOwnerLun(byte sensorOwnerLun) {
        this.sensorOwnerLun = sensorOwnerLun;
    }

    public byte getSensorNumber() {
        return sensorNumber;
    }

    public void setSensorNumber(byte sensorNumber) {
        this.sensorNumber = sensorNumber;
    }

    public EntityId getEntityId() {
        return entityId;
    }

    public void setEntityId(EntityId entityId) {
        this.entityId = entityId;
    }

    public boolean isEntityPhysical() {
        return entityPhysical;
    }

    public void setEntityPhysical(boolean entityPhysical) {
        this.entityPhysical = entityPhysical;
    }

    public byte getEntityInstanceNumber() {
        return entityInstanceNumber;
    }

    public void setEntityInstanceNumber(byte entityInstanceNumber) {
        this.entityInstanceNumber = entityInstanceNumber;
    }

    public boolean isHysteresisReadable() {

@Override
    protected void populateTypeSpecficValues(byte[] recordData,
            SensorRecord record) {
        setSensorOwnerId(TypeConverter.intToByte((TypeConverter
                .byteToInt(recordData[5]) & 0xfe) >> 1));

        setAddressType(AddressType.parseInt(TypeConverter
                .byteToInt(recordData[5]) & 0x01));

        setChannelNumber(TypeConverter.intToByte((TypeConverter
                .byteToInt(recordData[6]) & 0xf0) >> 4));

        setSensorOwnerLun(TypeConverter.intToByte(TypeConverter
                .byteToInt(recordData[6]) & 0x3));

        setSensorNumber(recordData[7]);

        setEntityId(EntityId.parseInt(TypeConverter.byteToInt(recordData[8])));

        setEntityPhysical((TypeConverter.byteToInt(recordData[9]) & 0x80) == 0);

        setEntityInstanceNumber(TypeConverter.intToByte(TypeConverter
                .byteToInt(recordData[9]) & 0x7f));

        int hysteresis = (TypeConverter.byteToInt(recordData[11]) & 0x30) >> 4;

private SensorDirection sensorDirection;

    private String name;

    /**
     * The instance modifier is a character(s) that software can append to the
     * end of the ID String. This field selects whether the appended
     * character(s) will be numeric or alpha.
     */
    private InstanceModifierType idInstanceModifierType;

    /**
     * Sensor numbers sharing this record are sequential starting with the
     * sensor number specified by the Sensor Number field for this record.
     */
    private int shareCount;

    private boolean entityInstanceIncrements;

    /**
     * Suppose sensor ID is 'Temp' for 'Temperature Sensor', share count = 3, ID
     * string instance modifier = numeric, instance modifier offset = 5 - then
     * the sensors could be identified as: Temp 5, Temp 6, Temp 7 <br>
     * If the modifier = alpha, offset=0 corresponds to 'A', offset=25
     * corresponds to 'Z', and offset = 26 corresponds to 'AA', thus, for
     * offset=26 the sensors could be identified as: Temp AA, Temp AB, Temp AC
     */
    private int idInstanceModifierOffset;

    @Override
    protected void populateTypeSpecficValues(byte[] recordData,
            SensorRecord record) {
        setSensorOwnerId(TypeConverter.intToByte((TypeConverter
                .byteToInt(recordData[5]) & 0xfe) >> 1));

        setAddressType(AddressType.parseInt(TypeConverter
                .byteToInt(recordData[5]) & 0x01));

        setChannelNumber(TypeConverter.intToByte((TypeConverter
                .byteToInt(recordData[6]) & 0xf0) >> 4));

        setSensorOwnerLun(TypeConverter.intToByte(TypeConverter
                .byteToInt(recordData[6]) & 0x3));

        setSensorNumber(recordData[7]);

        setEntityId(EntityId.parseInt(TypeConverter.byteToInt(recordData[8])));

        setEntityPhysical((TypeConverter.byteToInt(recordData[9]) & 0x80) == 0);

        setEntityInstanceNumber(TypeConverter.intToByte(TypeConverter
                .byteToInt(recordData[9]) & 0x7f));

this.sensorOwnerId = sensorOwnerId;
    }


    public AddressType getAddressType() {
        return addressType;
    }


    public void setAddressType(AddressType addressType) {
        this.addressType = addressType;
    }


    public byte getChannelNumber() {
        return channelNumber;
    }


    public void setChannelNumber(byte channelNumber) {
        this.channelNumber = channelNumber;
    }


    public byte getSensorOwnerLun() {
        return sensorOwnerLun;
    }


    public void setSensorOwnerLun(byte sensorOwnerLun) {
        this.sensorOwnerLun = sensorOwnerLun;
    }


    public byte getSensorNumber() {
        return sensorNumber;
    }


    public void setSensorNumber(byte sensorNumber) {
        this.sensorNumber = sensorNumber;
    }


    public EntityId getEntityId() {
        return entityId;
    }


    public void setEntityId(EntityId entityId) {
        this.entityId = entityId;
    }


    public boolean isEntityPhysical() {
        return entityPhysical;
    }


    public void setEntityPhysical(boolean entityPhysical) {
        this.entityPhysical = entityPhysical;
    }


    public byte getEntityInstanceNumber() {
        return entityInstanceNumber;
    }


    public void setEntityInstanceNumber(byte entityInstanceNumber) {
        this.entityInstanceNumber = entityInstanceNumber;
    }


    public SensorType getSensorType() {

@Override
    protected void populateTypeSpecficValues(byte[] recordData,
            SensorRecord record) {

        setSensorOwnerId(TypeConverter.intToByte((TypeConverter
                .byteToInt(recordData[5]) & 0xfe) >> 1));

        setAddressType(AddressType.parseInt(TypeConverter
                .byteToInt(recordData[5]) & 0x01));

        setChannelNumber(TypeConverter.intToByte((TypeConverter
                .byteToInt(recordData[6]) & 0xf0) >> 4));

        setSensorOwnerLun(TypeConverter.intToByte(TypeConverter
                .byteToInt(recordData[6]) & 0x3));

        setSensorNumber(recordData[7]);

        setEntityId(EntityId.parseInt(TypeConverter.byteToInt(recordData[8])));

        setEntityPhysical((TypeConverter.byteToInt(recordData[9]) & 0x80) == 0);

        setEntityInstanceNumber(TypeConverter.intToByte(TypeConverter
                .byteToInt(recordData[9]) & 0x7f));

payload, TypeConverter.intToByte(sequenceNumber));
    }

    @Override
    public ResponseData getResponseData(IpmiMessage message) throws IPMIException, NoSuchAlgorithmException, InvalidKeyException {

        if (!isCommandResponse(message)) {
            throw new IllegalArgumentException(
                    "This is not a response for Get SDR Repository Info command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

        byte[] raw = message.getPayload().getIpmiCommandData();

        if (raw == null || raw.length < 2) {

setSensorType(SensorType.parseInt(TypeConverter
                .byteToInt(recordData[12])));

        setEventReadingType(TypeConverter.byteToInt(recordData[13]));

        setRateUnit(RateUnit
                .parseInt((TypeConverter.byteToInt(recordData[20]) & 0x38) >> 3));

        setModifierUnitUsage(ModifierUnitUsage.parseInt((TypeConverter
                .byteToInt(recordData[20]) & 0x6) >> 1));

        setSensorBaseUnit(SensorUnit.parseInt(TypeConverter
                .byteToInt(recordData[21])));

        setSensorModifierUnit(SensorUnit.parseInt(TypeConverter
                .byteToInt(recordData[22])));

payload, TypeConverter.intToByte(sequenceNumber));
    }

    @Override
    public ResponseData getResponseData(IpmiMessage message) throws IPMIException,
            NoSuchAlgorithmException, InvalidKeyException {
        if (!isCommandResponse(message)) {
            throw new IllegalArgumentException(
                    "This is not a response for Get SEL Entry command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

"This is not a response for Get SDR command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

        byte[] raw = message.getPayload().getIpmiCommandData();

        if (raw == null || raw.length < 3) {
            throw new IllegalArgumentException(
                    "Invalid response payload length");
        }

stateMachine.setCurrent(new OpenSessionComplete());
        } else if (machineEvent instanceof Timeout) {
            stateMachine.setCurrent(new Authcap());
        } else {
            stateMachine.doExternalAction(new ErrorAction(
                    new IllegalArgumentException("Invalid transition")));
        }
    }

    @Override
    public void doAction(StateMachine stateMachine, RmcpMessage message) {
        if (ProtocolDecoder.decodeAuthenticationType(message) != AuthenticationType.RMCPPlus) {
            return; // this isn't IPMI v2.0 message so we ignore it
        }
        PlainCommandv20Decoder decoder = new PlainCommandv20Decoder(
                CipherSuite.getEmpty());
        if (Protocolv20Decoder.decodePayloadType(message.getData()[1]) != PayloadType.RmcpOpenSessionResponse) {

}

    @Override
    public NetworkFunction getNetworkFunction() {
        return NetworkFunction.StorageRequest;
    }

    @Override
    protected IpmiPayload preparePayload(int sequenceNumber)
            throws NoSuchAlgorithmException, InvalidKeyException {
        byte[] payload = new byte[6];

        byte[] buffer = TypeConverter.intToByteArray(reservationId);

        payload[0] = buffer[3];
        payload[1] = buffer[2]; // reservation ID

        buffer = TypeConverter.intToByteArray(recordId);

        payload[2] = buffer[3];
        payload[3] = buffer[2]; // record ID

        payload[4] = TypeConverter.intToByte(offset);

}

    @Override
    public ResponseData getResponseData(IpmiMessage message) throws IPMIException,
            NoSuchAlgorithmException, InvalidKeyException {
        if (!isCommandResponse(message)) {
            throw new IllegalArgumentException(
                    "This is not a response for Get Chassis Status command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

"This is not a response for Get SDR Repository Info command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

        byte[] raw = message.getPayload().getIpmiCommandData();

        if (raw == null || raw.length != 14) {
            throw new IllegalArgumentException(

"This is not a response for Reserve SDR Repository command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

        byte[] raw = message.getPayload().getIpmiCommandData();

        if (raw == null || raw.length != 2) {
            throw new IllegalArgumentException(

}

    public InstanceModifierType getIdInstanceModifierType() {
        return idInstanceModifierType;
    }

    public void setIdInstanceModifierType(
            InstanceModifierType idInstanceModifierType) {
        this.idInstanceModifierType = idInstanceModifierType;
    }

    public int getShareCount() {
        return shareCount;
    }

    public void setShareCount(int shareCount) {
        this.shareCount = shareCount;
    }

    public boolean isEntityInstanceIncrements() {
        return entityInstanceIncrements;
    }

    public void setEntityInstanceIncrements(boolean entityInstanceIncrements) {
        this.entityInstanceIncrements = entityInstanceIncrements;
    }

    public int getIdInstanceModifierOffset() {
        return idInstanceModifierOffset;
    }

    public void setIdInstanceModifierOffset(int idInstanceModifierOffset) {
        this.idInstanceModifierOffset = idInstanceModifierOffset;
    }

lock = false;

        logger.info("---------------------------------------------");

        while (nextRecId < 65535) {

            resp = new DatagramPacket(new byte[256], 256);

            try {
                socket.receive(resp);
                buffer = new byte[resp.getLength()];
                System.arraycopy(resp.getData(), 0, buffer, 0, buffer.length);
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }

"This is not a response for Get FRU Inventory Info command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

        byte[] raw = message.getPayload().getIpmiCommandData();

        if (raw == null || raw.length != 3) {

int currentOffset = offset;
        int currentPartNumber = partNumber;

        while (currentPartNumber != 0xc1 && currentOffset < fruData.length) {

            int partType = (currentPartNumber & 0xc0) >> 6;

            int partDataLength = (currentPartNumber & 0x3f);

            if (partDataLengthWithinBounds(fruData, currentOffset, partDataLength)) {

                byte[] partNumberData = new byte[partDataLength];

                System.arraycopy(fruData, currentOffset, partNumberData, 0,
                        partDataLength);

                currentOffset += partDataLength;

                switch (index) {
                case 0:

GetSdrResponseData responseData = new GetSdrResponseData();

        byte[] buffer = new byte[4];

        buffer[0] = raw[0];
        buffer[1] = raw[1];
        buffer[2] = 0;
        buffer[3] = 0;

        responseData.setNextRecordId(TypeConverter
                .littleEndianByteArrayToInt(buffer));

        byte[] recordData = new byte[raw.length - 2];

        System.arraycopy(raw, 2, recordData, 0, recordData.length);

        responseData.setSensorRecordData(recordData);

"This is not a response for Get Chassis Status command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

        byte[] raw = message.getPayload().getIpmiCommandData();

        if (raw == null || (raw.length != 3 && raw.length != 4)) {

logger.info("{}", data4.getConsoleSessionId());

        logger.info("---------------------------------------------");

        resp = new DatagramPacket(new byte[256], 256);

        try {
            socket.receive(resp);
            buffer = new byte[resp.getLength()];
            System.arraycopy(resp.getData(), 0, buffer, 0, buffer.length);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }

throw new IllegalArgumentException("This is not a response for Activate Payload command");
        }

        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }

        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(((IpmiLanResponse) message.getPayload()).getCompletionCode());
        }

        MessageReader messageReader = new MessageReader(message.getPayload().getData());

}

    @Override
    public NetworkFunction getNetworkFunction() {
        return NetworkFunction.StorageRequest;
    }

    @Override
    protected IpmiPayload preparePayload(int sequenceNumber)
            throws NoSuchAlgorithmException, InvalidKeyException {
        return new IpmiLanRequest(getNetworkFunction(), getCommandCode(), null,
                TypeConverter.intToByte(sequenceNumber));
    }

    @Override
    public ResponseData getResponseData(IpmiMessage message) throws IPMIException, NoSuchAlgorithmException, InvalidKeyException {
        if (!isCommandResponse(message)) {
            throw new IllegalArgumentException(

while (nextRecId < 65535) {

            resp = new DatagramPacket(new byte[256], 256);

            try {
                socket.receive(resp);
                buffer = new byte[resp.getLength()];
                System.arraycopy(resp.getData(), 0, buffer, 0, buffer.length);
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }

DatagramPacket resp = new DatagramPacket(new byte[256], 256);

            try {
                socket.receive(resp);
                buffer = new byte[resp.getLength()];
                System.arraycopy(resp.getData(), 0, buffer, 0, buffer.length);
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }

}

        resp = new DatagramPacket(new byte[256], 256);

        try {
            socket.receive(resp);
            buffer = new byte[resp.getLength()];
            System.arraycopy(resp.getData(), 0, buffer, 0, buffer.length);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }

DatagramPacket resp = new DatagramPacket(new byte[256], 256);

            try {
                socket.receive(resp);
                buffer = new byte[resp.getLength()];
                System.arraycopy(resp.getData(), 0, buffer, 0, buffer.length);
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }

}

    public int getEntityId() {
        return entityId;
    }

    public void setEntityId(int entityId) {
        this.entityId = entityId;
    }

    public int getEntityInstance() {
        return entityInstance;
    }

    public void setEntityInstance(int entityInstance) {
        this.entityInstance = entityInstance;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

} catch (IPMIException e) {

				// If getting sensor data failed, we check if it already failed
				// with this reservation ID, so that we avoid the infinite loop.
				if (lastReservationId == reservationId || e.getCompletionCode() != CompletionCode.ReservationCanceled) {
					throw e;
				}

				lastReservationId = reservationId;

				// If the cause of the failure was canceling of the
				// reservation, we get new reservationId and retry. This can
				// happen many times during getting all sensors, since BMC can't
				// manage parallel sessions and invalidates old one if new one
				// appears.
				reservationId = ((ReserveSdrRepositoryResponseData) connector.sendMessage(handle,
						new ReserveSdrRepository(IpmiVersion.V20, handle.getCipherSuite(), AuthenticationType.RMCPPlus))).getReservationId();
			}

		}

		return result;
	}

"This is not a response for Get Chassis Status command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }
        return new ChassisControlResponseData();

"This is not a response for Get Chassis Status command");
        }
        if (!(message.getPayload() instanceof IpmiLanResponse)) {
            throw new IllegalArgumentException("Invalid response payload");
        }
        if (((IpmiLanResponse) message.getPayload()).getCompletionCode() != CompletionCode.Ok) {
            throw new IPMIException(
                    ((IpmiLanResponse) message.getPayload())
                            .getCompletionCode());
        }

outmsg = Encoder.encode(new Protocolv20Encoder(), new GetSdr(
                    IpmiVersion.V20, cs, AuthenticationType.RMCPPlus,
                    reservation, nextRecId), sequence, sequence, r1
                    .getManagedSystemSessionId());

            packet = new DatagramPacket(outmsg, outmsg.length, ad, 0x26F);

            dr.socket.send(packet);
            lock = true;

            while (lock) {
                Thread.sleep(1);
            }

public DcLoadInfo(byte[] fruData, int offset) {
        super();
        // TODO: Test when server containing such records will be available

        outputNumber = TypeConverter.byteToInt(fruData[offset]) & 0xf;

        nominalVoltage = TypeConverter.byteToInt(fruData[offset+1]);
        nominalVoltage |= TypeConverter.byteToInt(fruData[offset+2]) << 8;
        nominalVoltage = TypeConverter.decode2sComplement(nominalVoltage, 15);

message.setPayloadType(PayloadType.RmcpOpenSessionRequest);
        message.setSessionID(0);
        message.setSessionSequenceNumber(0);
        message.setAuthenticationType(getAuthenticationType());
        message.setPayloadAuthenticated(false);
        message.setPayloadEncrypted(false);
        message.setPayload(preparePayload(messageSequenceNumber));

        return message;
    }

    @Override
    protected IpmiPayload preparePayload(int sequenceNumber) {
        byte[] payload = new byte[32];

new Protocolv15Encoder(), authCap, event.getSequenceNumber(),0,0));
            } catch (Exception e) {
                stateMachine.setCurrent(this);
                stateMachine.doExternalAction(new ErrorAction(e));
            }
        } else {
            stateMachine.doExternalAction(new ErrorAction(
                    new IllegalArgumentException("Invalid transition")));
        }
    }

    @Override
    public void doAction(StateMachine stateMachine, RmcpMessage message) {
        // No action is needed
    }

}

public void setChannelNumber(int channelNumber) {
        if (channelNumber < 0 || channelNumber > 0xF || channelNumber == 0xC
                || channelNumber == 0xD) {
            throw new IllegalArgumentException("Invalid channel number");
        }
        this.channelNumber = TypeConverter.intToByte(channelNumber);
    }

    public int getChannelNumber() {
        return TypeConverter.byteToInt(channelNumber);
    }

.calculateSik(event.getRakp1ResponseData())));
            } catch (Exception e) {
                stateMachine.setCurrent(this);
                stateMachine.doExternalAction(new ErrorAction(e));
            }
        } else {
            stateMachine.doExternalAction(new ErrorAction(
                    new IllegalArgumentException("Invalid transition")));
        }

    }

    @Override
    public void doAction(StateMachine stateMachine, RmcpMessage message) {

new Protocolv15Encoder(), authCap, event.getSequenceNumber(),0,0));
            } catch (Exception e) {
                stateMachine.setCurrent(this);
                stateMachine.doExternalAction(new ErrorAction(e));
            }
        } else {
            stateMachine.doExternalAction(new ErrorAction(
                    new IllegalArgumentException("Invalid transition")));
        }
    }

    @Override
    public void doAction(StateMachine stateMachine, RmcpMessage message) {

.appendField(TypeConverter.intToByte(payloadInstance))
                .getMessage();

        return new IpmiLanRequest(getNetworkFunction(), getCommandCode(), message, TypeConverter.intToByte(sequenceNumber));
    }

    @Override
    public ResponseData getResponseData(IpmiMessage message) throws IPMIException, NoSuchAlgorithmException, InvalidKeyException {
        if (!isCommandResponse(message)) {
            throw new IllegalArgumentException("This is not a response for Deactivate Payload command");

ReserveSdrRepositoryResponseData responseData = new ReserveSdrRepositoryResponseData();

        byte[] buffer = new byte[4];

        buffer[0] = raw[0];
        buffer[1] = raw[1];
        buffer[2] = 0;
        buffer[3] = 0;

        responseData.setReservationId(TypeConverter
                .littleEndianByteArrayToInt(buffer));

        return responseData;
    }

}

switch (requestedPrivilegeLevel) {
        case MaximumAvailable:
            return 0;
        case Callback:
            return TypeConverter.intToByte(0x1);
        case User:
            return TypeConverter.intToByte(0x2);
        case Operator:
            return TypeConverter.intToByte(0x3);
        case Administrator:
            return TypeConverter.intToByte(0x4);
        default:
            throw new IllegalArgumentException("Invalid privilege level");
        }
    }

setFruEntityInstance(TypeConverter.byteToInt(recordData[13]));

        byte[] nameData = new byte[recordData.length - 16];

        System.arraycopy(recordData, 16, nameData, 0, nameData.length);

        setName(decodeName(recordData[15], nameData));
    }

    public int getDeviceAccessAddress() {

Rakp1ResponseData data = new Rakp1ResponseData();

        data.setMessageTag(payload[0]);

        data.setStatusCode(payload[1]);

        if (payload[1] != 0) {
            throw new IPMIException(CompletionCode.parseInt(TypeConverter
                    .byteToInt(payload[1])));
        }

        if (payload.length < 40) {

} else {
            stateMachine.doExternalAction(new ErrorAction(
                    new IllegalArgumentException("Invalid transition")));
        }
    }

    @Override
    public void doAction(StateMachine stateMachine, RmcpMessage message) {
        if(ProtocolDecoder.decodeAuthenticationType(message) != AuthenticationType.RMCPPlus) {
            return;    //this isn't IPMI v2.0 message so we ignore it
        }
        if(Protocolv20Decoder.decodeSessionID(message) != 0){

super();

        if (countToRead > 255) {
            throw new IllegalArgumentException(
                    "Count to read cannot exceed 255");
        }

        if (fruId > 255) {
            throw new IllegalArgumentException("FRU ID cannot exceed 255");
        }

        this.offset = offset * unit.getSize();

        size = countToRead * unit.getSize();

        this.fruId = fruId;
        // TODO: Check if Count To Read field is encoded in words if the FRU is
        // addressed in words (requires different server settings).
    }

public CloseSession(int sessionId, int messageSequenceNumber, int sessionSequenceNumber) {
        this.messageSequenceNumber = messageSequenceNumber;
        this.sessionSequenceNumber = sessionSequenceNumber;
        this.sessionId = sessionId;
    }

    public int getSessionId() {
        return sessionId;
    }

    public int getMessageSequenceNumber() {
        return messageSequenceNumber;
    }

    public int getSessionSequenceNumber() {
        return sessionSequenceNumber;
    }
}

requestData[0] = TypeConverter.intToByte(powerCommand.getCode());

        return new IpmiLanRequest(getNetworkFunction(), getCommandCode(),
                requestData, TypeConverter.intToByte(sequenceNumber));
    }

    @Override
    public ResponseData getResponseData(IpmiMessage message) throws IPMIException,
            NoSuchAlgorithmException, InvalidKeyException {
        if (!isCommandResponse(message)) {
            throw new IllegalArgumentException(

public BaseCompatibilityInfo(byte[] fruData, int offset, int length) {
        super();
        // TODO: Test when server containing such records will be available

        byte[] buffer = new byte[4];

        System.arraycopy(fruData, offset, buffer, 0, 3);
        buffer[3] = 0;

        manufacturerId = TypeConverter.littleEndianByteArrayToInt(buffer);

}

    @Override
    public NetworkFunction getNetworkFunction() {
        return NetworkFunction.ApplicationRequest;
    }

    @Override
    protected IpmiPayload preparePayload(int sequenceNumber) throws NoSuchAlgorithmException, InvalidKeyException {
        //We put just 2 bytes into the 6-bytes array, as specification for this command says to leave the rest 4 bytes as zeros
        byte[] message = MessageComposer.get(REQUEST_DATA_LENGTH)
                .appendField(TypeConverter.intToByte(payloadType.getCode()))
                .appendField(TypeConverter.intToByte(payloadInstance))

logger.info("
        resp = new DatagramPacket(new byte[256], 256);

        try {
            socket.receive(resp);
            buffer = new byte[resp.getLength()];
            System.arraycopy(resp.getData(), 0, buffer, 0, buffer.length);

System.arraycopy(fruData, offset+3, oemData, 0, length-3);

    }

    public int getManufacturerId() {
        return manufacturerId;
    }

    public void setManufacturerId(int manufacturerId) {
        this.manufacturerId = manufacturerId;
    }

    public byte[] getOemData() {
        return oemData;
    }

    public void setOemData(byte[] oemData) {
        this.oemData = oemData;
    }

}

responseData.setSdrVersion(TypeConverter
                .littleEndianBcdByteToInt(raw[0]));

        byte[] buffer = new byte[4];

        buffer[0] = raw[1];
        buffer[1] = raw[2];
        buffer[2] = 0;
        buffer[3] = 0;

        responseData.setRecordCount(TypeConverter

DatagramPacket resp = new DatagramPacket(new byte[256], 256);

            try {
                socket.receive(resp);
                buffer = new byte[resp.getLength()];
                System.arraycopy(resp.getData(), 0, buffer, 0, buffer.length);

public class CompactSensorRecord extends SensorRecord {

    private byte sensorOwnerId;

    private AddressType addressType;

    private byte channelNumber;

    private byte sensorOwnerLun;

    private byte sensorNumber;

    private EntityId entityId;

    /**
     * Entity is physical if true, logical otherwise.
     */
    private boolean entityPhysical;

    private byte entityInstanceNumber;

    private boolean hysteresisReadable;

    private boolean thresholdsReadable;

    private SensorType sensorType;

    private int eventReadingType;

    private RateUnit rateUnit;

    private ModifierUnitUsage modifierUnitUsage;

    private SensorUnit sensorBaseUnit;

    private SensorUnit sensorModifierUnit;

    private SensorDirection sensorDirection;

+ rec.getSensorResolution()
                        + " "
                        + rec.getSensorBaseUnit().toString()
                        + (rec.getRateUnit() != RateUnit.None ? " per "
                                + rec.getRateUnit() : ""));
            }
            if (record instanceof CompactSensorRecord) {
                CompactSensorRecord rec = (CompactSensorRecord) record;

return new IpmiLanRequest(getNetworkFunction(), getCommandCode(),
                payload, TypeConverter.intToByte(sequenceNumber));
    }

    @Override
    public ResponseData getResponseData(IpmiMessage message) throws IPMIException, NoSuchAlgorithmException, InvalidKeyException {

        if (!isCommandResponse(message)) {
            throw new IllegalArgumentException(

setEntityRangeInstance4(TypeConverter.byteToInt(recordData[25]));
    }

    public int getContainerEntityId() {
        return containerEntityId;
    }

    public void setContainerEntityId(int containerEntityId) {
        this.containerEntityId = containerEntityId;
    }

    public int getContainerEntityInstance() {
        return containerEntityInstance;
    }

    public void setContainerEntityInstance(int containerEntityInstance) {
        this.containerEntityInstance = containerEntityInstance;
    }

    public int getContainerEntityDeviceAddress() {

try {
                    ResponseData responseData = coder.getResponseData(message);
                    connection.notifyResponseListeners(connection.getHandle(), tag, responseData, null);
                } catch (Exception e) {
                    connection.notifyResponseListeners(connection.getHandle(), tag, null, e);
                }

} else if (machineEvent instanceof AuthenticationCapabilitiesReceived) {
            stateMachine.setCurrent(new Authcap());
        } else {
            stateMachine.doExternalAction(new ErrorAction(
                    new IllegalArgumentException("Invalid transition")));
        }
    }

    @Override
    public void doAction(StateMachine stateMachine, RmcpMessage message) {
        if (ProtocolDecoder.decodeAuthenticationType(message) == AuthenticationType.RMCPPlus) {

stateMachine.setCurrent(new Ciphers());
        } else {
            stateMachine.doExternalAction(new ErrorAction(
                    new IllegalArgumentException("Invalid transition")));
        }
    }

    @Override
    public void doAction(StateMachine stateMachine, RmcpMessage message) {
        if(ProtocolDecoder.decodeAuthenticationType(message) != AuthenticationType.RMCPPlus) {
            return;    //this isn't IPMI v2.0 message so we ignore it
        }