Struct ByteArray 

#[repr(transparent)]
pub struct ByteArray<const N: usize>(pub [u8; N]);

Newtype for [u8; N] in order to be able to implement traits.

Tuple Fields

0: [u8; N]

Implementations

impl ByteArray<6>

pub const BROADCAST: MacAddr

Broadcast address (all ones)

pub const ANY: MacAddr

Any address (all zeroes)

pub fn new(v: [u8; 6]) -> Self

New from bytes

Examples found in repository

examples/dhcp.rs (line 7)

fn main() -> () {
    use catnip::*;

    let dhcp_inform = DhcpFixedPayload::new_inform(
        IpV4Addr::new([1, 2, 3, 4]),
        MacAddr::new([5, 6, 7, 8, 9, 10]),
        12345
    );

    // Serialize
    let bytes = dhcp_inform.to_be_bytes();
    // Deserialize
    let msg_parsed = DhcpFixedPayload::read_bytes(&bytes);

    assert_eq!(msg_parsed, dhcp_inform);
}

examples/arp.rs (line 7)

fn main() -> () {
    use catnip::*;

    let msg = ArpPayload::new(
        MacAddr::new([1, 2, 3, 4, 5, 6]),
        IpV4Addr::new([7, 8, 9, 10]),
        MacAddr::new([11, 12, 13, 14, 15, 16]),
        IpV4Addr::new([17, 18, 19, 20]),
        ArpOperation::Request,
    );

    // Serialize
    let bytes: [u8; ArpPayload::BYTE_LEN] = msg.to_be_bytes();

    // Deserialize
    let msg_parsed = ArpPayload::read_bytes(&bytes);

    assert_eq!(msg, msg_parsed);
}

examples/udp.rs (line 18)

fn main() -> () {
    use catnip::*;
    
    // Some made-up data with two 32-bit words' worth of bytes
    let data: ByteArray<8> = ByteArray([0, 1, 2, 3, 4, 5, 6, 7]);

    // Arbitrary addresses
    let src_ipaddr: IpV4Addr = IpV4Addr::new([10, 0, 0, 120]);
    let dst_ipaddr: IpV4Addr = IpV4Addr::new([10, 0, 0, 121]);

    let frame = EthernetFrame::<IpV4Frame<UdpFrame<ByteArray<8>>>> {
        header: EthernetHeader {
            dst_macaddr: MacAddr::BROADCAST,
            src_macaddr: MacAddr::new([0x02, 0xAF, 0xFF, 0x1A, 0xE5, 0x3C]),
            ethertype: EtherType::IpV4,
        },
        data: IpV4Frame::<UdpFrame<ByteArray<8>>> {
            header: IpV4Header {
                version_and_header_length: VersionAndHeaderLength::new().with_version(4).with_header_length((IpV4Header::BYTE_LEN / 4) as u8),
                dscp: DSCP::Standard,
                total_length: IpV4Frame::<UdpFrame<ByteArray<8>>>::BYTE_LEN as u16,
                identification: 0,
                fragmentation: Fragmentation::default(),
                time_to_live: 10,
                protocol: Protocol::Udp,
                checksum: 0,
                src_ipaddr: src_ipaddr,
                dst_ipaddr: dst_ipaddr,
            },
            data: UdpFrame::<ByteArray<8>> {
                header: UdpHeader {
                    src_port: 8123,
                    dst_port: 8125,
                    length: UdpFrame::<ByteArray<8>>::BYTE_LEN as u16,
                    checksum: 0,
                },
                data: data,
            },
        },
        checksum: 0_u32,
    };

    let bytes = frame.to_be_bytes();
    let frame_parsed = EthernetFrame::<IpV4Frame<UdpFrame<ByteArray<8>>>>::read_bytes(&bytes);

    assert_eq!(frame_parsed, frame);
}

impl ByteArray<4>

pub const BROADCAST: IpV4Addr

Broadcast address (all ones)

pub const BROADCAST_LOCAL: IpV4Addr

LAN broadcast address (all ones)

pub const ANY: IpV4Addr

Any address (all zeroes)

pub fn new(v: [u8; 4]) -> Self

New from bytes

Examples found in repository

examples/dhcp.rs (line 6)

fn main() -> () {
    use catnip::*;

    let dhcp_inform = DhcpFixedPayload::new_inform(
        IpV4Addr::new([1, 2, 3, 4]),
        MacAddr::new([5, 6, 7, 8, 9, 10]),
        12345
    );

    // Serialize
    let bytes = dhcp_inform.to_be_bytes();
    // Deserialize
    let msg_parsed = DhcpFixedPayload::read_bytes(&bytes);

    assert_eq!(msg_parsed, dhcp_inform);
}

examples/arp.rs (line 8)

fn main() -> () {
    use catnip::*;

    let msg = ArpPayload::new(
        MacAddr::new([1, 2, 3, 4, 5, 6]),
        IpV4Addr::new([7, 8, 9, 10]),
        MacAddr::new([11, 12, 13, 14, 15, 16]),
        IpV4Addr::new([17, 18, 19, 20]),
        ArpOperation::Request,
    );

    // Serialize
    let bytes: [u8; ArpPayload::BYTE_LEN] = msg.to_be_bytes();

    // Deserialize
    let msg_parsed = ArpPayload::read_bytes(&bytes);

    assert_eq!(msg, msg_parsed);
}

examples/udp.rs (line 12)

fn main() -> () {
    use catnip::*;
    
    // Some made-up data with two 32-bit words' worth of bytes
    let data: ByteArray<8> = ByteArray([0, 1, 2, 3, 4, 5, 6, 7]);

    // Arbitrary addresses
    let src_ipaddr: IpV4Addr = IpV4Addr::new([10, 0, 0, 120]);
    let dst_ipaddr: IpV4Addr = IpV4Addr::new([10, 0, 0, 121]);

    let frame = EthernetFrame::<IpV4Frame<UdpFrame<ByteArray<8>>>> {
        header: EthernetHeader {
            dst_macaddr: MacAddr::BROADCAST,
            src_macaddr: MacAddr::new([0x02, 0xAF, 0xFF, 0x1A, 0xE5, 0x3C]),
            ethertype: EtherType::IpV4,
        },
        data: IpV4Frame::<UdpFrame<ByteArray<8>>> {
            header: IpV4Header {
                version_and_header_length: VersionAndHeaderLength::new().with_version(4).with_header_length((IpV4Header::BYTE_LEN / 4) as u8),
                dscp: DSCP::Standard,
                total_length: IpV4Frame::<UdpFrame<ByteArray<8>>>::BYTE_LEN as u16,
                identification: 0,
                fragmentation: Fragmentation::default(),
                time_to_live: 10,
                protocol: Protocol::Udp,
                checksum: 0,
                src_ipaddr: src_ipaddr,
                dst_ipaddr: dst_ipaddr,
            },
            data: UdpFrame::<ByteArray<8>> {
                header: UdpHeader {
                    src_port: 8123,
                    dst_port: 8125,
                    length: UdpFrame::<ByteArray<8>>::BYTE_LEN as u16,
                    checksum: 0,
                },
                data: data,
            },
        },
        checksum: 0_u32,
    };

    let bytes = frame.to_be_bytes();
    let frame_parsed = EthernetFrame::<IpV4Frame<UdpFrame<ByteArray<8>>>>::read_bytes(&bytes);

    assert_eq!(frame_parsed, frame);
}

impl<const N: usize> ByteArray<N>

pub fn to_be_bytes(&self) -> [u8; N]

Convert to big-endian byte array

Trait Implementations

impl<const N: usize> ByteStruct for ByteArray<N>

fn read_bytes(bytes: &[u8]) -> Self

Unpacks raw bytes from a slice into a new struct

fn write_bytes(&self, bytes: &mut [u8])

Packs the struct into raw bytes and write to a slice

impl<const N: usize> ByteStructLen for ByteArray<N>

const BYTE_LEN: usize = N

The length of the packed bytes of this type

impl<const N: usize> Clone for ByteArray<N>

fn clone(&self) -> ByteArray<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for ByteArray<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize> Ord for ByteArray<N>

fn cmp(&self, other: &ByteArray<N>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const N: usize> PartialEq for ByteArray<N>

fn eq(&self, other: &ByteArray<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> PartialOrd for ByteArray<N>

fn partial_cmp(&self, other: &ByteArray<N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl uDebug for ByteArray<4>

fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>

where W: uWrite + ?Sized,

Formats the value using the given formatter

impl uDebug for ByteArray<6>

fn fmt<W>(&self, f: &mut Formatter<'_, W>) -> Result<(), W::Error>

where W: uWrite + ?Sized,

Formats the value using the given formatter

impl<const N: usize> Copy for ByteArray<N>

impl<const N: usize> Eq for ByteArray<N>

impl<const N: usize> StructuralPartialEq for ByteArray<N>