smoltcp/src/wire/sixlowpan.rs

//! Implementation of [RFC 6282] which specifies a compression format for IPv6 datagrams over
//! IEEE802.154-based networks.
//!
//! [RFC 6282]: https://datatracker.ietf.org/doc/html/rfc6282

use super::{Error, Result};
use crate::wire::ieee802154::Address as LlAddress;
use crate::wire::ipv6;
use crate::wire::IpProtocol;

const ADDRESS_CONTEXT_LENGTH: usize = 8;

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct AddressContext(pub [u8; ADDRESS_CONTEXT_LENGTH]);

/// The representation of an unresolved address. 6LoWPAN compression of IPv6 addresses can be with
/// and without context information. The decompression with context information is not yet
/// implemented.
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum UnresolvedAddress<'a> {
    WithoutContext(AddressMode<'a>),
    WithContext((usize, AddressMode<'a>)),
    Reserved,
}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum AddressMode<'a> {
    /// The full address is carried in-line.
    FullInline(&'a [u8]),
    /// The first 64-bits of the address are elided. The value of those bits
    /// is the link-local prefix padded with zeros. The remaining 64 bits are
    /// carried in-line.
    InLine64bits(&'a [u8]),
    /// The first 112 bits of the address are elided. The value of the first
    /// 64 bits is the link-local prefix padded with zeros. The following 64 bits
    /// are 0000:00ff:fe00:XXXX, where XXXX are the 16 bits carried in-line.
    InLine16bits(&'a [u8]),
    /// The address is fully elided. The first 64 bits of the address are
    /// the link-local prefix padded with zeros. The remaining 64 bits are
    /// computed from the encapsulating header (e.g., 802.15.4 or IPv6 source address)
    /// as specified in Section 3.2.2.
    FullyElided,
    /// The address takes the form ffXX::00XX:XXXX:XXXX
    Multicast48bits(&'a [u8]),
    /// The address takes the form ffXX::00XX:XXXX.
    Multicast32bits(&'a [u8]),
    /// The address takes the form ff02::00XX.
    Multicast8bits(&'a [u8]),
    /// The unspecified address.
    Unspecified,
    NotSupported,
}

const LINK_LOCAL_PREFIX: [u8; 2] = [0xfe, 0x80];
const EUI64_MIDDLE_VALUE: [u8; 2] = [0xff, 0xfe];

impl<'a> UnresolvedAddress<'a> {
    pub fn resolve(
        self,
        ll_address: Option<LlAddress>,
        addr_context: &[AddressContext],
    ) -> Result<ipv6::Address> {
        let mut bytes = [0; 16];

        let copy_context = |index: usize, bytes: &mut [u8]| -> Result<()> {
            if index >= addr_context.len() {
                return Err(Error);
            }

            let context = addr_context[index];
            bytes[..ADDRESS_CONTEXT_LENGTH].copy_from_slice(&context.0);

            Ok(())
        };

        match self {
            UnresolvedAddress::WithoutContext(mode) => match mode {
                AddressMode::FullInline(addr) => Ok(ipv6::Address::from_bytes(addr)),
                AddressMode::InLine64bits(inline) => {
                    bytes[0..2].copy_from_slice(&LINK_LOCAL_PREFIX[..]);
                    bytes[8..].copy_from_slice(inline);
                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                AddressMode::InLine16bits(inline) => {
                    bytes[0..2].copy_from_slice(&LINK_LOCAL_PREFIX[..]);
                    bytes[11..13].copy_from_slice(&EUI64_MIDDLE_VALUE[..]);
                    bytes[14..].copy_from_slice(inline);
                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                AddressMode::FullyElided => {
                    bytes[0..2].copy_from_slice(&LINK_LOCAL_PREFIX[..]);
                    match ll_address {
                        Some(LlAddress::Short(ll)) => {
                            bytes[11..13].copy_from_slice(&EUI64_MIDDLE_VALUE[..]);
                            bytes[14..].copy_from_slice(&ll);
                        }
                        Some(addr @ LlAddress::Extended(_)) => match addr.as_eui_64() {
                            Some(addr) => bytes[8..].copy_from_slice(&addr),
                            None => return Err(Error),
                        },
                        Some(LlAddress::Absent) => return Err(Error),
                        None => return Err(Error),
                    }
                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                AddressMode::Multicast48bits(inline) => {
                    bytes[0] = 0xff;
                    bytes[1] = inline[0];
                    bytes[11..].copy_from_slice(&inline[1..][..5]);
                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                AddressMode::Multicast32bits(inline) => {
                    bytes[0] = 0xff;
                    bytes[1] = inline[0];
                    bytes[13..].copy_from_slice(&inline[1..][..3]);
                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                AddressMode::Multicast8bits(inline) => {
                    bytes[0] = 0xff;
                    bytes[1] = 0x02;
                    bytes[15] = inline[0];
                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                _ => Err(Error),
            },
            UnresolvedAddress::WithContext(mode) => match mode {
                (_, AddressMode::Unspecified) => Ok(ipv6::Address::UNSPECIFIED),
                (index, AddressMode::InLine64bits(inline)) => {
                    copy_context(index, &mut bytes[..])?;
                    bytes[16 - inline.len()..].copy_from_slice(inline);
                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                (index, AddressMode::InLine16bits(inline)) => {
                    copy_context(index, &mut bytes[..])?;
                    bytes[16 - inline.len()..].copy_from_slice(inline);
                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                (index, AddressMode::FullyElided) => {
                    match ll_address {
                        Some(LlAddress::Short(ll)) => {
                            bytes[11..13].copy_from_slice(&EUI64_MIDDLE_VALUE[..]);
                            bytes[14..].copy_from_slice(&ll);
                        }
                        Some(addr @ LlAddress::Extended(_)) => match addr.as_eui_64() {
                            Some(addr) => bytes[8..].copy_from_slice(&addr),
                            None => return Err(Error),
                        },
                        Some(LlAddress::Absent) => return Err(Error),
                        None => return Err(Error),
                    }

                    copy_context(index, &mut bytes[..])?;

                    Ok(ipv6::Address::from_bytes(&bytes[..]))
                }
                _ => Err(Error),
            },
            UnresolvedAddress::Reserved => Err(Error),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum SixlowpanPacket {
    FragmentHeader,
    IphcHeader,
}

const DISPATCH_FIRST_FRAGMENT_HEADER: u8 = 0b11000;
const DISPATCH_FRAGMENT_HEADER: u8 = 0b11100;
const DISPATCH_IPHC_HEADER: u8 = 0b011;
const DISPATCH_UDP_HEADER: u8 = 0b11110;
const DISPATCH_EXT_HEADER: u8 = 0b1110;

impl SixlowpanPacket {
    /// Returns the type of the 6LoWPAN header.
    /// This can either be a fragment header or an IPHC header.
    ///
    /// # Errors
    /// Returns `[Error::Unrecognized]` when neither the Fragment Header dispatch or the IPHC
    /// dispatch is recognized.
    pub fn dispatch(buffer: impl AsRef<[u8]>) -> Result<Self> {
        let raw = buffer.as_ref();

        if raw.is_empty() {
            return Err(Error);
        }

        if raw[0] >> 3 == DISPATCH_FIRST_FRAGMENT_HEADER || raw[0] >> 3 == DISPATCH_FRAGMENT_HEADER
        {
            Ok(Self::FragmentHeader)
        } else if raw[0] >> 5 == DISPATCH_IPHC_HEADER {
            Ok(Self::IphcHeader)
        } else {
            Err(Error)
        }
    }
}

pub mod frag {
    //! Implementation of the fragment headers from [RFC 4944 § 5.3].
    //!
    //! [RFC 4944 § 5.3]: https://datatracker.ietf.org/doc/html/rfc4944#section-5.3

    use super::{DISPATCH_FIRST_FRAGMENT_HEADER, DISPATCH_FRAGMENT_HEADER};
    use crate::wire::{Error, Result};
    use crate::wire::{Ieee802154Address, Ieee802154Repr};
    use byteorder::{ByteOrder, NetworkEndian};

    /// Key used for identifying all the link fragments that belong to the same packet.
    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    pub struct Key {
        pub(crate) ll_src_addr: Ieee802154Address,
        pub(crate) ll_dst_addr: Ieee802154Address,
        pub(crate) datagram_size: u16,
        pub(crate) datagram_tag: u16,
    }

    /// A read/write wrapper around a 6LoWPAN Fragment header.
    /// [RFC 4944 § 5.3] specifies the format of the header.
    ///
    /// A First Fragment header has the following format:
    /// ```txt
    ///                      1                   2                   3
    ///  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    /// |1 1 0 0 0|    datagram_size    |         datagram_tag          |
    /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    /// ```
    ///
    /// Subsequent fragment headers have the following format:
    /// ```txt
    ///                      1                   2                   3
    ///  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    /// |1 1 1 0 0|    datagram_size    |         datagram_tag          |
    /// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    /// |datagram_offset|
    /// +-+-+-+-+-+-+-+-+
    /// ```
    ///
    /// [RFC 4944 § 5.3]: https://datatracker.ietf.org/doc/html/rfc4944#section-5.3
    #[derive(Debug, Clone)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    pub struct Packet<T: AsRef<[u8]>> {
        buffer: T,
    }

    pub const FIRST_FRAGMENT_HEADER_SIZE: usize = 4;
    pub const NEXT_FRAGMENT_HEADER_SIZE: usize = 5;

    mod field {
        use crate::wire::field::*;

        pub const DISPATCH: usize = 0;
        pub const DATAGRAM_SIZE: Field = 0..2;
        pub const DATAGRAM_TAG: Field = 2..4;
        pub const DATAGRAM_OFFSET: usize = 4;

        pub const FIRST_FRAGMENT_REST: Rest = super::FIRST_FRAGMENT_HEADER_SIZE..;
        pub const NEXT_FRAGMENT_REST: Rest = super::NEXT_FRAGMENT_HEADER_SIZE..;
    }

    impl<T: AsRef<[u8]>> Packet<T> {
        /// Input a raw octet buffer with a 6LoWPAN Fragment header structure.
        pub const fn new_unchecked(buffer: T) -> Self {
            Self { buffer }
        }

        /// Shorthand for a combination of [new_unchecked] and [check_len].
        ///
        /// [new_unchecked]: #method.new_unchecked
        /// [check_len]: #method.check_len
        pub fn new_checked(buffer: T) -> Result<Self> {
            let packet = Self::new_unchecked(buffer);
            packet.check_len()?;

            let dispatch = packet.dispatch();

            if dispatch != DISPATCH_FIRST_FRAGMENT_HEADER && dispatch != DISPATCH_FRAGMENT_HEADER {
                return Err(Error);
            }

            Ok(packet)
        }

        /// Ensure that no accessor method will panic if called.
        /// Returns `Err(Error)` if the buffer is too short.
        pub fn check_len(&self) -> Result<()> {
            let buffer = self.buffer.as_ref();
            if buffer.is_empty() {
                return Err(Error);
            }

            match self.dispatch() {
                DISPATCH_FIRST_FRAGMENT_HEADER if buffer.len() >= FIRST_FRAGMENT_HEADER_SIZE => {
                    Ok(())
                }
                DISPATCH_FIRST_FRAGMENT_HEADER if buffer.len() < FIRST_FRAGMENT_HEADER_SIZE => {
                    Err(Error)
                }
                DISPATCH_FRAGMENT_HEADER if buffer.len() >= NEXT_FRAGMENT_HEADER_SIZE => Ok(()),
                DISPATCH_FRAGMENT_HEADER if buffer.len() < NEXT_FRAGMENT_HEADER_SIZE => Err(Error),
                _ => Err(Error),
            }
        }

        /// Consumes the frame, returning the underlying buffer.
        pub fn into_inner(self) -> T {
            self.buffer
        }

        /// Return the dispatch field.
        pub fn dispatch(&self) -> u8 {
            let raw = self.buffer.as_ref();
            raw[field::DISPATCH] >> 3
        }

        /// Return the total datagram size.
        pub fn datagram_size(&self) -> u16 {
            let raw = self.buffer.as_ref();
            NetworkEndian::read_u16(&raw[field::DATAGRAM_SIZE]) & 0b111_1111_1111
        }

        /// Return the datagram tag.
        pub fn datagram_tag(&self) -> u16 {
            let raw = self.buffer.as_ref();
            NetworkEndian::read_u16(&raw[field::DATAGRAM_TAG])
        }

        /// Return the datagram offset.
        pub fn datagram_offset(&self) -> u8 {
            match self.dispatch() {
                DISPATCH_FIRST_FRAGMENT_HEADER => 0,
                DISPATCH_FRAGMENT_HEADER => {
                    let raw = self.buffer.as_ref();
                    raw[field::DATAGRAM_OFFSET]
                }
                _ => unreachable!(),
            }
        }

        /// Returns `true` when this header is from the first fragment of a link.
        pub fn is_first_fragment(&self) -> bool {
            self.dispatch() == DISPATCH_FIRST_FRAGMENT_HEADER
        }

        /// Returns the key for identifying the packet it belongs to.
        pub fn get_key(&self, ieee802154_repr: &Ieee802154Repr) -> Key {
            Key {
                ll_src_addr: ieee802154_repr.src_addr.unwrap(),
                ll_dst_addr: ieee802154_repr.dst_addr.unwrap(),
                datagram_size: self.datagram_size(),
                datagram_tag: self.datagram_tag(),
            }
        }
    }

    impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
        /// Return the payload.
        pub fn payload(&self) -> &'a [u8] {
            match self.dispatch() {
                DISPATCH_FIRST_FRAGMENT_HEADER => {
                    let raw = self.buffer.as_ref();
                    &raw[field::FIRST_FRAGMENT_REST]
                }
                DISPATCH_FRAGMENT_HEADER => {
                    let raw = self.buffer.as_ref();
                    &raw[field::NEXT_FRAGMENT_REST]
                }
                _ => unreachable!(),
            }
        }
    }

    impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
        fn set_dispatch_field(&mut self, value: u8) {
            let raw = self.buffer.as_mut();
            raw[field::DISPATCH] = (raw[field::DISPATCH] & !(0b11111 << 3)) | (value << 3);
        }

        fn set_datagram_size(&mut self, size: u16) {
            let raw = self.buffer.as_mut();
            let mut v = NetworkEndian::read_u16(&raw[field::DATAGRAM_SIZE]);
            v = (v & !0b111_1111_1111) | size;

            NetworkEndian::write_u16(&mut raw[field::DATAGRAM_SIZE], v);
        }

        fn set_datagram_tag(&mut self, tag: u16) {
            let raw = self.buffer.as_mut();
            NetworkEndian::write_u16(&mut raw[field::DATAGRAM_TAG], tag);
        }

        fn set_datagram_offset(&mut self, offset: u8) {
            let raw = self.buffer.as_mut();
            raw[field::DATAGRAM_OFFSET] = offset;
        }
    }

    /// A high-level representation of a 6LoWPAN Fragment header.
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    pub enum Repr {
        FirstFragment { size: u16, tag: u16 },
        Fragment { size: u16, tag: u16, offset: u8 },
    }

    impl core::fmt::Display for Repr {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            match self {
                Repr::FirstFragment { size, tag } => {
                    write!(f, "FirstFrag size={size} tag={tag}")
                }
                Repr::Fragment { size, tag, offset } => {
                    write!(f, "NthFrag size={size} tag={tag} offset={offset}")
                }
            }
        }
    }

    #[cfg(feature = "defmt")]
    impl defmt::Format for Repr {
        fn format(&self, fmt: defmt::Formatter) {
            match self {
                Repr::FirstFragment { size, tag } => {
                    defmt::write!(fmt, "FirstFrag size={} tag={}", size, tag);
                }
                Repr::Fragment { size, tag, offset } => {
                    defmt::write!(fmt, "NthFrag size={} tag={} offset={}", size, tag, offset);
                }
            }
        }
    }

    impl Repr {
        /// Parse a 6LoWPAN Fragment header.
        pub fn parse<T: AsRef<[u8]>>(packet: &Packet<T>) -> Result<Self> {
            let size = packet.datagram_size();
            let tag = packet.datagram_tag();

            match packet.dispatch() {
                DISPATCH_FIRST_FRAGMENT_HEADER => Ok(Self::FirstFragment { size, tag }),
                DISPATCH_FRAGMENT_HEADER => Ok(Self::Fragment {
                    size,
                    tag,
                    offset: packet.datagram_offset(),
                }),
                _ => Err(Error),
            }
        }

        /// Returns the length of the Fragment header.
        pub const fn buffer_len(&self) -> usize {
            match self {
                Self::FirstFragment { .. } => field::FIRST_FRAGMENT_REST.start,
                Self::Fragment { .. } => field::NEXT_FRAGMENT_REST.start,
            }
        }

        /// Emit a high-level representation into a 6LoWPAN Fragment header.
        pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
            match self {
                Self::FirstFragment { size, tag } => {
                    packet.set_dispatch_field(DISPATCH_FIRST_FRAGMENT_HEADER);
                    packet.set_datagram_size(*size);
                    packet.set_datagram_tag(*tag);
                }
                Self::Fragment { size, tag, offset } => {
                    packet.set_dispatch_field(DISPATCH_FRAGMENT_HEADER);
                    packet.set_datagram_size(*size);
                    packet.set_datagram_tag(*tag);
                    packet.set_datagram_offset(*offset);
                }
            }
        }
    }
}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum NextHeader {
    Compressed,
    Uncompressed(IpProtocol),
}

impl core::fmt::Display for NextHeader {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            NextHeader::Compressed => write!(f, "compressed"),
            NextHeader::Uncompressed(protocol) => write!(f, "{protocol}"),
        }
    }
}

#[cfg(feature = "defmt")]
impl defmt::Format for NextHeader {
    fn format(&self, fmt: defmt::Formatter) {
        match self {
            NextHeader::Compressed => defmt::write!(fmt, "compressed"),
            NextHeader::Uncompressed(protocol) => defmt::write!(fmt, "{}", protocol),
        }
    }
}

pub mod iphc {
    //! Implementation of IP Header Compression from [RFC 6282 § 3.1].
    //! It defines the compression of IPv6 headers.
    //!
    //! [RFC 6282 § 3.1]: https://datatracker.ietf.org/doc/html/rfc6282#section-3.1

    use super::{
        AddressContext, AddressMode, Error, NextHeader, Result, UnresolvedAddress,
        DISPATCH_IPHC_HEADER,
    };
    use crate::wire::{ieee802154::Address as LlAddress, ipv6, IpProtocol};
    use byteorder::{ByteOrder, NetworkEndian};

    mod field {
        use crate::wire::field::*;

        pub const IPHC_FIELD: Field = 0..2;
    }

    macro_rules! get_field {
        ($name:ident, $mask:expr, $shift:expr) => {
            fn $name(&self) -> u8 {
                let data = self.buffer.as_ref();
                let raw = NetworkEndian::read_u16(&data[field::IPHC_FIELD]);
                ((raw >> $shift) & $mask) as u8
            }
        };
    }

    macro_rules! set_field {
        ($name:ident, $mask:expr, $shift:expr) => {
            fn $name(&mut self, val: u8) {
                let data = &mut self.buffer.as_mut()[field::IPHC_FIELD];
                let mut raw = NetworkEndian::read_u16(data);

                raw = (raw & !($mask << $shift)) | ((val as u16) << $shift);
                NetworkEndian::write_u16(data, raw);
            }
        };
    }

    /// A read/write wrapper around a 6LoWPAN IPHC header.
    /// [RFC 6282 § 3.1] specifies the format of the header.
    ///
    /// The header always start with the following base format (from [RFC 6282 § 3.1.1]):
    /// ```txt
    ///    0                                       1
    ///    0   1   2   3   4   5   6   7   8   9   0   1   2   3   4   5
    ///  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    ///  | 0 | 1 | 1 |  TF   |NH | HLIM  |CID|SAC|  SAM  | M |DAC|  DAM  |
    ///  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
    /// ```
    /// With:
    /// - TF: Traffic Class and Flow Label
    /// - NH: Next Header
    /// - HLIM: Hop Limit
    /// - CID: Context Identifier Extension
    /// - SAC: Source Address Compression
    /// - SAM: Source Address Mode
    /// - M: Multicast Compression
    /// - DAC: Destination Address Compression
    /// - DAM: Destination Address Mode
    ///
    /// Depending on the flags in the base format, the following fields are added to the header:
    /// - Traffic Class and Flow Label
    /// - Next Header
    /// - Hop Limit
    /// - IPv6 source address
    /// - IPv6 destinatino address
    ///
    /// [RFC 6282 § 3.1]: https://datatracker.ietf.org/doc/html/rfc6282#section-3.1
    /// [RFC 6282 § 3.1.1]: https://datatracker.ietf.org/doc/html/rfc6282#section-3.1.1
    #[derive(Debug, Clone)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    pub struct Packet<T: AsRef<[u8]>> {
        buffer: T,
    }

    impl<T: AsRef<[u8]>> Packet<T> {
        /// Input a raw octet buffer with a 6LoWPAN IPHC header structure.
        pub const fn new_unchecked(buffer: T) -> Self {
            Packet { buffer }
        }

        /// Shorthand for a combination of [new_unchecked] and [check_len].
        ///
        /// [new_unchecked]: #method.new_unchecked
        /// [check_len]: #method.check_len
        pub fn new_checked(buffer: T) -> Result<Self> {
            let packet = Self::new_unchecked(buffer);
            packet.check_len()?;
            Ok(packet)
        }

        /// Ensure that no accessor method will panic if called.
        /// Returns `Err(Error)` if the buffer is too short.
        pub fn check_len(&self) -> Result<()> {
            let buffer = self.buffer.as_ref();
            if buffer.len() < 2 {
                return Err(Error);
            }

            let mut offset = self.ip_fields_start()
                + self.traffic_class_size()
                + self.next_header_size()
                + self.hop_limit_size();
            offset += self.src_address_size();
            offset += self.dst_address_size();

            if offset as usize > buffer.len() {
                return Err(Error);
            }

            Ok(())
        }

        /// Consumes the frame, returning the underlying buffer.
        pub fn into_inner(self) -> T {
            self.buffer
        }

        /// Return the Next Header field.
        pub fn next_header(&self) -> NextHeader {
            let nh = self.nh_field();

            if nh == 1 {
                // The next header field is compressed.
                // It is also encoded using LOWPAN_NHC.
                NextHeader::Compressed
            } else {
                // The full 8 bits for Next Header are carried in-line.
                let start = (self.ip_fields_start() + self.traffic_class_size()) as usize;

                let data = self.buffer.as_ref();
                let nh = data[start..start + 1][0];
                NextHeader::Uncompressed(IpProtocol::from(nh))
            }
        }

        /// Return the Hop Limit.
        pub fn hop_limit(&self) -> u8 {
            match self.hlim_field() {
                0b00 => {
                    let start = (self.ip_fields_start()
                        + self.traffic_class_size()
                        + self.next_header_size()) as usize;

                    let data = self.buffer.as_ref();
                    data[start..start + 1][0]
                }
                0b01 => 1,
                0b10 => 64,
                0b11 => 255,
                _ => unreachable!(),
            }
        }

        /// Return the Source Context Identifier.
        pub fn src_context_id(&self) -> Option<u8> {
            if self.cid_field() == 1 {
                let data = self.buffer.as_ref();
                Some(data[2] >> 4)
            } else {
                None
            }
        }

        /// Return the Destination Context Identifier.
        pub fn dst_context_id(&self) -> Option<u8> {
            if self.cid_field() == 1 {
                let data = self.buffer.as_ref();
                Some(data[2] & 0x0f)
            } else {
                None
            }
        }

        /// Return the ECN field (when it is inlined).
        pub fn ecn_field(&self) -> Option<u8> {
            match self.tf_field() {
                0b00 | 0b01 | 0b10 => {
                    let start = self.ip_fields_start() as usize;
                    Some(self.buffer.as_ref()[start..][0] & 0b1100_0000)
                }
                0b11 => None,
                _ => unreachable!(),
            }
        }

        /// Return the DSCP field (when it is inlined).
        pub fn dscp_field(&self) -> Option<u8> {
            match self.tf_field() {
                0b00 | 0b10 => {
                    let start = self.ip_fields_start() as usize;
                    Some(self.buffer.as_ref()[start..][0] & 0b111111)
                }
                0b01 | 0b11 => None,
                _ => unreachable!(),
            }
        }

        /// Return the flow label field (when it is inlined).
        pub fn flow_label_field(&self) -> Option<u16> {
            match self.tf_field() {
                0b00 => {
                    let start = self.ip_fields_start() as usize;
                    Some(NetworkEndian::read_u16(
                        &self.buffer.as_ref()[start..][2..4],
                    ))
                }
                0b01 => {
                    let start = self.ip_fields_start() as usize;
                    Some(NetworkEndian::read_u16(
                        &self.buffer.as_ref()[start..][1..3],
                    ))
                }
                0b10 | 0b11 => None,
                _ => unreachable!(),
            }
        }

        /// Return the Source Address.
        pub fn src_addr(&self) -> Result<UnresolvedAddress> {
            let start = (self.ip_fields_start()
                + self.traffic_class_size()
                + self.next_header_size()
                + self.hop_limit_size()) as usize;

            let data = self.buffer.as_ref();
            match (self.sac_field(), self.sam_field()) {
                (0, 0b00) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullInline(
                    &data[start..][..16],
                ))),
                (0, 0b01) => Ok(UnresolvedAddress::WithoutContext(
                    AddressMode::InLine64bits(&data[start..][..8]),
                )),
                (0, 0b10) => Ok(UnresolvedAddress::WithoutContext(
                    AddressMode::InLine16bits(&data[start..][..2]),
                )),
                (0, 0b11) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullyElided)),
                (1, 0b00) => Ok(UnresolvedAddress::WithContext((
                    0,
                    AddressMode::Unspecified,
                ))),
                (1, 0b01) => {
                    if let Some(id) = self.src_context_id() {
                        Ok(UnresolvedAddress::WithContext((
                            id as usize,
                            AddressMode::InLine64bits(&data[start..][..8]),
                        )))
                    } else {
                        Err(Error)
                    }
                }
                (1, 0b10) => {
                    if let Some(id) = self.src_context_id() {
                        Ok(UnresolvedAddress::WithContext((
                            id as usize,
                            AddressMode::InLine16bits(&data[start..][..2]),
                        )))
                    } else {
                        Err(Error)
                    }
                }
                (1, 0b11) => {
                    if let Some(id) = self.src_context_id() {
                        Ok(UnresolvedAddress::WithContext((
                            id as usize,
                            AddressMode::FullyElided,
                        )))
                    } else {
                        Err(Error)
                    }
                }
                _ => Err(Error),
            }
        }

        /// Return the Destination Address.
        pub fn dst_addr(&self) -> Result<UnresolvedAddress> {
            let start = (self.ip_fields_start()
                + self.traffic_class_size()
                + self.next_header_size()
                + self.hop_limit_size()
                + self.src_address_size()) as usize;

            let data = self.buffer.as_ref();
            match (self.m_field(), self.dac_field(), self.dam_field()) {
                (0, 0, 0b00) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullInline(
                    &data[start..][..16],
                ))),
                (0, 0, 0b01) => Ok(UnresolvedAddress::WithoutContext(
                    AddressMode::InLine64bits(&data[start..][..8]),
                )),
                (0, 0, 0b10) => Ok(UnresolvedAddress::WithoutContext(
                    AddressMode::InLine16bits(&data[start..][..2]),
                )),
                (0, 0, 0b11) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullyElided)),
                (0, 1, 0b00) => Ok(UnresolvedAddress::Reserved),
                (0, 1, 0b01) => {
                    if let Some(id) = self.dst_context_id() {
                        Ok(UnresolvedAddress::WithContext((
                            id as usize,
                            AddressMode::InLine64bits(&data[start..][..8]),
                        )))
                    } else {
                        Err(Error)
                    }
                }
                (0, 1, 0b10) => {
                    if let Some(id) = self.dst_context_id() {
                        Ok(UnresolvedAddress::WithContext((
                            id as usize,
                            AddressMode::InLine16bits(&data[start..][..2]),
                        )))
                    } else {
                        Err(Error)
                    }
                }
                (0, 1, 0b11) => {
                    if let Some(id) = self.dst_context_id() {
                        Ok(UnresolvedAddress::WithContext((
                            id as usize,
                            AddressMode::FullyElided,
                        )))
                    } else {
                        Err(Error)
                    }
                }
                (1, 0, 0b00) => Ok(UnresolvedAddress::WithoutContext(AddressMode::FullInline(
                    &data[start..][..16],
                ))),
                (1, 0, 0b01) => Ok(UnresolvedAddress::WithoutContext(
                    AddressMode::Multicast48bits(&data[start..][..6]),
                )),
                (1, 0, 0b10) => Ok(UnresolvedAddress::WithoutContext(
                    AddressMode::Multicast32bits(&data[start..][..4]),
                )),
                (1, 0, 0b11) => Ok(UnresolvedAddress::WithoutContext(
                    AddressMode::Multicast8bits(&data[start..][..1]),
                )),
                (1, 1, 0b00) => Ok(UnresolvedAddress::WithContext((
                    0,
                    AddressMode::NotSupported,
                ))),
                (1, 1, 0b01 | 0b10 | 0b11) => Ok(UnresolvedAddress::Reserved),
                _ => Err(Error),
            }
        }

        get_field!(dispatch_field, 0b111, 13);
        get_field!(tf_field, 0b11, 11);
        get_field!(nh_field, 0b1, 10);
        get_field!(hlim_field, 0b11, 8);
        get_field!(cid_field, 0b1, 7);
        get_field!(sac_field, 0b1, 6);
        get_field!(sam_field, 0b11, 4);
        get_field!(m_field, 0b1, 3);
        get_field!(dac_field, 0b1, 2);
        get_field!(dam_field, 0b11, 0);

        /// Return the start for the IP fields.
        fn ip_fields_start(&self) -> u8 {
            2 + self.cid_size()
        }

        /// Get the size in octets of the traffic class field.
        fn traffic_class_size(&self) -> u8 {
            match self.tf_field() {
                0b00 => 4,
                0b01 => 3,
                0b10 => 1,
                0b11 => 0,
                _ => unreachable!(),
            }
        }

        /// Get the size in octets of the next header field.
        fn next_header_size(&self) -> u8 {
            (self.nh_field() != 1) as u8
        }

        /// Get the size in octets of the hop limit field.
        fn hop_limit_size(&self) -> u8 {
            (self.hlim_field() == 0b00) as u8
        }

        /// Get the size in octets of the CID field.
        fn cid_size(&self) -> u8 {
            (self.cid_field() == 1) as u8
        }

        /// Get the size in octets of the source address.
        fn src_address_size(&self) -> u8 {
            match (self.sac_field(), self.sam_field()) {
                (0, 0b00) => 16, // The full address is carried in-line.
                (0, 0b01) => 8,  // The first 64 bits are elided.
                (0, 0b10) => 2,  // The first 112 bits are elided.
                (0, 0b11) => 0,  // The address is fully elided.
                (1, 0b00) => 0,  // The UNSPECIFIED address.
                (1, 0b01) => 8,  // Address derived using context information.
                (1, 0b10) => 2,  // Address derived using context information.
                (1, 0b11) => 0,  // Address derived using context information.
                _ => unreachable!(),
            }
        }

        /// Get the size in octets of the address address.
        fn dst_address_size(&self) -> u8 {
            match (self.m_field(), self.dac_field(), self.dam_field()) {
                (0, 0, 0b00) => 16, // The full address is carried in-line.
                (0, 0, 0b01) => 8,  // The first 64 bits are elided.
                (0, 0, 0b10) => 2,  // The first 112 bits are elided.
                (0, 0, 0b11) => 0,  // The address is fully elided.
                (0, 1, 0b00) => 0,  // Reserved.
                (0, 1, 0b01) => 8,  // Address derived using context information.
                (0, 1, 0b10) => 2,  // Address derived using context information.
                (0, 1, 0b11) => 0,  // Address derived using context information.
                (1, 0, 0b00) => 16, // The full address is carried in-line.
                (1, 0, 0b01) => 6,  // The address takes the form ffXX::00XX:XXXX:XXXX.
                (1, 0, 0b10) => 4,  // The address takes the form ffXX::00XX:XXXX.
                (1, 0, 0b11) => 1,  // The address takes the form ff02::00XX.
                (1, 1, 0b00) => 6,  // Match Unicast-Prefix-based IPv6.
                (1, 1, 0b01) => 0,  // Reserved.
                (1, 1, 0b10) => 0,  // Reserved.
                (1, 1, 0b11) => 0,  // Reserved.
                _ => unreachable!(),
            }
        }

        /// Return the length of the header.
        pub fn header_len(&self) -> usize {
            let mut len = self.ip_fields_start();
            len += self.traffic_class_size();
            len += self.next_header_size();
            len += self.hop_limit_size();
            len += self.src_address_size();
            len += self.dst_address_size();

            len as usize
        }
    }

    impl<'a, T: AsRef<[u8]> + ?Sized> Packet<&'a T> {
        /// Return a pointer to the payload.
        pub fn payload(&self) -> &'a [u8] {
            let mut len = self.ip_fields_start();
            len += self.traffic_class_size();
            len += self.next_header_size();
            len += self.hop_limit_size();
            len += self.src_address_size();
            len += self.dst_address_size();

            let len = len as usize;

            let data = self.buffer.as_ref();
            &data[len..]
        }
    }

    impl<T: AsRef<[u8]> + AsMut<[u8]>> Packet<T> {
        /// Set the dispatch field to `0b011`.
        fn set_dispatch_field(&mut self) {
            let data = &mut self.buffer.as_mut()[field::IPHC_FIELD];
            let mut raw = NetworkEndian::read_u16(data);

            raw = (raw & !(0b111 << 13)) | (0b11 << 13);
            NetworkEndian::write_u16(data, raw);
        }

        set_field!(set_tf_field, 0b11, 11);
        set_field!(set_nh_field, 0b1, 10);
        set_field!(set_hlim_field, 0b11, 8);
        set_field!(set_cid_field, 0b1, 7);
        set_field!(set_sac_field, 0b1, 6);
        set_field!(set_sam_field, 0b11, 4);
        set_field!(set_m_field, 0b1, 3);
        set_field!(set_dac_field, 0b1, 2);
        set_field!(set_dam_field, 0b11, 0);

        fn set_field(&mut self, idx: usize, value: &[u8]) {
            let raw = self.buffer.as_mut();
            raw[idx..idx + value.len()].copy_from_slice(value);
        }

        /// Set the Next Header.
        ///
        /// **NOTE**: `idx` is the offset at which the Next Header needs to be written to.
        fn set_next_header(&mut self, nh: NextHeader, mut idx: usize) -> usize {
            match nh {
                NextHeader::Uncompressed(nh) => {
                    self.set_nh_field(0);
                    self.set_field(idx, &[nh.into()]);
                    idx += 1;
                }
                NextHeader::Compressed => self.set_nh_field(1),
            }

            idx
        }

        /// Set the Hop Limit.
        ///
        /// **NOTE**: `idx` is the offset at which the Next Header needs to be written to.
        fn set_hop_limit(&mut self, hl: u8, mut idx: usize) -> usize {
            match hl {
                255 => self.set_hlim_field(0b11),
                64 => self.set_hlim_field(0b10),
                1 => self.set_hlim_field(0b01),
                _ => {
                    self.set_hlim_field(0b00);
                    self.set_field(idx, &[hl]);
                    idx += 1;
                }
            }

            idx
        }

        /// Set the Source Address based on the IPv6 address and the Link-Local address.
        ///
        /// **NOTE**: `idx` is the offset at which the Next Header needs to be written to.
        fn set_src_address(
            &mut self,
            src_addr: ipv6::Address,
            ll_src_addr: Option<LlAddress>,
            mut idx: usize,
        ) -> usize {
            self.set_cid_field(0);
            self.set_sac_field(0);
            let src = src_addr.as_bytes();
            if src_addr == ipv6::Address::UNSPECIFIED {
                self.set_sac_field(1);
                self.set_sam_field(0b00);
            } else if src_addr.is_link_local() {
                // We have a link local address.
                // The remainder of the address can be elided when the context contains
                // a 802.15.4 short address or a 802.15.4 extended address which can be
                // converted to a eui64 address.
                let is_eui_64 = ll_src_addr
                    .map(|addr| {
                        addr.as_eui_64()
                            .map(|addr| addr[..] == src[8..])
                            .unwrap_or(false)
                    })
                    .unwrap_or(false);

                if src[8..14] == [0, 0, 0, 0xff, 0xfe, 0] {
                    let ll = [src[14], src[15]];

                    if ll_src_addr == Some(LlAddress::Short(ll)) {
                        // We have the context from the 802.15.4 frame.
                        // The context contains the short address.
                        // We can elide the source address.
                        self.set_sam_field(0b11);
                    } else {
                        // We don't have the context from the 802.15.4 frame.
                        // We cannot elide the source address, however we can elide 112 bits.
                        self.set_sam_field(0b10);

                        self.set_field(idx, &src[14..]);
                        idx += 2;
                    }
                } else if is_eui_64 {
                    // We have the context from the 802.15.4 frame.
                    // The context contains the extended address.
                    // We can elide the source address.
                    self.set_sam_field(0b11);
                } else {
                    // We cannot elide the source address, however we can elide 64 bits.
                    self.set_sam_field(0b01);

                    self.set_field(idx, &src[8..]);
                    idx += 8;
                }
            } else {
                // We cannot elide anything.
                self.set_sam_field(0b00);
                self.set_field(idx, src);
                idx += 16;
            }

            idx
        }

        /// Set the Destination Address based on the IPv6 address and the Link-Local address.
        ///
        /// **NOTE**: `idx` is the offset at which the Next Header needs to be written to.
        fn set_dst_address(
            &mut self,
            dst_addr: ipv6::Address,
            ll_dst_addr: Option<LlAddress>,
            mut idx: usize,
        ) -> usize {
            self.set_dac_field(0);
            self.set_dam_field(0);
            self.set_m_field(0);
            let dst = dst_addr.as_bytes();
            if dst_addr.is_multicast() {
                self.set_m_field(1);

                if dst[1] == 0x02 && dst[2..15] == [0; 13] {
                    self.set_dam_field(0b11);

                    self.set_field(idx, &[dst[15]]);
                    idx += 1;
                } else if dst[2..13] == [0; 11] {
                    self.set_dam_field(0b10);

                    self.set_field(idx, &[dst[1]]);
                    idx += 1;
                    self.set_field(idx, &dst[13..]);
                    idx += 3;
                } else if dst[2..11] == [0; 9] {
                    self.set_dam_field(0b01);

                    self.set_field(idx, &[dst[1]]);
                    idx += 1;
                    self.set_field(idx, &dst[11..]);
                    idx += 5;
                } else {
                    self.set_dam_field(0b11);

                    self.set_field(idx, dst);
                    idx += 16;
                }
            } else if dst_addr.is_link_local() {
                let is_eui_64 = ll_dst_addr
                    .map(|addr| {
                        addr.as_eui_64()
                            .map(|addr| addr[..] == dst[8..])
                            .unwrap_or(false)
                    })
                    .unwrap_or(false);

                if dst[8..14] == [0, 0, 0, 0xff, 0xfe, 0] {
                    let ll = [dst[14], dst[15]];

                    if ll_dst_addr == Some(LlAddress::Short(ll)) {
                        self.set_dam_field(0b11);
                    } else {
                        self.set_dam_field(0b10);

                        self.set_field(idx, &dst[14..]);
                        idx += 2;
                    }
                } else if is_eui_64 {
                    self.set_dam_field(0b11);
                } else {
                    self.set_dam_field(0b01);

                    self.set_field(idx, &dst[8..]);
                    idx += 8;
                }
            } else {
                self.set_dam_field(0b00);

                self.set_field(idx, dst);
                idx += 16;
            }

            idx
        }

        /// Return a mutable pointer to the payload.
        pub fn payload_mut(&mut self) -> &mut [u8] {
            let mut len = self.ip_fields_start();

            len += self.traffic_class_size();
            len += self.next_header_size();
            len += self.hop_limit_size();
            len += self.src_address_size();
            len += self.dst_address_size();

            let len = len as usize;

            let data = self.buffer.as_mut();
            &mut data[len..]
        }
    }

    /// A high-level representation of a 6LoWPAN IPHC header.
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    pub struct Repr {
        pub src_addr: ipv6::Address,
        pub ll_src_addr: Option<LlAddress>,
        pub dst_addr: ipv6::Address,
        pub ll_dst_addr: Option<LlAddress>,
        pub next_header: NextHeader,
        pub hop_limit: u8,
        // TODO(thvdveld): refactor the following fields into something else
        pub ecn: Option<u8>,
        pub dscp: Option<u8>,
        pub flow_label: Option<u16>,
    }

    impl core::fmt::Display for Repr {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            write!(
                f,
                "IPHC src={} dst={} nxt-hdr={} hop-limit={}",
                self.src_addr, self.dst_addr, self.next_header, self.hop_limit
            )
        }
    }

    #[cfg(feature = "defmt")]
    impl defmt::Format for Repr {
        fn format(&self, fmt: defmt::Formatter) {
            defmt::write!(
                fmt,
                "IPHC src={} dst={} nxt-hdr={} hop-limit={}",
                self.src_addr,
                self.dst_addr,
                self.next_header,
                self.hop_limit
            );
        }
    }

    impl Repr {
        /// Parse a 6LoWPAN IPHC header and return a high-level representation.
        ///
        /// The `ll_src_addr` and `ll_dst_addr` are the link-local addresses used for resolving the
        /// IPv6 packets.
        pub fn parse<T: AsRef<[u8]> + ?Sized>(
            packet: &Packet<&T>,
            ll_src_addr: Option<LlAddress>,
            ll_dst_addr: Option<LlAddress>,
            addr_context: &[AddressContext],
        ) -> Result<Self> {
            // Ensure basic accessors will work.
            packet.check_len()?;

            if packet.dispatch_field() != DISPATCH_IPHC_HEADER {
                // This is not an LOWPAN_IPHC packet.
                return Err(Error);
            }

            let src_addr = packet.src_addr()?.resolve(ll_src_addr, addr_context)?;
            let dst_addr = packet.dst_addr()?.resolve(ll_dst_addr, addr_context)?;

            Ok(Self {
                src_addr,
                ll_src_addr,
                dst_addr,
                ll_dst_addr,
                next_header: packet.next_header(),
                hop_limit: packet.hop_limit(),
                ecn: packet.ecn_field(),
                dscp: packet.dscp_field(),
                flow_label: packet.flow_label_field(),
            })
        }

        /// Return the length of a header that will be emitted from this high-level representation.
        pub fn buffer_len(&self) -> usize {
            let mut len = 0;
            len += 2; // The minimal header length

            len += match self.next_header {
                NextHeader::Compressed => 0, // The next header is compressed (we don't need to inline what the next header is)
                NextHeader::Uncompressed(_) => 1, // The next header field is inlined
            };

            // Hop Limit size
            len += match self.hop_limit {
                255 | 64 | 1 => 0, // We can inline the hop limit
                _ => 1,
            };

            // Add the length of the source address
            len += if self.src_addr == ipv6::Address::UNSPECIFIED {
                0
            } else if self.src_addr.is_link_local() {
                let src = self.src_addr.as_bytes();
                let ll = [src[14], src[15]];

                let is_eui_64 = self
                    .ll_src_addr
                    .map(|addr| {
                        addr.as_eui_64()
                            .map(|addr| addr[..] == src[8..])
                            .unwrap_or(false)
                    })
                    .unwrap_or(false);

                if src[8..14] == [0, 0, 0, 0xff, 0xfe, 0] {
                    if self.ll_src_addr == Some(LlAddress::Short(ll)) {
                        0
                    } else {
                        2
                    }
                } else if is_eui_64 {
                    0
                } else {
                    8
                }
            } else {
                16
            };

            // Add the size of the destination header
            let dst = self.dst_addr.as_bytes();
            len += if self.dst_addr.is_multicast() {
                if dst[1] == 0x02 && dst[2..15] == [0; 13] {
                    1
                } else if dst[2..13] == [0; 11] {
                    4
                } else if dst[2..11] == [0; 9] {
                    6
                } else {
                    16
                }
            } else if self.dst_addr.is_link_local() {
                let is_eui_64 = self
                    .ll_dst_addr
                    .map(|addr| {
                        addr.as_eui_64()
                            .map(|addr| addr[..] == dst[8..])
                            .unwrap_or(false)
                    })
                    .unwrap_or(false);

                if dst[8..14] == [0, 0, 0, 0xff, 0xfe, 0] {
                    let ll = [dst[14], dst[15]];

                    if self.ll_dst_addr == Some(LlAddress::Short(ll)) {
                        0
                    } else {
                        2
                    }
                } else if is_eui_64 {
                    0
                } else {
                    8
                }
            } else {
                16
            };

            len += match (self.ecn, self.dscp, self.flow_label) {
                (Some(_), Some(_), Some(_)) => 4,
                (Some(_), None, Some(_)) => 3,
                (Some(_), Some(_), None) => 1,
                (None, None, None) => 0,
                _ => unreachable!(),
            };

            len
        }

        /// Emit a high-level representation into a 6LoWPAN IPHC header.
        pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
            let idx = 2;

            packet.set_dispatch_field();

            // FIXME(thvdveld): we don't set anything from the traffic flow.
            packet.set_tf_field(0b11);

            let idx = packet.set_next_header(self.next_header, idx);
            let idx = packet.set_hop_limit(self.hop_limit, idx);
            let idx = packet.set_src_address(self.src_addr, self.ll_src_addr, idx);
            packet.set_dst_address(self.dst_addr, self.ll_dst_addr, idx);
        }
    }

    #[cfg(test)]
    mod test {
        use super::*;

        #[test]
        fn iphc_fields() {
            let bytes = [
                0x7a, 0x33, // IPHC
                0x3a, // Next header
            ];

            let packet = Packet::new_unchecked(bytes);

            assert_eq!(packet.dispatch_field(), 0b011);
            assert_eq!(packet.tf_field(), 0b11);
            assert_eq!(packet.nh_field(), 0b0);
            assert_eq!(packet.hlim_field(), 0b10);
            assert_eq!(packet.cid_field(), 0b0);
            assert_eq!(packet.sac_field(), 0b0);
            assert_eq!(packet.sam_field(), 0b11);
            assert_eq!(packet.m_field(), 0b0);
            assert_eq!(packet.dac_field(), 0b0);
            assert_eq!(packet.dam_field(), 0b11);

            assert_eq!(
                packet.next_header(),
                NextHeader::Uncompressed(IpProtocol::Icmpv6)
            );

            assert_eq!(packet.src_address_size(), 0);
            assert_eq!(packet.dst_address_size(), 0);
            assert_eq!(packet.hop_limit(), 64);

            assert_eq!(
                packet.src_addr(),
                Ok(UnresolvedAddress::WithoutContext(AddressMode::FullyElided))
            );
            assert_eq!(
                packet.dst_addr(),
                Ok(UnresolvedAddress::WithoutContext(AddressMode::FullyElided))
            );

            let bytes = [
                0x7e, 0xf7, // IPHC,
                0x00, // CID
            ];

            let packet = Packet::new_unchecked(bytes);

            assert_eq!(packet.dispatch_field(), 0b011);
            assert_eq!(packet.tf_field(), 0b11);
            assert_eq!(packet.nh_field(), 0b1);
            assert_eq!(packet.hlim_field(), 0b10);
            assert_eq!(packet.cid_field(), 0b1);
            assert_eq!(packet.sac_field(), 0b1);
            assert_eq!(packet.sam_field(), 0b11);
            assert_eq!(packet.m_field(), 0b0);
            assert_eq!(packet.dac_field(), 0b1);
            assert_eq!(packet.dam_field(), 0b11);

            assert_eq!(packet.next_header(), NextHeader::Compressed);

            assert_eq!(packet.src_address_size(), 0);
            assert_eq!(packet.dst_address_size(), 0);
            assert_eq!(packet.hop_limit(), 64);

            assert_eq!(
                packet.src_addr(),
                Ok(UnresolvedAddress::WithContext((
                    0,
                    AddressMode::FullyElided
                )))
            );
            assert_eq!(
                packet.dst_addr(),
                Ok(UnresolvedAddress::WithContext((
                    0,
                    AddressMode::FullyElided
                )))
            );
        }
    }
}

pub mod nhc {
    //! Implementation of Next Header Compression from [RFC 6282 § 4].
    //!
    //! [RFC 6282 § 4]: https://datatracker.ietf.org/doc/html/rfc6282#section-4
    use super::{Error, NextHeader, Result, DISPATCH_EXT_HEADER, DISPATCH_UDP_HEADER};
    use crate::{
        phy::ChecksumCapabilities,
        wire::{
            ip::{checksum, Address as IpAddress},
            ipv6,
            udp::Repr as UdpRepr,
            IpProtocol,
        },
    };
    use byteorder::{ByteOrder, NetworkEndian};
    use ipv6::Address;

    macro_rules! get_field {
        ($name:ident, $mask:expr, $shift:expr) => {
            fn $name(&self) -> u8 {
                let data = self.buffer.as_ref();
                let raw = &data[0];
                ((raw >> $shift) & $mask) as u8
            }
        };
    }

    macro_rules! set_field {
        ($name:ident, $mask:expr, $shift:expr) => {
            fn $name(&mut self, val: u8) {
                let data = self.buffer.as_mut();
                let mut raw = data[0];
                raw = (raw & !($mask << $shift)) | (val << $shift);
                data[0] = raw;
            }
        };
    }

    #[derive(Debug, Clone)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    /// A read/write wrapper around a 6LoWPAN_NHC Header.
    /// [RFC 6282 § 4.2] specifies the format of the header.
    ///
    /// The header has the following format:
    /// ```txt
    ///   0   1   2   3   4   5   6   7
    /// +---+---+---+---+---+---+---+---+
    /// | 1 | 1 | 1 | 0 |    EID    |NH |
    /// +---+---+---+---+---+---+---+---+
    /// ```
    ///
    /// With:
    /// - EID: the extension header ID
    /// - NH: Next Header
    ///
    /// [RFC 6282 § 4.2]: https://datatracker.ietf.org/doc/html/rfc6282#section-4.2
    pub enum NhcPacket {
        ExtHeader,
        UdpHeader,
    }

    impl NhcPacket {
        /// Returns the type of the Next Header header.
        /// This can either be an Extenstion header or an 6LoWPAN Udp header.
        ///
        /// # Errors
        /// Returns `[Error::Unrecognized]` when neither the Extension Header dispatch or the Udp
        /// dispatch is recognized.
        pub fn dispatch(buffer: impl AsRef<[u8]>) -> Result<Self> {
            let raw = buffer.as_ref();
            if raw.is_empty() {
                return Err(Error);
            }

            if raw[0] >> 4 == DISPATCH_EXT_HEADER {
                // We have a compressed IPv6 Extension Header.
                Ok(Self::ExtHeader)
            } else if raw[0] >> 3 == DISPATCH_UDP_HEADER {
                // We have a compressed UDP header.
                Ok(Self::UdpHeader)
            } else {
                Err(Error)
            }
        }
    }

    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    pub enum ExtHeaderId {
        HopByHopHeader,
        RoutingHeader,
        FragmentHeader,
        DestinationOptionsHeader,
        MobilityHeader,
        Header,
        Reserved,
    }

    impl From<ExtHeaderId> for IpProtocol {
        fn from(val: ExtHeaderId) -> Self {
            match val {
                ExtHeaderId::HopByHopHeader => Self::HopByHop,
                ExtHeaderId::RoutingHeader => Self::Ipv6Route,
                ExtHeaderId::FragmentHeader => Self::Ipv6Frag,
                ExtHeaderId::DestinationOptionsHeader => Self::Ipv6Opts,
                ExtHeaderId::MobilityHeader => Self::Unknown(0),
                ExtHeaderId::Header => Self::Unknown(0),
                ExtHeaderId::Reserved => Self::Unknown(0),
            }
        }
    }

    /// A read/write wrapper around a 6LoWPAN NHC Extension header.
    #[derive(Debug, Clone)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    pub struct ExtHeaderPacket<T: AsRef<[u8]>> {
        buffer: T,
    }

    impl<T: AsRef<[u8]>> ExtHeaderPacket<T> {
        /// Input a raw octet buffer with a 6LoWPAN NHC Extension Header structure.
        pub const fn new_unchecked(buffer: T) -> Self {
            ExtHeaderPacket { buffer }
        }

        /// Shorthand for a combination of [new_unchecked] and [check_len].
        ///
        /// [new_unchecked]: #method.new_unchecked
        /// [check_len]: #method.check_len
        pub fn new_checked(buffer: T) -> Result<Self> {
            let packet = Self::new_unchecked(buffer);
            packet.check_len()?;

            if packet.eid_field() > 7 {
                return Err(Error);
            }

            Ok(packet)
        }

        /// Ensure that no accessor method will panic if called.
        /// Returns `Err(Error)` if the buffer is too short.
        pub fn check_len(&self) -> Result<()> {
            let buffer = self.buffer.as_ref();

            if buffer.is_empty() {
                return Err(Error);
            }

            let mut len = 1;
            len += self.next_header_size();

            if len <= buffer.len() {
                Ok(())
            } else {
                Err(Error)
            }
        }

        /// Consumes the frame, returning the underlying buffer.
        pub fn into_inner(self) -> T {
            self.buffer
        }

        get_field!(dispatch_field, 0b1111, 4);
        get_field!(eid_field, 0b111, 1);
        get_field!(nh_field, 0b1, 0);

        /// Return the Extension Header ID.
        pub fn extension_header_id(&self) -> ExtHeaderId {
            match self.eid_field() {
                0 => ExtHeaderId::HopByHopHeader,
                1 => ExtHeaderId::RoutingHeader,
                2 => ExtHeaderId::FragmentHeader,
                3 => ExtHeaderId::DestinationOptionsHeader,
                4 => ExtHeaderId::MobilityHeader,
                5 | 6 => ExtHeaderId::Reserved,
                7 => ExtHeaderId::Header,
                _ => unreachable!(),
            }
        }

        /// Parse the next header field.
        pub fn next_header(&self) -> NextHeader {
            if self.nh_field() == 1 {
                NextHeader::Compressed
            } else {
                // The full 8 bits for Next Header are carried in-line.
                let start = 1;

                let data = self.buffer.as_ref();
                let nh = data[start];
                NextHeader::Uncompressed(IpProtocol::from(nh))
            }
        }

        /// Return the size of the Next Header field.
        fn next_header_size(&self) -> usize {
            // If nh is set, then the Next Header is compressed using LOWPAN_NHC
            match self.nh_field() {
                0 => 1,
                1 => 0,
                _ => unreachable!(),
            }
        }
    }

    impl<'a, T: AsRef<[u8]> + ?Sized> ExtHeaderPacket<&'a T> {
        /// Return a pointer to the payload.
        pub fn payload(&self) -> &'a [u8] {
            let start = 2 + self.next_header_size();
            &self.buffer.as_ref()[start..]
        }
    }

    impl<T: AsRef<[u8]> + AsMut<[u8]>> ExtHeaderPacket<T> {
        /// Return a mutable pointer to the payload.
        pub fn payload_mut(&mut self) -> &mut [u8] {
            let start = 2 + self.next_header_size();
            &mut self.buffer.as_mut()[start..]
        }

        /// Set the dispatch field to `0b1110`.
        fn set_dispatch_field(&mut self) {
            let data = self.buffer.as_mut();
            data[0] = (data[0] & !(0b1111 << 4)) | (DISPATCH_EXT_HEADER << 4);
        }

        set_field!(set_eid_field, 0b111, 1);
        set_field!(set_nh_field, 0b1, 0);

        /// Set the Extension Header ID field.
        fn set_extension_header_id(&mut self, ext_header_id: ExtHeaderId) {
            let id = match ext_header_id {
                ExtHeaderId::HopByHopHeader => 0,
                ExtHeaderId::RoutingHeader => 1,
                ExtHeaderId::FragmentHeader => 2,
                ExtHeaderId::DestinationOptionsHeader => 3,
                ExtHeaderId::MobilityHeader => 4,
                ExtHeaderId::Reserved => 5,
                ExtHeaderId::Header => 7,
            };

            self.set_eid_field(id);
        }

        /// Set the Next Header.
        fn set_next_header(&mut self, next_header: NextHeader) {
            match next_header {
                NextHeader::Compressed => self.set_nh_field(0b1),
                NextHeader::Uncompressed(nh) => {
                    self.set_nh_field(0b0);

                    let start = 1;
                    let data = self.buffer.as_mut();
                    data[start] = nh.into();
                }
            }
        }

        /// Set the length.
        fn set_length(&mut self, length: u8) {
            let start = 1 + self.next_header_size();

            let data = self.buffer.as_mut();
            data[start] = length;
        }
    }

    /// A high-level representation of an 6LoWPAN NHC Extension header.
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    pub struct ExtHeaderRepr {
        ext_header_id: ExtHeaderId,
        next_header: NextHeader,
        length: u8,
    }

    impl ExtHeaderRepr {
        /// Parse a 6LoWPAN NHC Extension Header packet and return a high-level representation.
        pub fn parse<T: AsRef<[u8]> + ?Sized>(packet: &ExtHeaderPacket<&T>) -> Result<Self> {
            // Ensure basic accessors will work.
            packet.check_len()?;

            if packet.dispatch_field() != DISPATCH_EXT_HEADER {
                return Err(Error);
            }

            Ok(Self {
                ext_header_id: packet.extension_header_id(),
                next_header: packet.next_header(),
                length: packet.payload().len() as u8,
            })
        }

        /// Return the length of a header that will be emitted from this high-level representation.
        pub fn buffer_len(&self) -> usize {
            let mut len = 1; // The minimal header size

            if self.next_header != NextHeader::Compressed {
                len += 1;
            }

            len += 1; // The length

            len
        }

        /// Emit a high-level representaiton into a 6LoWPAN NHC Extension Header packet.
        pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut ExtHeaderPacket<T>) {
            packet.set_dispatch_field();
            packet.set_extension_header_id(self.ext_header_id);
            packet.set_next_header(self.next_header);
            packet.set_length(self.length);
        }
    }

    #[cfg(test)]
    mod tests {
        use super::*;

        use crate::wire::{Ipv6RoutingHeader, Ipv6RoutingRepr};

        #[cfg(feature = "proto-rpl")]
        use crate::wire::{
            Ipv6Option, Ipv6OptionRepr, Ipv6OptionsIterator, RplHopByHopRepr, RplInstanceId,
        };

        #[cfg(feature = "proto-rpl")]
        const RPL_HOP_BY_HOP_PACKET: [u8; 9] =
            [0xe0, 0x3a, 0x06, 0x63, 0x04, 0x00, 0x1e, 0x03, 0x00];

        const ROUTING_SR_PACKET: [u8; 32] = [
            0xe3, 0x1e, 0x03, 0x03, 0x99, 0x30, 0x00, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00,
            0x05, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00,
            0x02, 0x00, 0x00, 0x00,
        ];

        #[test]
        #[cfg(feature = "proto-rpl")]
        fn test_rpl_hop_by_hop_option_deconstruct() {
            let header = ExtHeaderPacket::new_checked(&RPL_HOP_BY_HOP_PACKET).unwrap();
            assert_eq!(
                header.next_header(),
                NextHeader::Uncompressed(IpProtocol::Icmpv6)
            );
            assert_eq!(header.extension_header_id(), ExtHeaderId::HopByHopHeader);

            let options = header.payload();
            let mut options = Ipv6OptionsIterator::new(options);
            let rpl_repr = options.next().unwrap();
            let rpl_repr = rpl_repr.unwrap();

            match rpl_repr {
                Ipv6OptionRepr::Rpl(rpl) => {
                    assert_eq!(
                        rpl,
                        RplHopByHopRepr {
                            down: false,
                            rank_error: false,
                            forwarding_error: false,
                            instance_id: RplInstanceId::from(0x1e),
                            sender_rank: 0x0300,
                        }
                    );
                }
                _ => unreachable!(),
            }
        }

        #[test]
        #[cfg(feature = "proto-rpl")]
        fn test_rpl_hop_by_hop_option_emit() {
            let repr = Ipv6OptionRepr::Rpl(RplHopByHopRepr {
                down: false,
                rank_error: false,
                forwarding_error: false,
                instance_id: RplInstanceId::from(0x1e),
                sender_rank: 0x0300,
            });

            let ext_hdr = ExtHeaderRepr {
                ext_header_id: ExtHeaderId::HopByHopHeader,
                next_header: NextHeader::Uncompressed(IpProtocol::Icmpv6),
                length: repr.buffer_len() as u8,
            };

            let mut buffer = vec![0u8; ext_hdr.buffer_len() + repr.buffer_len()];
            ext_hdr.emit(&mut ExtHeaderPacket::new_unchecked(
                &mut buffer[..ext_hdr.buffer_len()],
            ));
            repr.emit(&mut Ipv6Option::new_unchecked(
                &mut buffer[ext_hdr.buffer_len()..],
            ));

            assert_eq!(&buffer[..], RPL_HOP_BY_HOP_PACKET);
        }

        #[test]
        fn test_source_routing_deconstruct() {
            let header = ExtHeaderPacket::new_checked(&ROUTING_SR_PACKET).unwrap();
            assert_eq!(header.next_header(), NextHeader::Compressed);
            assert_eq!(header.extension_header_id(), ExtHeaderId::RoutingHeader);

            let routing_hdr = Ipv6RoutingHeader::new_checked(header.payload()).unwrap();
            let repr = Ipv6RoutingRepr::parse(&routing_hdr).unwrap();
            assert_eq!(
                repr,
                Ipv6RoutingRepr::Rpl {
                    segments_left: 3,
                    cmpr_i: 9,
                    cmpr_e: 9,
                    pad: 3,
                    addresses: &[
                        0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x06, 0x00, 0x06, 0x00, 0x06,
                        0x00, 0x06, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00
                    ],
                }
            );
        }

        #[test]
        fn test_source_routing_emit() {
            let routing_hdr = Ipv6RoutingRepr::Rpl {
                segments_left: 3,
                cmpr_i: 9,
                cmpr_e: 9,
                pad: 3,
                addresses: &[
                    0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00,
                    0x06, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00,
                ],
            };

            let ext_hdr = ExtHeaderRepr {
                ext_header_id: ExtHeaderId::RoutingHeader,
                next_header: NextHeader::Compressed,
                length: routing_hdr.buffer_len() as u8,
            };

            let mut buffer = vec![0u8; ext_hdr.buffer_len() + routing_hdr.buffer_len()];
            ext_hdr.emit(&mut ExtHeaderPacket::new_unchecked(
                &mut buffer[..ext_hdr.buffer_len()],
            ));
            routing_hdr.emit(&mut Ipv6RoutingHeader::new_unchecked(
                &mut buffer[ext_hdr.buffer_len()..],
            ));

            assert_eq!(&buffer[..], ROUTING_SR_PACKET);
        }
    }

    /// A read/write wrapper around a 6LoWPAN_NHC UDP frame.
    /// [RFC 6282 § 4.3] specifies the format of the header.
    ///
    /// The base header has the following formath:
    /// ```txt
    ///   0   1   2   3   4   5   6   7
    /// +---+---+---+---+---+---+---+---+
    /// | 1 | 1 | 1 | 1 | 0 | C |   P   |
    /// +---+---+---+---+---+---+---+---+
    /// With:
    /// - C: checksum, specifies if the checksum is elided.
    /// - P: ports, specifies if the ports are elided.
    /// ```
    ///
    /// [RFC 6282 § 4.3]: https://datatracker.ietf.org/doc/html/rfc6282#section-4.3
    #[derive(Debug, Clone)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    pub struct UdpNhcPacket<T: AsRef<[u8]>> {
        buffer: T,
    }

    impl<T: AsRef<[u8]>> UdpNhcPacket<T> {
        /// Input a raw octet buffer with a LOWPAN_NHC frame structure for UDP.
        pub const fn new_unchecked(buffer: T) -> Self {
            Self { buffer }
        }

        /// Shorthand for a combination of [new_unchecked] and [check_len].
        ///
        /// [new_unchecked]: #method.new_unchecked
        /// [check_len]: #method.check_len
        pub fn new_checked(buffer: T) -> Result<Self> {
            let packet = Self::new_unchecked(buffer);
            packet.check_len()?;
            Ok(packet)
        }

        /// Ensure that no accessor method will panic if called.
        /// Returns `Err(Error::Truncated)` if the buffer is too short.
        pub fn check_len(&self) -> Result<()> {
            let buffer = self.buffer.as_ref();

            if buffer.is_empty() {
                return Err(Error);
            }

            let index = 1 + self.ports_size() + self.checksum_size();
            if index > buffer.len() {
                return Err(Error);
            }

            Ok(())
        }

        /// Consumes the frame, returning the underlying buffer.
        pub fn into_inner(self) -> T {
            self.buffer
        }

        get_field!(dispatch_field, 0b11111, 3);
        get_field!(checksum_field, 0b1, 2);
        get_field!(ports_field, 0b11, 0);

        /// Returns the index of the start of the next header compressed fields.
        const fn nhc_fields_start(&self) -> usize {
            1
        }

        /// Return the source port number.
        pub fn src_port(&self) -> u16 {
            match self.ports_field() {
                0b00 | 0b01 => {
                    // The full 16 bits are carried in-line.
                    let data = self.buffer.as_ref();
                    let start = self.nhc_fields_start();

                    NetworkEndian::read_u16(&data[start..start + 2])
                }
                0b10 => {
                    // The first 8 bits are elided.
                    let data = self.buffer.as_ref();
                    let start = self.nhc_fields_start();

                    0xf000 + data[start] as u16
                }
                0b11 => {
                    // The first 12 bits are elided.
                    let data = self.buffer.as_ref();
                    let start = self.nhc_fields_start();

                    0xf0b0 + (data[start] >> 4) as u16
                }
                _ => unreachable!(),
            }
        }

        /// Return the destination port number.
        pub fn dst_port(&self) -> u16 {
            match self.ports_field() {
                0b00 => {
                    // The full 16 bits are carried in-line.
                    let data = self.buffer.as_ref();
                    let idx = self.nhc_fields_start();

                    NetworkEndian::read_u16(&data[idx + 2..idx + 4])
                }
                0b01 => {
                    // The first 8 bits are elided.
                    let data = self.buffer.as_ref();
                    let idx = self.nhc_fields_start();

                    0xf000 + data[idx] as u16
                }
                0b10 => {
                    // The full 16 bits are carried in-line.
                    let data = self.buffer.as_ref();
                    let idx = self.nhc_fields_start();

                    NetworkEndian::read_u16(&data[idx + 1..idx + 1 + 2])
                }
                0b11 => {
                    // The first 12 bits are elided.
                    let data = self.buffer.as_ref();
                    let start = self.nhc_fields_start();

                    0xf0b0 + (data[start] & 0xff) as u16
                }
                _ => unreachable!(),
            }
        }

        /// Return the checksum.
        pub fn checksum(&self) -> Option<u16> {
            if self.checksum_field() == 0b0 {
                // The first 12 bits are elided.
                let data = self.buffer.as_ref();
                let start = self.nhc_fields_start() + self.ports_size();
                Some(NetworkEndian::read_u16(&data[start..start + 2]))
            } else {
                // The checksum is elided and needs to be recomputed on the 6LoWPAN termination point.
                None
            }
        }

        // Return the size of the checksum field.
        pub(crate) fn checksum_size(&self) -> usize {
            match self.checksum_field() {
                0b0 => 2,
                0b1 => 0,
                _ => unreachable!(),
            }
        }

        /// Returns the total size of both port numbers.
        pub(crate) fn ports_size(&self) -> usize {
            match self.ports_field() {
                0b00 => 4, // 16 bits + 16 bits
                0b01 => 3, // 16 bits + 8 bits
                0b10 => 3, // 8 bits + 16 bits
                0b11 => 1, // 4 bits + 4 bits
                _ => unreachable!(),
            }
        }
    }

    impl<'a, T: AsRef<[u8]> + ?Sized> UdpNhcPacket<&'a T> {
        /// Return a pointer to the payload.
        pub fn payload(&self) -> &'a [u8] {
            let start = 1 + self.ports_size() + self.checksum_size();
            &self.buffer.as_ref()[start..]
        }
    }

    impl<T: AsRef<[u8]> + AsMut<[u8]>> UdpNhcPacket<T> {
        /// Return a mutable pointer to the payload.
        pub fn payload_mut(&mut self) -> &mut [u8] {
            let start = 1 + self.ports_size() + 2; // XXX(thvdveld): we assume we put the checksum inlined.
            &mut self.buffer.as_mut()[start..]
        }

        /// Set the dispatch field to `0b11110`.
        fn set_dispatch_field(&mut self) {
            let data = self.buffer.as_mut();
            data[0] = (data[0] & !(0b11111 << 3)) | (DISPATCH_UDP_HEADER << 3);
        }

        set_field!(set_checksum_field, 0b1, 2);
        set_field!(set_ports_field, 0b11, 0);

        fn set_ports(&mut self, src_port: u16, dst_port: u16) {
            let mut idx = 1;

            match (src_port, dst_port) {
                (0xf0b0..=0xf0bf, 0xf0b0..=0xf0bf) => {
                    // We can compress both the source and destination ports.
                    self.set_ports_field(0b11);
                    let data = self.buffer.as_mut();
                    data[idx] = (((src_port - 0xf0b0) as u8) << 4) & ((dst_port - 0xf0b0) as u8);
                }
                (0xf000..=0xf0ff, _) => {
                    // We can compress the source port, but not the destination port.
                    self.set_ports_field(0b10);
                    let data = self.buffer.as_mut();
                    data[idx] = (src_port - 0xf000) as u8;
                    idx += 1;

                    NetworkEndian::write_u16(&mut data[idx..idx + 2], dst_port);
                }
                (_, 0xf000..=0xf0ff) => {
                    // We can compress the destination port, but not the source port.
                    self.set_ports_field(0b01);
                    let data = self.buffer.as_mut();
                    NetworkEndian::write_u16(&mut data[idx..idx + 2], src_port);
                    idx += 2;
                    data[idx] = (dst_port - 0xf000) as u8;
                }
                (_, _) => {
                    // We cannot compress any port.
                    self.set_ports_field(0b00);
                    let data = self.buffer.as_mut();
                    NetworkEndian::write_u16(&mut data[idx..idx + 2], src_port);
                    idx += 2;
                    NetworkEndian::write_u16(&mut data[idx..idx + 2], dst_port);
                }
            };
        }

        fn set_checksum(&mut self, checksum: u16) {
            self.set_checksum_field(0b0);
            let idx = 1 + self.ports_size();
            let data = self.buffer.as_mut();
            NetworkEndian::write_u16(&mut data[idx..idx + 2], checksum);
        }
    }

    /// A high-level representation of a 6LoWPAN NHC UDP header.
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
    pub struct UdpNhcRepr(pub UdpRepr);

    impl<'a> UdpNhcRepr {
        /// Parse a 6LoWPAN NHC UDP packet and return a high-level representation.
        pub fn parse<T: AsRef<[u8]> + ?Sized>(
            packet: &UdpNhcPacket<&'a T>,
            src_addr: &ipv6::Address,
            dst_addr: &ipv6::Address,
            checksum_caps: &ChecksumCapabilities,
        ) -> Result<Self> {
            packet.check_len()?;

            if packet.dispatch_field() != DISPATCH_UDP_HEADER {
                return Err(Error);
            }

            if checksum_caps.udp.rx() {
                let payload_len = packet.payload().len();
                let chk_sum = !checksum::combine(&[
                    checksum::pseudo_header(
                        &IpAddress::Ipv6(*src_addr),
                        &IpAddress::Ipv6(*dst_addr),
                        crate::wire::ip::Protocol::Udp,
                        payload_len as u32 + 8,
                    ),
                    packet.src_port(),
                    packet.dst_port(),
                    payload_len as u16 + 8,
                    checksum::data(packet.payload()),
                ]);

                if let Some(checksum) = packet.checksum() {
                    if chk_sum != checksum {
                        return Err(Error);
                    }
                }
            }

            Ok(Self(UdpRepr {
                src_port: packet.src_port(),
                dst_port: packet.dst_port(),
            }))
        }

        /// Return the length of a packet that will be emitted from this high-level representation.
        pub fn header_len(&self) -> usize {
            let mut len = 1; // The minimal header size

            len += 2; // XXX We assume we will add the checksum at the end

            // Check if we can compress the source and destination ports
            match (self.src_port, self.dst_port) {
                (0xf0b0..=0xf0bf, 0xf0b0..=0xf0bf) => len + 1,
                (0xf000..=0xf0ff, _) | (_, 0xf000..=0xf0ff) => len + 3,
                (_, _) => len + 4,
            }
        }

        /// Emit a high-level representation into a LOWPAN_NHC UDP header.
        pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(
            &self,
            packet: &mut UdpNhcPacket<T>,
            src_addr: &Address,
            dst_addr: &Address,
            payload_len: usize,
            emit_payload: impl FnOnce(&mut [u8]),
        ) {
            packet.set_dispatch_field();
            packet.set_ports(self.src_port, self.dst_port);
            emit_payload(packet.payload_mut());

            let chk_sum = !checksum::combine(&[
                checksum::pseudo_header(
                    &IpAddress::Ipv6(*src_addr),
                    &IpAddress::Ipv6(*dst_addr),
                    crate::wire::ip::Protocol::Udp,
                    payload_len as u32 + 8,
                ),
                self.src_port,
                self.dst_port,
                payload_len as u16 + 8,
                checksum::data(packet.payload_mut()),
            ]);

            packet.set_checksum(chk_sum);
        }
    }

    impl core::ops::Deref for UdpNhcRepr {
        type Target = UdpRepr;

        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }

    impl core::ops::DerefMut for UdpNhcRepr {
        fn deref_mut(&mut self) -> &mut Self::Target {
            &mut self.0
        }
    }

    #[cfg(test)]
    mod test {
        use super::*;

        #[test]
        fn ext_header_nhc_fields() {
            let bytes = [0xe3, 0x06, 0x03, 0x00, 0xff, 0x00, 0x00, 0x00];

            let packet = ExtHeaderPacket::new_checked(&bytes[..]).unwrap();
            assert_eq!(packet.next_header_size(), 0);
            assert_eq!(packet.dispatch_field(), DISPATCH_EXT_HEADER);
            assert_eq!(packet.extension_header_id(), ExtHeaderId::RoutingHeader);

            assert_eq!(packet.payload(), [0x03, 0x00, 0xff, 0x00, 0x00, 0x00]);
        }

        #[test]
        fn ext_header_emit() {
            let ext_header = ExtHeaderRepr {
                ext_header_id: ExtHeaderId::RoutingHeader,
                next_header: NextHeader::Compressed,
                length: 6,
            };

            let len = ext_header.buffer_len();
            let mut buffer = [0u8; 127];
            let mut packet = ExtHeaderPacket::new_unchecked(&mut buffer[..len]);
            ext_header.emit(&mut packet);

            assert_eq!(packet.dispatch_field(), DISPATCH_EXT_HEADER);
            assert_eq!(packet.next_header(), NextHeader::Compressed);
            assert_eq!(packet.extension_header_id(), ExtHeaderId::RoutingHeader);
        }

        #[test]
        fn udp_nhc_fields() {
            let bytes = [0xf0, 0x16, 0x2e, 0x22, 0x3d, 0x28, 0xc4];

            let packet = UdpNhcPacket::new_checked(&bytes[..]).unwrap();
            assert_eq!(packet.dispatch_field(), DISPATCH_UDP_HEADER);
            assert_eq!(packet.checksum(), Some(0x28c4));
            assert_eq!(packet.src_port(), 5678);
            assert_eq!(packet.dst_port(), 8765);
        }

        #[test]
        fn udp_emit() {
            let udp = UdpNhcRepr(UdpRepr {
                src_port: 0xf0b1,
                dst_port: 0xf001,
            });

            let payload = b"Hello World!";

            let src_addr = ipv6::Address::default();
            let dst_addr = ipv6::Address::default();

            let len = udp.header_len() + payload.len();
            let mut buffer = [0u8; 127];
            let mut packet = UdpNhcPacket::new_unchecked(&mut buffer[..len]);
            udp.emit(&mut packet, &src_addr, &dst_addr, payload.len(), |buf| {
                buf.copy_from_slice(&payload[..])
            });

            assert_eq!(packet.dispatch_field(), DISPATCH_UDP_HEADER);
            assert_eq!(packet.src_port(), 0xf0b1);
            assert_eq!(packet.dst_port(), 0xf001);
            assert_eq!(packet.payload_mut(), b"Hello World!");
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn sixlowpan_fragment_emit() {
        let repr = frag::Repr::FirstFragment {
            size: 0xff,
            tag: 0xabcd,
        };
        let buffer = [0u8; 4];
        let mut packet = frag::Packet::new_unchecked(buffer);

        assert_eq!(repr.buffer_len(), 4);
        repr.emit(&mut packet);

        assert_eq!(packet.datagram_size(), 0xff);
        assert_eq!(packet.datagram_tag(), 0xabcd);
        assert_eq!(packet.into_inner(), [0xc0, 0xff, 0xab, 0xcd]);

        let repr = frag::Repr::Fragment {
            size: 0xff,
            tag: 0xabcd,
            offset: 0xcc,
        };
        let buffer = [0u8; 5];
        let mut packet = frag::Packet::new_unchecked(buffer);

        assert_eq!(repr.buffer_len(), 5);
        repr.emit(&mut packet);

        assert_eq!(packet.datagram_size(), 0xff);
        assert_eq!(packet.datagram_tag(), 0xabcd);
        assert_eq!(packet.into_inner(), [0xe0, 0xff, 0xab, 0xcd, 0xcc]);
    }

    #[test]
    fn sixlowpan_three_fragments() {
        use crate::wire::ieee802154::Frame as Ieee802154Frame;
        use crate::wire::ieee802154::Repr as Ieee802154Repr;
        use crate::wire::Ieee802154Address;

        let key = frag::Key {
            ll_src_addr: Ieee802154Address::Extended([50, 147, 130, 47, 40, 8, 62, 217]),
            ll_dst_addr: Ieee802154Address::Extended([26, 11, 66, 66, 66, 66, 66, 66]),
            datagram_size: 307,
            datagram_tag: 63,
        };

        let frame1: &[u8] = &[
            0x41, 0xcc, 0x92, 0xef, 0xbe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a, 0xd9,
            0x3e, 0x08, 0x28, 0x2f, 0x82, 0x93, 0x32, 0xc1, 0x33, 0x00, 0x3f, 0x6e, 0x33, 0x02,
            0x35, 0x3d, 0xf0, 0xd2, 0x5f, 0x1b, 0x39, 0xb4, 0x6b, 0x4c, 0x6f, 0x72, 0x65, 0x6d,
            0x20, 0x69, 0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x73,
            0x69, 0x74, 0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x65,
            0x63, 0x74, 0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64, 0x69, 0x70, 0x69, 0x73, 0x63,
            0x69, 0x6e, 0x67, 0x20, 0x65, 0x6c, 0x69, 0x74, 0x2e, 0x20, 0x41, 0x6c, 0x69, 0x71,
            0x75, 0x61, 0x6d, 0x20, 0x64, 0x75, 0x69, 0x20, 0x6f, 0x64, 0x69, 0x6f, 0x2c, 0x20,
            0x69, 0x61, 0x63, 0x75, 0x6c, 0x69, 0x73, 0x20, 0x76, 0x65, 0x6c, 0x20, 0x72,
        ];

        let ieee802154_frame = Ieee802154Frame::new_checked(frame1).unwrap();
        let ieee802154_repr = Ieee802154Repr::parse(&ieee802154_frame).unwrap();

        let sixlowpan_frame =
            SixlowpanPacket::dispatch(ieee802154_frame.payload().unwrap()).unwrap();

        let frag = if let SixlowpanPacket::FragmentHeader = sixlowpan_frame {
            frag::Packet::new_checked(ieee802154_frame.payload().unwrap()).unwrap()
        } else {
            unreachable!()
        };

        assert_eq!(frag.datagram_size(), 307);
        assert_eq!(frag.datagram_tag(), 0x003f);
        assert_eq!(frag.datagram_offset(), 0);

        assert_eq!(frag.get_key(&ieee802154_repr), key);

        let frame2: &[u8] = &[
            0x41, 0xcc, 0x93, 0xef, 0xbe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a, 0xd9,
            0x3e, 0x08, 0x28, 0x2f, 0x82, 0x93, 0x32, 0xe1, 0x33, 0x00, 0x3f, 0x11, 0x75, 0x74,
            0x72, 0x75, 0x6d, 0x20, 0x61, 0x74, 0x2c, 0x20, 0x74, 0x72, 0x69, 0x73, 0x74, 0x69,
            0x71, 0x75, 0x65, 0x20, 0x6e, 0x6f, 0x6e, 0x20, 0x6e, 0x75, 0x6e, 0x63, 0x20, 0x65,
            0x72, 0x61, 0x74, 0x20, 0x63, 0x75, 0x72, 0x61, 0x65, 0x2e, 0x20, 0x4c, 0x6f, 0x72,
            0x65, 0x6d, 0x20, 0x69, 0x70, 0x73, 0x75, 0x6d, 0x20, 0x64, 0x6f, 0x6c, 0x6f, 0x72,
            0x20, 0x73, 0x69, 0x74, 0x20, 0x61, 0x6d, 0x65, 0x74, 0x2c, 0x20, 0x63, 0x6f, 0x6e,
            0x73, 0x65, 0x63, 0x74, 0x65, 0x74, 0x75, 0x72, 0x20, 0x61, 0x64, 0x69, 0x70, 0x69,
            0x73, 0x63, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6c, 0x69, 0x74,
        ];

        let ieee802154_frame = Ieee802154Frame::new_checked(frame2).unwrap();
        let ieee802154_repr = Ieee802154Repr::parse(&ieee802154_frame).unwrap();

        let sixlowpan_frame =
            SixlowpanPacket::dispatch(ieee802154_frame.payload().unwrap()).unwrap();

        let frag = if let SixlowpanPacket::FragmentHeader = sixlowpan_frame {
            frag::Packet::new_checked(ieee802154_frame.payload().unwrap()).unwrap()
        } else {
            unreachable!()
        };

        assert_eq!(frag.datagram_size(), 307);
        assert_eq!(frag.datagram_tag(), 0x003f);
        assert_eq!(frag.datagram_offset(), 136 / 8);

        assert_eq!(frag.get_key(&ieee802154_repr), key);

        let frame3: &[u8] = &[
            0x41, 0xcc, 0x94, 0xef, 0xbe, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x0b, 0x1a, 0xd9,
            0x3e, 0x08, 0x28, 0x2f, 0x82, 0x93, 0x32, 0xe1, 0x33, 0x00, 0x3f, 0x1d, 0x2e, 0x20,
            0x41, 0x6c, 0x69, 0x71, 0x75, 0x61, 0x6d, 0x20, 0x64, 0x75, 0x69, 0x20, 0x6f, 0x64,
            0x69, 0x6f, 0x2c, 0x20, 0x69, 0x61, 0x63, 0x75, 0x6c, 0x69, 0x73, 0x20, 0x76, 0x65,
            0x6c, 0x20, 0x72, 0x75, 0x74, 0x72, 0x75, 0x6d, 0x20, 0x61, 0x74, 0x2c, 0x20, 0x74,
            0x72, 0x69, 0x73, 0x74, 0x69, 0x71, 0x75, 0x65, 0x20, 0x6e, 0x6f, 0x6e, 0x20, 0x6e,
            0x75, 0x6e, 0x63, 0x20, 0x65, 0x72, 0x61, 0x74, 0x20, 0x63, 0x75, 0x72, 0x61, 0x65,
            0x2e, 0x20, 0x0a,
        ];

        let ieee802154_frame = Ieee802154Frame::new_checked(frame3).unwrap();
        let ieee802154_repr = Ieee802154Repr::parse(&ieee802154_frame).unwrap();

        let sixlowpan_frame =
            SixlowpanPacket::dispatch(ieee802154_frame.payload().unwrap()).unwrap();

        let frag = if let SixlowpanPacket::FragmentHeader = sixlowpan_frame {
            frag::Packet::new_checked(ieee802154_frame.payload().unwrap()).unwrap()
        } else {
            unreachable!()
        };

        assert_eq!(frag.datagram_size(), 307);
        assert_eq!(frag.datagram_tag(), 0x003f);
        assert_eq!(frag.datagram_offset(), 232 / 8);

        assert_eq!(frag.get_key(&ieee802154_repr), key);
    }
}