CPD Results

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);

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);

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));
	}

	/**
	 * Returns the slave address of the controller used to access the FRU device, in its 7-bit form (byte 6 bits 7:1 of
	 * the record), 0 when the device is directly on the IPMB.
	 * {@link org.metricshub.ipmi.core.coding.commands.app.SendMessage} takes the slave address in its 8-bit form: this
	 * value shifted left by one.
	 *
	 * @return the 7-bit slave address of the controller
	 */
	public int getDeviceAccessAddress() {
		return deviceAccessAddress;
	}

	/**
	 * Sets the slave address of the controller used to access the FRU device.
	 *
	 * @param deviceAccessAddress the 7-bit slave address of the controller
	 */
	public void setDeviceAccessAddress(int deviceAccessAddress) {
		this.deviceAccessAddress = deviceAccessAddress;
	}

	/**
	 * Returns the FRU device ID of a logical FRU device (byte 7 of the record), the ID that the FRU commands of its
	 * controller take, or the 7-bit I2C slave address of a non-logical FRU device (byte 7 bits 7:1).
	 *
	 * @return the FRU device ID, or the 7-bit slave address of a non-logical FRU device
	 */
	public int getDeviceId() {

}

	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;
	}

}

setDeviceTypeModifier(TypeConverter.byteToInt(recordData[11]));

		setEntityId(TypeConverter.byteToInt(recordData[12]));
		setEntityInstance(TypeConverter.byteToInt(recordData[13]));

		// Byte 16 is the ID string type/length, the string starts at byte 17 (Table 43-10)
		byte[] nameData = new byte[recordData.length - 16];

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

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

	public int getDeviceAccessAddress() {

public DcLoadInfo(byte[] fruData, int offset) {
		super();

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

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

stateMachine.doExternalAction(new GetSikAction(rakp1.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) {
		// 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);
	}

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];

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));
	}

	/**
	 * Returns the slave address of the controller used to access the FRU device, in its 7-bit form (byte 6 bits 7:1 of
	 * the record), 0 when the device is directly on the IPMB.
	 * {@link org.metricshub.ipmi.core.coding.commands.app.SendMessage} takes the slave address in its 8-bit form: this
	 * value shifted left by one.
	 *
	 * @return the 7-bit slave address of the controller
	 */
	public int getDeviceAccessAddress() {

public BaseCompatibilityInfo(byte[] fruData, int offset, int length) {
		super();

		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))

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

	}

	/**
	 * Returns the manufacturer ID of the record, which identifies the vendor that defines it.
	 *
	 * @return the IANA manufacturer ID (3 bytes in the record, least significant byte first)
	 */
	public int getManufacturerId() {
		return manufacturerId;
	}

	/**
	 * Sets the manufacturer ID of the record.
	 *
	 * @param manufacturerId the IANA manufacturer ID
	 */
	public void setManufacturerId(int manufacturerId) {
		this.manufacturerId = manufacturerId;
	}

	/**
	 * Returns the OEM data of the record.
	 *
	 * @return the bytes that follow the manufacturer ID
	 */
	public byte[] getOemData() {
		return oemData;
	}

	/**
	 * Sets the OEM data of the record.
	 *
	 * @param oemData the bytes that follow the manufacturer ID
	 */
	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.littleEndianByteArrayToInt(buffer));

System.arraycopy(data, 3, buffer, 0, 4);
			record.setTimestamp(TypeConverter.decodeDate(TypeConverter.littleEndianByteArrayToInt(buffer)));
			buffer[0] = data[7];
			buffer[1] = data[8];
			buffer[2] = data[9];

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() {

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
		}