iscsi-client-rs 0.0.4

use anyhow::{Result, anyhow, bail};
use bitflags::bitflags;

use crate::{
    client::pdu_connection::FromBytes,
    models::{
        common::{BasicHeaderSegment, HEADER_LEN, SendingData},
        opcode::{BhsOpcode, IfFlags, Opcode},
    },
};

bitflags! {
    #[derive(Default, Debug, PartialEq)]
    pub struct DataOutFlags: u8 {
        const FINAL = 0b1000_0000;
    }
}

impl TryFrom<u8> for DataOutFlags {
    type Error = anyhow::Error;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        DataOutFlags::from_bits(value)
            .ok_or_else(|| anyhow::anyhow!("invalid DataOutFlags: {:#08b}", value))
    }
}

/// BHS for SCSI Data-Out (opcode 0x26)
#[repr(C)]
#[derive(Debug, Default, PartialEq)]
pub struct ScsiDataOut {
    pub opcode: BhsOpcode,            // 0 (0x26)
    pub flags: DataOutFlags,          // 1 (F, rest 0)
    pub reserved2: [u8; 2],           // 2..4
    pub total_ahs_length: u8,         // 4
    pub data_segment_length: [u8; 3], // 5..8
    pub lun: [u8; 8],                 // 8..16
    pub initiator_task_tag: u32,      // 16..20
    pub target_transfer_tag: u32,     // 20..23
    pub exp_stat_sn: u32,             // 24..28
    pub reserved3: [u8; 8],           // 28..36
    pub data_sn: u32,                 // 36..40
    pub buffer_offset: u32,           // 40..44
    pub reserved4: u32,               // 44..48
}

impl ScsiDataOut {
    pub fn to_bhs_bytes(&self) -> [u8; HEADER_LEN] {
        let mut buf = [0u8; HEADER_LEN];
        buf[0] = (&self.opcode).into();
        buf[1] = self.flags.bits();
        buf[2..4].copy_from_slice(&self.reserved2);
        buf[4] = self.total_ahs_length;
        buf[5..8].copy_from_slice(&self.data_segment_length);
        buf[8..16].copy_from_slice(&self.lun);
        buf[16..20].copy_from_slice(&self.initiator_task_tag.to_be_bytes());
        buf[20..24].copy_from_slice(&self.target_transfer_tag.to_be_bytes());
        buf[24..28].copy_from_slice(&self.exp_stat_sn.to_be_bytes());
        buf[28..36].copy_from_slice(&self.reserved3);
        buf[36..40].copy_from_slice(&self.data_sn.to_be_bytes());
        buf[40..44].copy_from_slice(&self.buffer_offset.to_be_bytes());
        buf[44..48].copy_from_slice(&self.reserved4.to_be_bytes());

        buf
    }

    pub fn from_bhs_bytes(b: &[u8]) -> Result<Self> {
        if b.len() < HEADER_LEN {
            return Err(anyhow!("buffer too small for SCSI Data-Out BHS"));
        }
        let opcode: BhsOpcode = BhsOpcode::try_from(b[0])?;
        if opcode.opcode != Opcode::ScsiDataOut {
            bail!("ScsiDataOut invalid opcode: {:?}", opcode.opcode);
        }
        let flags = DataOutFlags::try_from(b[1])?;
        let mut reserved2 = [0u8; 2];
        reserved2.copy_from_slice(&b[2..4]);
        let total_ahs_length = b[4];
        let data_segment_length = [b[5], b[6], b[7]];
        let mut lun = [0u8; 8];
        lun.copy_from_slice(&b[8..16]);
        let initiator_task_tag = u32::from_be_bytes(b[16..20].try_into()?);
        let target_transfer_tag = u32::from_be_bytes(b[20..24].try_into()?);
        let exp_stat_sn = u32::from_be_bytes(b[24..28].try_into()?);
        let mut reserved3 = [0u8; 8];
        reserved3.copy_from_slice(&b[28..36]);
        let data_sn = u32::from_be_bytes(b[36..40].try_into()?);
        let buffer_offset = u32::from_be_bytes(b[40..44].try_into()?);
        let reserved4 = u32::from_be_bytes(b[44..48].try_into()?);

        Ok(Self {
            opcode,
            flags,
            reserved2,
            total_ahs_length,
            data_segment_length,
            lun,
            initiator_task_tag,
            target_transfer_tag,
            exp_stat_sn,
            reserved3,
            data_sn,
            buffer_offset,
            reserved4,
        })
    }
}

impl SendingData for ScsiDataOut {
    fn get_final_bit(&self) -> bool {
        self.flags.contains(DataOutFlags::FINAL)
    }

    fn set_final_bit(&mut self) {
        self.flags.insert(DataOutFlags::FINAL);
    }

    fn get_continue_bit(&self) -> bool {
        !self.flags.contains(DataOutFlags::FINAL)
    }

    fn set_continue_bit(&mut self) {
        self.flags.remove(DataOutFlags::FINAL);
    }
}

impl FromBytes for ScsiDataOut {
    fn from_bhs_bytes(bytes: &[u8]) -> Result<Self> {
        Self::from_bhs_bytes(bytes)
    }
}

impl BasicHeaderSegment for ScsiDataOut {
    fn to_bhs_bytes(&self) -> Result<[u8; HEADER_LEN]> {
        Ok(self.to_bhs_bytes())
    }

    fn get_opcode(&self) -> &BhsOpcode {
        &self.opcode
    }

    fn get_initiator_task_tag(&self) -> u32 {
        self.initiator_task_tag
    }

    fn get_ahs_length_bytes(&self) -> usize {
        (self.total_ahs_length as usize) * 4
    }

    fn set_ahs_length_bytes(&mut self, len_bytes: u8) {
        self.total_ahs_length = len_bytes >> 2;
    }

    fn get_data_length_bytes(&self) -> usize {
        u32::from_be_bytes([
            0,
            self.data_segment_length[0],
            self.data_segment_length[1],
            self.data_segment_length[2],
        ]) as usize
    }

    fn set_data_length_bytes(&mut self, len: u32) {
        let be = len.to_be_bytes();
        self.data_segment_length = [be[1], be[2], be[3]];
    }
}

/// Builder for **SCSI Data-Out** PDUs (opcode `0x26`).
///
/// This helper prepares the Basic Header Segment (BHS) for Data-Out and
/// lets the higher layer stream an arbitrary payload split into chunks
/// that respect the negotiated **MaxRecvDataSegmentLength (MRDSL)**.
///
/// When the payload is later converted into wire frames (by your
/// `ToBytes`/`Builder` implementation), each chunk will be emitted as a
/// separate Data-Out PDU with:
/// - **F (Final) = 1** only on the **last** chunk,
/// - **DataSN** increasing sequentially per PDU,
/// - **BufferOffset** set to the cumulative number of bytes already sent,
/// - **DataSegmentLength** equal to the current chunk size (without padding).
///
/// Target Transfer Tag (**TTT**) semantics:
/// - For **unsolicited / initial burst** Data-Out PDUs, use `DEFAULT_TTT =
///   0xFFFF_FFFF`.
/// - For **R2T-driven** transfers, set the TTT received in the R2T PDU.
///
/// You can also request HeaderDigest and/or DataDigest emission; these
/// flags only affect how the final frames are serialized (they do not
/// modify the BHS fields directly).
#[derive(Debug, Default)]
pub struct ScsiDataOutBuilder {
    pub header: ScsiDataOut,

    enable_header_digest: bool,
    enable_data_digest: bool,
}

impl ScsiDataOutBuilder {
    /// Default Target Transfer Tag for unsolicited/initial-burst Data-Out.
    pub const DEFAULT_TTT: u32 = 0xFFFF_FFFF;

    pub fn new() -> Self {
        Self {
            header: ScsiDataOut {
                opcode: BhsOpcode {
                    flags: IfFlags::empty(),
                    opcode: Opcode::ScsiDataOut,
                },
                ..Default::default()
            },
            enable_header_digest: false,
            enable_data_digest: false,
        }
    }

    /// Set the 8-byte LUN to which data is written.
    pub fn lun(mut self, lun: &[u8; 8]) -> Self {
        self.header.lun.copy_from_slice(lun);
        self
    }

    /// Set Initiator Task Tag (ITT) identifying this stream.
    pub fn initiator_task_tag(mut self, itt: u32) -> Self {
        self.header.initiator_task_tag = itt;
        self
    }

    /// Set Target Transfer Tag (TTT). Use `DEFAULT_TTT` for unsolicited
    /// bursts, or the TTT provided in an R2T for solicited transfers.
    pub fn target_transfer_tag(mut self, ttt: u32) -> Self {
        self.header.target_transfer_tag = ttt;
        self
    }

    /// Set the expected StatusSN (ExpStatSN).
    pub fn exp_stat_sn(mut self, sn: u32) -> Self {
        self.header.exp_stat_sn = sn;
        self
    }

    /// Set the **DataSN** for this Data-Out PDU.
    pub fn data_sn(mut self, data_sn: u32) -> Self {
        self.header.data_sn = data_sn;
        self
    }

    /// Set the **BufferOffset** (in **bytes**) of the first byte carried by
    /// this Data-Out PDU within the overall WRITE command payload.
    pub fn buffer_offset(mut self, buffer_offset: u32) -> Self {
        self.header.buffer_offset = buffer_offset;
        self
    }

    /// Request emission of a HeaderDigest (e.g., CRC32C) after the header.
    pub fn with_header_digest(mut self) -> Self {
        self.enable_header_digest = true;
        self
    }

    /// Request emission of a DataDigest after each Data Segment.
    pub fn with_data_digest(mut self) -> Self {
        self.enable_data_digest = true;
        self
    }
}