internet 0.0.5

//! UDP Options.
//!
//! [RFC 9868]: https://datatracker.ietf.org/doc/html/rfc9868

use crate::{Buf, BufError, BufMut, BufResult, Codec, Cursor};

/// UDP options.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Option {
    /// End of Options List.
    EndOfOptionsList(EndOfOptionsList),
    /// No Operation.
    NoOperation(NoOperation),
    /// Additional Payload Checksum.
    AdditionalPayloadChecksum(AdditionalPayloadChecksum),
    /// Fragmentation.
    Fragmentation(Fragmentation),
    /// Maximum Datagram Size.
    MaximumDatagramSize(MaximumDatagramSize),
    /// Maximum Reassembled Datagram Size.
    MaximumReassembledDatagramSize(MaximumReassembledDatagramSize),
    /// Request.
    Request(EchoRequest),
    /// Response.
    Response(EchoResponse),
    /// Timestamp.
    Timestamp(Timestamp),
}

impl Codec for Option {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        match self {
            Option::EndOfOptionsList(opt) => opt.encode(writer, ()),
            Option::NoOperation(opt) => opt.encode(writer, ()),
            Option::AdditionalPayloadChecksum(opt) => opt.encode(writer, ()),
            Option::Fragmentation(opt) => opt.encode(writer, ()),
            Option::MaximumDatagramSize(opt) => opt.encode(writer, ()),
            Option::MaximumReassembledDatagramSize(opt) => opt.encode(writer, ()),
            Option::Request(opt) => opt.encode(writer, ()),
            Option::Response(opt) => opt.encode(writer, ()),
            Option::Timestamp(opt) => opt.encode(writer, ()),
        }
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let kind = Kind::decode(reader, ())?;
        match kind {
            Kind::EndOfOptionList => Ok(Option::EndOfOptionsList(EndOfOptionsList::decode(
                reader,
                (),
            )?)),
            Kind::NoOperation => Ok(Option::NoOperation(NoOperation::decode(reader, ())?)),
            Kind::AdditionalPayloadChecksum => Ok(Option::AdditionalPayloadChecksum(
                AdditionalPayloadChecksum::decode(reader, ())?,
            )),
            Kind::Fragmentation => Ok(Option::Fragmentation(Fragmentation::decode(reader, ())?)),
            Kind::MaximumDatagramSize => Ok(Option::MaximumDatagramSize(
                MaximumDatagramSize::decode(reader, ())?,
            )),
            Kind::MaximumReassembledDatagramSize => Ok(Option::MaximumReassembledDatagramSize(
                MaximumReassembledDatagramSize::decode(reader, ())?,
            )),
            Kind::Request => Ok(Option::Request(EchoRequest::decode(reader, ())?)),
            Kind::Response => Ok(Option::Response(EchoResponse::decode(reader, ())?)),
            Kind::Timestamp => Ok(Option::Timestamp(Timestamp::decode(reader, ())?)),
        }
    }
}

/// UDP Option Kind.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum Kind {
    /// End of Option List (EOOL).
    EndOfOptionList = 0,
    /// No Operation (NOP).
    NoOperation = 1,
    /// Additional Payload Checksum (APC).
    AdditionalPayloadChecksum = 2,
    /// Fragmentation (FRAG).
    Fragmentation = 3,
    /// Maximum Datagram Size (MDS).
    MaximumDatagramSize = 4,
    /// Maximum Reassembled Datagram Size (MRDS).
    MaximumReassembledDatagramSize = 5,
    /// Request (REQ).
    Request = 6,
    /// Response (RES).
    Response = 7,
    /// Timestamp (TIME).
    Timestamp = 8,
}

impl TryFrom<u8> for Kind {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Kind::EndOfOptionList),
            1 => Ok(Kind::NoOperation),
            2 => Ok(Kind::AdditionalPayloadChecksum),
            3 => Ok(Kind::Fragmentation),
            4 => Ok(Kind::MaximumDatagramSize),
            5 => Ok(Kind::MaximumReassembledDatagramSize),
            6 => Ok(Kind::Request),
            7 => Ok(Kind::Response),
            8 => Ok(Kind::Timestamp),
            _ => Err(()),
        }
    }
}

impl Codec for Kind {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u8).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let byte = u8::decode(reader, ())?;
        Self::try_from(byte).map_err(|_| BufError::UnexpectedValue)
    }
}

/// End Of Options List (EOL) option following [Section 11.1].
///
/// [Section 11.1]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.1
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EndOfOptionsList;

impl EndOfOptionsList {
    /// Kind field.
    pub const KIND: Kind = Kind::EndOfOptionList;
}

impl Codec for EndOfOptionsList {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        Ok(Self)
    }
}

/// No Operation (NOP) option following [Section 11.2].
///
/// [Section 11.2]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.2
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct NoOperation;

impl NoOperation {
    /// Kind field.
    pub const KIND: Kind = Kind::NoOperation;
}

impl Codec for NoOperation {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        Ok(Self)
    }
}

/// Additional Payload Checksum (APC) option following [Section 11.3].
///
/// [Section 11.3]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct AdditionalPayloadChecksum {
    /// CRC32C checksum.
    pub crc32c: u32,
}

impl AdditionalPayloadChecksum {
    /// Kind field.
    pub const KIND: Kind = Kind::AdditionalPayloadChecksum;
    /// Length field.
    pub const LEN: u8 = 8;
}

impl Codec for AdditionalPayloadChecksum {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())?;
        Self::LEN.encode(writer, ())?;
        // 2 bytes reserved
        0u16.encode(writer, ())?;
        self.crc32c.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        if u8::decode(reader, ())? != Self::LEN {
            return Err(BufError::UnexpectedValue);
        }
        let _reserved = u16::decode(reader, ())?;
        let crc32c = u32::decode(reader, ())?;
        Ok(Self { crc32c })
    }
}

/// Fragmentation (FRAG) option following [Section 11.4].
///
/// [Section 11.4]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.4
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Fragmentation {
    /// Length field.
    pub len: u8,
}

impl Fragmentation {
    /// Kind field.
    pub const KIND: Kind = Kind::Fragmentation;
}

impl Codec for Fragmentation {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())?;
        self.len.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        let len = u8::decode(reader, ())?;
        Ok(Self { len })
    }
}

/// Maximum Datagram Size (MDS) option following [Section 11.5].
///
/// [Section 11.5]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.5
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct MaximumDatagramSize {
    /// Maximum datagram size.
    pub mds: u16,
}

impl MaximumDatagramSize {
    /// Kind field.
    pub const KIND: Kind = Kind::MaximumDatagramSize;
    /// Length field.
    pub const LEN: u8 = 4;
}

impl Codec for MaximumDatagramSize {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())?;
        Self::LEN.encode(writer, ())?;
        self.mds.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        if u8::decode(reader, ())? != Self::LEN {
            return Err(BufError::UnexpectedValue);
        }
        let mds = u16::decode(reader, ())?;
        Ok(Self { mds })
    }
}

/// Maximum Reassembled Datagram Size (MRDS) option following [Section 11.6].
///
/// [Section 11.6]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.6
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct MaximumReassembledDatagramSize {
    /// Maximum reassembled datagram size.
    pub mrds: u16,
}

impl MaximumReassembledDatagramSize {
    /// Kind field.
    pub const KIND: Kind = Kind::MaximumReassembledDatagramSize;
    /// Length field.
    pub const LEN: u8 = 4;
}

impl Codec for MaximumReassembledDatagramSize {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())?;
        Self::LEN.encode(writer, ())?;
        self.mrds.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        if u8::decode(reader, ())? != Self::LEN {
            return Err(BufError::UnexpectedValue);
        }
        let mrds = u16::decode(reader, ())?;
        Ok(Self { mrds })
    }
}

/// Echo Request (REQ) option following [Section 11.7].
///
/// [Section 11.7]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.7
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EchoRequest {
    /// Maximum segment size.
    pub mss: u16,
}

impl EchoRequest {
    /// Kind field.
    pub const KIND: Kind = Kind::Request;
    /// Length field.
    pub const LEN: u8 = 4;
}

impl Codec for EchoRequest {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())?;
        Self::LEN.encode(writer, ())?;
        self.mss.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        if u8::decode(reader, ())? != Self::LEN {
            return Err(BufError::UnexpectedValue);
        }
        let mss = u16::decode(reader, ())?;
        Ok(Self { mss })
    }
}

/// Echo Response (RES) option following [Section 11.7].
///
/// [Section 11.7]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.7
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EchoResponse {
    /// Length field.
    pub len: u8,
}

impl EchoResponse {
    /// Kind field.
    pub const KIND: Kind = Kind::Response;
}

impl Codec for EchoResponse {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())?;
        self.len.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        let len = u8::decode(reader, ())?;
        Ok(Self { len })
    }
}

/// Timestamp (TIME) option following [Section 11.8].
///
/// [Section 11.8]: https://datatracker.ietf.org/doc/html/rfc9868#section-11.8
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Timestamp {
    /// Timestamp value.
    pub ts_val: u32,
    /// Timestamp echo reply.
    pub ts_ecr: u32,
}

impl Timestamp {
    /// Kind field.
    pub const KIND: Kind = Kind::Timestamp;
    /// Length field.
    pub const LEN: u8 = 12;
}

impl Codec for Timestamp {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Self::KIND.encode(writer, ())?;
        Self::LEN.encode(writer, ())?;
        0u16.encode(writer, ())?;
        self.ts_val.encode(writer, ())?;
        self.ts_ecr.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        if Kind::decode(reader, ())? != Self::KIND {
            return Err(BufError::UnexpectedValue);
        }
        if u8::decode(reader, ())? != Self::LEN {
            return Err(BufError::UnexpectedValue);
        }
        let _reserved = u16::decode(reader, ())?;
        let ts_val = u32::decode(reader, ())?;
        let ts_ecr = u32::decode(reader, ())?;
        Ok(Self { ts_val, ts_ecr })
    }
}

#[cfg(test)]
mod tests {
    use core::fmt::Debug;

    use crate::{
        Codec, Cursor,
        udp::{Checksum, Header, Port},
    };

    fn codec_roundtrip<T: Codec<C> + Debug + Eq, C: Copy>(
        etalon_struct: T,
        etalon_bytes: &[u8],
        context: C,
    ) {
        let mut encoded_bytes = vec![];
        {
            let writer = &mut Cursor::new(&mut encoded_bytes);
            etalon_struct.encode(writer, context).unwrap();
        }
        assert_eq!(etalon_bytes, &encoded_bytes);

        let decoded_struct = {
            let reader = &mut Cursor::new(&mut encoded_bytes);
            T::decode(reader, context).unwrap()
        };
        assert_eq!(etalon_struct, decoded_struct);

        encoded_bytes.fill(0x00);
        {
            let writer = &mut Cursor::new(&mut encoded_bytes);
            decoded_struct.encode(writer, context).unwrap();
        }
        assert_eq!(etalon_bytes, &encoded_bytes);
    }

    #[test]
    fn end_of_options_list() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn no_operation() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn additional_payload_checksum() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn fragmentation() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn maximum_datagram_size() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn maximum_reassembled_datagram_size() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn echo_request() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn echo_response() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn timestamp() {
        let etalon_bytes = &[
            0x00, 0x35, // source port: 53 (DNS)
            0xC3, 0x50, // destination port: 50000
            0x00, 0x10, // length: 16
            0x00, 0x00, // checksum: 0
        ];
        let etalon_struct = Header {
            source_port: Port::DNS,
            destination_port: Port::from(50000u16),
            length: 16,
            checksum: Checksum(0),
        };

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }
}