/home/ubuntu/.cargo/registry/src/index.crates.io-6f17d22bba15001f/arrayvec-0.7.4/src/arrayvec.rs

Source (jump to first uncovered line)

use std::cmp;
use std::iter;
use std::mem;
use std::ops::{Bound, Deref, DerefMut, RangeBounds};
use std::ptr;
use std::slice;

// extra traits
use std::borrow::{Borrow, BorrowMut};
use std::hash::{Hash, Hasher};
use std::fmt;

#[cfg(feature="std")]
use std::io;

use std::mem::ManuallyDrop;
use std::mem::MaybeUninit;

#[cfg(feature="serde")]
use serde::{Serialize, Deserialize, Serializer, Deserializer};

use crate::LenUint;
use crate::errors::CapacityError;
use crate::arrayvec_impl::ArrayVecImpl;
use crate::utils::MakeMaybeUninit;

/// A vector with a fixed capacity.
///
/// The `ArrayVec` is a vector backed by a fixed size array. It keeps track of
/// the number of initialized elements. The `ArrayVec<T, CAP>` is parameterized
/// by `T` for the element type and `CAP` for the maximum capacity.
///
/// `CAP` is of type `usize` but is range limited to `u32::MAX`; attempting to create larger
/// arrayvecs with larger capacity will panic.
///
/// The vector is a contiguous value (storing the elements inline) that you can store directly on
/// the stack if needed.
///
/// It offers a simple API but also dereferences to a slice, so that the full slice API is
/// available. The ArrayVec can be converted into a by value iterator.
pub struct ArrayVec<T, const CAP: usize> {
    // the `len` first elements of the array are initialized
    xs: [MaybeUninit<T>; CAP],
    len: LenUint,
}

impl<T, const CAP: usize> Drop for ArrayVec<T, CAP> {
    fn drop(&mut self) {
        self.clear();

        // MaybeUninit inhibits array's drop
    }
}

macro_rules! panic_oob {
    ($method_name:expr, $index:expr, $len:expr) => {
        panic!(concat!("ArrayVec::", $method_name, ": index {} is out of bounds in vector of length {}"),
               $index, $len)
    }
}

impl<T, const CAP: usize> ArrayVec<T, CAP> {
    /// Capacity
    const CAPACITY: usize = CAP;

    /// Create a new empty `ArrayVec`.
    ///
    /// The maximum capacity is given by the generic parameter `CAP`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::<_, 16>::new();
    /// array.push(1);
    /// array.push(2);
    /// assert_eq!(&array[..], &[1, 2]);
    /// assert_eq!(array.capacity(), 16);
    /// ```
    #[inline]
    #[track_caller]
    pub fn new() -> ArrayVec<T, CAP> {
        assert_capacity_limit!(CAP);
        unsafe {
            ArrayVec { xs: MaybeUninit::uninit().assume_init(), len: 0 }
        }
    }

    /// Create a new empty `ArrayVec` (const fn).
    ///
    /// The maximum capacity is given by the generic parameter `CAP`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// static ARRAY: ArrayVec<u8, 1024> = ArrayVec::new_const();
    /// ```
    pub const fn new_const() -> ArrayVec<T, CAP> {
        assert_capacity_limit_const!(CAP);
        ArrayVec { xs: MakeMaybeUninit::ARRAY, len: 0 }
    }

    /// Return the number of elements in the `ArrayVec`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1, 2, 3]);
    /// array.pop();
    /// assert_eq!(array.len(), 2);
    /// ```
    #[inline(always)]
    pub const fn len(&self) -> usize { self.len as usize }

    /// Returns whether the `ArrayVec` is empty.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1]);
    /// array.pop();
    /// assert_eq!(array.is_empty(), true);
    /// ```
    #[inline]
    pub const fn is_empty(&self) -> bool { self.len() == 0 }

    /// Return the capacity of the `ArrayVec`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let array = ArrayVec::from([1, 2, 3]);
    /// assert_eq!(array.capacity(), 3);
    /// ```
    #[inline(always)]
    pub const fn capacity(&self) -> usize { CAP }

    /// Return true if the `ArrayVec` is completely filled to its capacity, false otherwise.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::<_, 1>::new();
    /// assert!(!array.is_full());
    /// array.push(1);
    /// assert!(array.is_full());
    /// ```
    pub const fn is_full(&self) -> bool { self.len() == self.capacity() }

    /// Returns the capacity left in the `ArrayVec`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1, 2, 3]);
    /// array.pop();
    /// assert_eq!(array.remaining_capacity(), 1);
    /// ```
    pub const fn remaining_capacity(&self) -> usize {
        self.capacity() - self.len()
    }

    /// Push `element` to the end of the vector.
    ///
    /// ***Panics*** if the vector is already full.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::<_, 2>::new();
    ///
    /// array.push(1);
    /// array.push(2);
    ///
    /// assert_eq!(&array[..], &[1, 2]);
    /// ```
    #[track_caller]
    pub fn push(&mut self, element: T) {
        ArrayVecImpl::push(self, element)
    }

    /// Push `element` to the end of the vector.
    ///
    /// Return `Ok` if the push succeeds, or return an error if the vector
    /// is already full.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::<_, 2>::new();
    ///
    /// let push1 = array.try_push(1);
    /// let push2 = array.try_push(2);
    ///
    /// assert!(push1.is_ok());
    /// assert!(push2.is_ok());
    ///
    /// assert_eq!(&array[..], &[1, 2]);
    ///
    /// let overflow = array.try_push(3);
    ///
    /// assert!(overflow.is_err());
    /// ```
    pub fn try_push(&mut self, element: T) -> Result<(), CapacityError<T>> {
        ArrayVecImpl::try_push(self, element)
    }

    /// Push `element` to the end of the vector without checking the capacity.
    ///
    /// It is up to the caller to ensure the capacity of the vector is
    /// sufficiently large.
    ///
    /// This method uses *debug assertions* to check that the arrayvec is not full.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::<_, 2>::new();
    ///
    /// if array.len() + 2 <= array.capacity() {
    ///     unsafe {
    ///         array.push_unchecked(1);
    ///         array.push_unchecked(2);
    ///     }
    /// }
    ///
    /// assert_eq!(&array[..], &[1, 2]);
    /// ```
    pub unsafe fn push_unchecked(&mut self, element: T) {
        ArrayVecImpl::push_unchecked(self, element)
    }

    /// Shortens the vector, keeping the first `len` elements and dropping
    /// the rest.
    ///
    /// If `len` is greater than the vector’s current length this has no
    /// effect.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1, 2, 3, 4, 5]);
    /// array.truncate(3);
    /// assert_eq!(&array[..], &[1, 2, 3]);
    /// array.truncate(4);
    /// assert_eq!(&array[..], &[1, 2, 3]);
    /// ```
    pub fn truncate(&mut self, new_len: usize) {
        ArrayVecImpl::truncate(self, new_len)
    }

    /// Remove all elements in the vector.
    pub fn clear(&mut self) {
        ArrayVecImpl::clear(self)
    }


    /// Get pointer to where element at `index` would be
    unsafe fn get_unchecked_ptr(&mut self, index: usize) -> *mut T {
        self.as_mut_ptr().add(index)
    }

    /// Insert `element` at position `index`.
    ///
    /// Shift up all elements after `index`.
    ///
    /// It is an error if the index is greater than the length or if the
    /// arrayvec is full.
    ///
    /// ***Panics*** if the array is full or the `index` is out of bounds. See
    /// `try_insert` for fallible version.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::<_, 2>::new();
    ///
    /// array.insert(0, "x");
    /// array.insert(0, "y");
    /// assert_eq!(&array[..], &["y", "x"]);
    ///
    /// ```
    #[track_caller]
    pub fn insert(&mut self, index: usize, element: T) {
        self.try_insert(index, element).unwrap()
    }

    /// Insert `element` at position `index`.
    ///
    /// Shift up all elements after `index`; the `index` must be less than
    /// or equal to the length.
    ///
    /// Returns an error if vector is already at full capacity.
    ///
    /// ***Panics*** `index` is out of bounds.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::<_, 2>::new();
    ///
    /// assert!(array.try_insert(0, "x").is_ok());
    /// assert!(array.try_insert(0, "y").is_ok());
    /// assert!(array.try_insert(0, "z").is_err());
    /// assert_eq!(&array[..], &["y", "x"]);
    ///
    /// ```
    pub fn try_insert(&mut self, index: usize, element: T) -> Result<(), CapacityError<T>> {
        if index > self.len() {
            panic_oob!("try_insert", index, self.len())
        }
        if self.len() == self.capacity() {
            return Err(CapacityError::new(element));
        }
        let len = self.len();

        // follows is just like Vec<T>
        unsafe { // infallible
            // The spot to put the new value
            {
                let p: *mut _ = self.get_unchecked_ptr(index);
                // Shift everything over to make space. (Duplicating the
                // `index`th element into two consecutive places.)
                ptr::copy(p, p.offset(1), len - index);
                // Write it in, overwriting the first copy of the `index`th
                // element.
                ptr::write(p, element);
            }
            self.set_len(len + 1);
        }
        Ok(())
    }

    /// Remove the last element in the vector and return it.
    ///
    /// Return `Some(` *element* `)` if the vector is non-empty, else `None`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::<_, 2>::new();
    ///
    /// array.push(1);
    ///
    /// assert_eq!(array.pop(), Some(1));
    /// assert_eq!(array.pop(), None);
    /// ```
    pub fn pop(&mut self) -> Option<T> {
        ArrayVecImpl::pop(self)
    }

    /// Remove the element at `index` and swap the last element into its place.
    ///
    /// This operation is O(1).
    ///
    /// Return the *element* if the index is in bounds, else panic.
    ///
    /// ***Panics*** if the `index` is out of bounds.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1, 2, 3]);
    ///
    /// assert_eq!(array.swap_remove(0), 1);
    /// assert_eq!(&array[..], &[3, 2]);
    ///
    /// assert_eq!(array.swap_remove(1), 2);
    /// assert_eq!(&array[..], &[3]);
    /// ```
    pub fn swap_remove(&mut self, index: usize) -> T {
        self.swap_pop(index)
            .unwrap_or_else(|| {
                panic_oob!("swap_remove", index, self.len())
            })
    }

    /// Remove the element at `index` and swap the last element into its place.
    ///
    /// This is a checked version of `.swap_remove`.  
    /// This operation is O(1).
    ///
    /// Return `Some(` *element* `)` if the index is in bounds, else `None`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1, 2, 3]);
    ///
    /// assert_eq!(array.swap_pop(0), Some(1));
    /// assert_eq!(&array[..], &[3, 2]);
    ///
    /// assert_eq!(array.swap_pop(10), None);
    /// ```
    pub fn swap_pop(&mut self, index: usize) -> Option<T> {
        let len = self.len();
        if index >= len {
            return None;
        }
        self.swap(index, len - 1);
        self.pop()
    }

    /// Remove the element at `index` and shift down the following elements.
    ///
    /// The `index` must be strictly less than the length of the vector.
    ///
    /// ***Panics*** if the `index` is out of bounds.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1, 2, 3]);
    ///
    /// let removed_elt = array.remove(0);
    /// assert_eq!(removed_elt, 1);
    /// assert_eq!(&array[..], &[2, 3]);
    /// ```
    pub fn remove(&mut self, index: usize) -> T {
        self.pop_at(index)
            .unwrap_or_else(|| {
                panic_oob!("remove", index, self.len())
            })
    }

    /// Remove the element at `index` and shift down the following elements.
    ///
    /// This is a checked version of `.remove(index)`. Returns `None` if there
    /// is no element at `index`. Otherwise, return the element inside `Some`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1, 2, 3]);
    ///
    /// assert!(array.pop_at(0).is_some());
    /// assert_eq!(&array[..], &[2, 3]);
    ///
    /// assert!(array.pop_at(2).is_none());
    /// assert!(array.pop_at(10).is_none());
    /// ```
    pub fn pop_at(&mut self, index: usize) -> Option<T> {
        if index >= self.len() {
            None
        } else {
            self.drain(index..index + 1).next()
        }
    }

    /// Retains only the elements specified by the predicate.
    ///
    /// In other words, remove all elements `e` such that `f(&mut e)` returns false.
    /// This method operates in place and preserves the order of the retained
    /// elements.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut array = ArrayVec::from([1, 2, 3, 4]);
    /// array.retain(|x| *x & 1 != 0 );
    /// assert_eq!(&array[..], &[1, 3]);
    /// ```
    pub fn retain<F>(&mut self, mut f: F)
        where F: FnMut(&mut T) -> bool
    {
        // Check the implementation of
        // https://doc.rust-lang.org/std/vec/struct.Vec.html#method.retain
        // for safety arguments (especially regarding panics in f and when
        // dropping elements). Implementation closely mirrored here.

        let original_len = self.len();
        unsafe { self.set_len(0) };

        struct BackshiftOnDrop<'a, T, const CAP: usize> {
            v: &'a mut ArrayVec<T, CAP>,
            processed_len: usize,
            deleted_cnt: usize,
            original_len: usize,
        }

        impl<T, const CAP: usize> Drop for BackshiftOnDrop<'_, T, CAP> {
            fn drop(&mut self) {
                if self.deleted_cnt > 0 {
                    unsafe {
                        ptr::copy(
                            self.v.as_ptr().add(self.processed_len),
                            self.v.as_mut_ptr().add(self.processed_len - self.deleted_cnt),
                            self.original_len - self.processed_len
                        );
                    }
                }
                unsafe {
                    self.v.set_len(self.original_len - self.deleted_cnt);
                }
            }
        }

        let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len };

        #[inline(always)]
        fn process_one<F: FnMut(&mut T) -> bool, T, const CAP: usize, const DELETED: bool>(
            f: &mut F,
            g: &mut BackshiftOnDrop<'_, T, CAP>
        ) -> bool {
            let cur = unsafe { g.v.as_mut_ptr().add(g.processed_len) };
            if !f(unsafe { &mut *cur }) {
                g.processed_len += 1;
                g.deleted_cnt += 1;
                unsafe { ptr::drop_in_place(cur) };
                return false;
            }
            if DELETED {
                unsafe {
                    let hole_slot = cur.sub(g.deleted_cnt);
                    ptr::copy_nonoverlapping(cur, hole_slot, 1);
                }
            }
            g.processed_len += 1;
            true
        }

        // Stage 1: Nothing was deleted.
        while g.processed_len != original_len {
            if !process_one::<F, T, CAP, false>(&mut f, &mut g) {
                break;
            }
        }

        // Stage 2: Some elements were deleted.
        while g.processed_len != original_len {
            process_one::<F, T, CAP, true>(&mut f, &mut g);
        }

        drop(g);
    }

    /// Set the vector’s length without dropping or moving out elements
    ///
    /// This method is `unsafe` because it changes the notion of the
    /// number of “valid” elements in the vector. Use with care.
    ///
    /// This method uses *debug assertions* to check that `length` is
    /// not greater than the capacity.
    pub unsafe fn set_len(&mut self, length: usize) {
        // type invariant that capacity always fits in LenUint
        debug_assert!(length <= self.capacity());
        self.len = length as LenUint;
    }

    /// Copy all elements from the slice and append to the `ArrayVec`.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut vec: ArrayVec<usize, 10> = ArrayVec::new();
    /// vec.push(1);
    /// vec.try_extend_from_slice(&[2, 3]).unwrap();
    /// assert_eq!(&vec[..], &[1, 2, 3]);
    /// ```
    ///
    /// # Errors
    ///
    /// This method will return an error if the capacity left (see
    /// [`remaining_capacity`]) is smaller then the length of the provided
    /// slice.
    ///
    /// [`remaining_capacity`]: #method.remaining_capacity
    pub fn try_extend_from_slice(&mut self, other: &[T]) -> Result<(), CapacityError>
        where T: Copy,
    {
        if self.remaining_capacity() < other.len() {
            return Err(CapacityError::new(()));
        }

        let self_len = self.len();
        let other_len = other.len();

        unsafe {
            let dst = self.get_unchecked_ptr(self_len);
            ptr::copy_nonoverlapping(other.as_ptr(), dst, other_len);
            self.set_len(self_len + other_len);
        }
        Ok(())
    }

    /// Create a draining iterator that removes the specified range in the vector
    /// and yields the removed items from start to end. The element range is
    /// removed even if the iterator is not consumed until the end.
    ///
    /// Note: It is unspecified how many elements are removed from the vector,
    /// if the `Drain` value is leaked.
    ///
    /// **Panics** if the starting point is greater than the end point or if
    /// the end point is greater than the length of the vector.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut v1 = ArrayVec::from([1, 2, 3]);
    /// let v2: ArrayVec<_, 3> = v1.drain(0..2).collect();
    /// assert_eq!(&v1[..], &[3]);
    /// assert_eq!(&v2[..], &[1, 2]);
    /// ```
    pub fn drain<R>(&mut self, range: R) -> Drain<T, CAP>
        where R: RangeBounds<usize>
    {
        // Memory safety
        //
        // When the Drain is first created, it shortens the length of
        // the source vector to make sure no uninitialized or moved-from elements
        // are accessible at all if the Drain's destructor never gets to run.
        //
        // Drain will ptr::read out the values to remove.
        // When finished, remaining tail of the vec is copied back to cover
        // the hole, and the vector length is restored to the new length.
        //
        let len = self.len();
        let start = match range.start_bound() {
            Bound::Unbounded => 0,
            Bound::Included(&i) => i,
            Bound::Excluded(&i) => i.saturating_add(1),
        };
        let end = match range.end_bound() {
            Bound::Excluded(&j) => j,
            Bound::Included(&j) => j.saturating_add(1),
            Bound::Unbounded => len,
        };
        self.drain_range(start, end)
    }

    fn drain_range(&mut self, start: usize, end: usize) -> Drain<T, CAP>
    {
        let len = self.len();

        // bounds check happens here (before length is changed!)
        let range_slice: *const _ = &self[start..end];

        // Calling `set_len` creates a fresh and thus unique mutable references, making all
        // older aliases we created invalid. So we cannot call that function.
        self.len = start as LenUint;

        unsafe {
            Drain {
                tail_start: end,
                tail_len: len - end,
                iter: (*range_slice).iter(),
                vec: self as *mut _,
            }
        }
    }

    /// Return the inner fixed size array, if it is full to its capacity.
    ///
    /// Return an `Ok` value with the array if length equals capacity,
    /// return an `Err` with self otherwise.
    pub fn into_inner(self) -> Result<[T; CAP], Self> {
        if self.len() < self.capacity() {
            Err(self)
        } else {
            unsafe { Ok(self.into_inner_unchecked()) }
        }
    }

    /// Return the inner fixed size array.
    ///
    /// Safety:
    /// This operation is safe if and only if length equals capacity.
    pub unsafe fn into_inner_unchecked(self) -> [T; CAP] {
        debug_assert_eq!(self.len(), self.capacity());
        let self_ = ManuallyDrop::new(self);
        let array = ptr::read(self_.as_ptr() as *const [T; CAP]);
        array
    }

    /// Returns the ArrayVec, replacing the original with a new empty ArrayVec.
    ///
    /// ```
    /// use arrayvec::ArrayVec;
    ///
    /// let mut v = ArrayVec::from([0, 1, 2, 3]);
    /// assert_eq!([0, 1, 2, 3], v.take().into_inner().unwrap());
    /// assert!(v.is_empty());
    /// ```
    pub fn take(&mut self) -> Self  {
        mem::replace(self, Self::new())
    }

    /// Return a slice containing all elements of the vector.
    pub fn as_slice(&self) -> &[T] {
        ArrayVecImpl::as_slice(self)
    }

    /// Return a mutable slice containing all elements of the vector.
    pub fn as_mut_slice(&mut self) -> &mut [T] {
        ArrayVecImpl::as_mut_slice(self)
    }

    /// Return a raw pointer to the vector's buffer.
    pub fn as_ptr(&self) -> *const T {
        ArrayVecImpl::as_ptr(self)
    }

    /// Return a raw mutable pointer to the vector's buffer.
    pub fn as_mut_ptr(&mut self) -> *mut T {
        ArrayVecImpl::as_mut_ptr(self)
    }
}

impl<T, const CAP: usize> ArrayVecImpl for ArrayVec<T, CAP> {
    type Item = T;
    const CAPACITY: usize = CAP;

    fn len(&self) -> usize { self.len() }

    unsafe fn set_len(&mut self, length: usize) {
        debug_assert!(length <= CAP);
        self.len = length as LenUint;
    }

    fn as_ptr(&self) -> *const Self::Item {
        self.xs.as_ptr() as _
    }

    fn as_mut_ptr(&mut self) -> *mut Self::Item {
        self.xs.as_mut_ptr() as _
    }
}

impl<T, const CAP: usize> Deref for ArrayVec<T, CAP> {
    type Target = [T];
    #[inline]
    fn deref(&self) -> &Self::Target {
        self.as_slice()
    }
}

impl<T, const CAP: usize> DerefMut for ArrayVec<T, CAP> {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.as_mut_slice()
    }
}


/// Create an `ArrayVec` from an array.
///
/// ```
/// use arrayvec::ArrayVec;
///
/// let mut array = ArrayVec::from([1, 2, 3]);
/// assert_eq!(array.len(), 3);
/// assert_eq!(array.capacity(), 3);
/// ```
impl<T, const CAP: usize> From<[T; CAP]> for ArrayVec<T, CAP> {
    #[track_caller]
    fn from(array: [T; CAP]) -> Self {
        let array = ManuallyDrop::new(array);
        let mut vec = <ArrayVec<T, CAP>>::new();
        unsafe {
            (&*array as *const [T; CAP] as *const [MaybeUninit<T>; CAP])
                .copy_to_nonoverlapping(&mut vec.xs as *mut [MaybeUninit<T>; CAP], 1);
            vec.set_len(CAP);
        }
        vec
    }
}


/// Try to create an `ArrayVec` from a slice. This will return an error if the slice was too big to
/// fit.
///
/// ```
/// use arrayvec::ArrayVec;
/// use std::convert::TryInto as _;
///
/// let array: ArrayVec<_, 4> = (&[1, 2, 3] as &[_]).try_into().unwrap();
/// assert_eq!(array.len(), 3);
/// assert_eq!(array.capacity(), 4);
/// ```
impl<T, const CAP: usize> std::convert::TryFrom<&[T]> for ArrayVec<T, CAP>
    where T: Clone,
{
    type Error = CapacityError;

    fn try_from(slice: &[T]) -> Result<Self, Self::Error> {
        if Self::CAPACITY < slice.len() {
            Err(CapacityError::new(()))
        } else {
            let mut array = Self::new();
            array.extend_from_slice(slice);
            Ok(array)
        }
    }
}


/// Iterate the `ArrayVec` with references to each element.
///
/// ```
/// use arrayvec::ArrayVec;
///
/// let array = ArrayVec::from([1, 2, 3]);
///
/// for elt in &array {
///     // ...
/// }
/// ```
impl<'a, T: 'a, const CAP: usize> IntoIterator for &'a ArrayVec<T, CAP> {
    type Item = &'a T;
    type IntoIter = slice::Iter<'a, T>;
    fn into_iter(self) -> Self::IntoIter { self.iter() }
}

/// Iterate the `ArrayVec` with mutable references to each element.
///
/// ```
/// use arrayvec::ArrayVec;
///
/// let mut array = ArrayVec::from([1, 2, 3]);
///
/// for elt in &mut array {
///     // ...
/// }
/// ```
impl<'a, T: 'a, const CAP: usize> IntoIterator for &'a mut ArrayVec<T, CAP> {
    type Item = &'a mut T;
    type IntoIter = slice::IterMut<'a, T>;
    fn into_iter(self) -> Self::IntoIter { self.iter_mut() }
}

/// Iterate the `ArrayVec` with each element by value.
///
/// The vector is consumed by this operation.
///
/// ```
/// use arrayvec::ArrayVec;
///
/// for elt in ArrayVec::from([1, 2, 3]) {
///     // ...
/// }
/// ```
impl<T, const CAP: usize> IntoIterator for ArrayVec<T, CAP> {
    type Item = T;
    type IntoIter = IntoIter<T, CAP>;
    fn into_iter(self) -> IntoIter<T, CAP> {
        IntoIter { index: 0, v: self, }
    }
}


#[cfg(feature = "zeroize")]
/// "Best efforts" zeroing of the `ArrayVec`'s buffer when the `zeroize` feature is enabled.
///
/// The length is set to 0, and the buffer is dropped and zeroized.
/// Cannot ensure that previous moves of the `ArrayVec` did not leave values on the stack.
///
/// ```
/// use arrayvec::ArrayVec;
/// use zeroize::Zeroize;
/// let mut array = ArrayVec::from([1, 2, 3]);
/// array.zeroize();
/// assert_eq!(array.len(), 0);
/// let data = unsafe { core::slice::from_raw_parts(array.as_ptr(), array.capacity()) };
/// assert_eq!(data, [0, 0, 0]);
/// ```
impl<Z: zeroize::Zeroize, const CAP: usize> zeroize::Zeroize for ArrayVec<Z, CAP> {
    fn zeroize(&mut self) {
        // Zeroize all the contained elements.
        self.iter_mut().zeroize();
        // Drop all the elements and set the length to 0.
        self.clear();
        // Zeroize the backing array.
        self.xs.zeroize();
    }
}

/// By-value iterator for `ArrayVec`.
pub struct IntoIter<T, const CAP: usize> {
    index: usize,
    v: ArrayVec<T, CAP>,
}

impl<T, const CAP: usize> Iterator for IntoIter<T, CAP> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        if self.index == self.v.len() {
            None
        } else {
            unsafe {
                let index = self.index;
                self.index = index + 1;
                Some(ptr::read(self.v.get_unchecked_ptr(index)))
            }
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.v.len() - self.index;
        (len, Some(len))
    }
}

impl<T, const CAP: usize> DoubleEndedIterator for IntoIter<T, CAP> {
    fn next_back(&mut self) -> Option<Self::Item> {
        if self.index == self.v.len() {
            None
        } else {
            unsafe {
                let new_len = self.v.len() - 1;
                self.v.set_len(new_len);
                Some(ptr::read(self.v.get_unchecked_ptr(new_len)))
            }
        }
    }
}

impl<T, const CAP: usize> ExactSizeIterator for IntoIter<T, CAP> { }

impl<T, const CAP: usize> Drop for IntoIter<T, CAP> {
    fn drop(&mut self) {
        // panic safety: Set length to 0 before dropping elements.
        let index = self.index;
        let len = self.v.len();
        unsafe {
            self.v.set_len(0);
            let elements = slice::from_raw_parts_mut(
                self.v.get_unchecked_ptr(index),
                len - index);
            ptr::drop_in_place(elements);
        }
    }
}

impl<T, const CAP: usize> Clone for IntoIter<T, CAP>
where T: Clone,
{
    fn clone(&self) -> IntoIter<T, CAP> {
        let mut v = ArrayVec::new();
        v.extend_from_slice(&self.v[self.index..]);
        v.into_iter()
    }
}

impl<T, const CAP: usize> fmt::Debug for IntoIter<T, CAP>
where
    T: fmt::Debug,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_list()
            .entries(&self.v[self.index..])
            .finish()
    }
}

/// A draining iterator for `ArrayVec`.
pub struct Drain<'a, T: 'a, const CAP: usize> {
    /// Index of tail to preserve
    tail_start: usize,
    /// Length of tail
    tail_len: usize,
    /// Current remaining range to remove
    iter: slice::Iter<'a, T>,
    vec: *mut ArrayVec<T, CAP>,
}

unsafe impl<'a, T: Sync, const CAP: usize> Sync for Drain<'a, T, CAP> {}
unsafe impl<'a, T: Send, const CAP: usize> Send for Drain<'a, T, CAP> {}

impl<'a, T: 'a, const CAP: usize> Iterator for Drain<'a, T, CAP> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(|elt|
            unsafe {
                ptr::read(elt as *const _)
            }
        )
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
}

impl<'a, T: 'a, const CAP: usize> DoubleEndedIterator for Drain<'a, T, CAP>
{
    fn next_back(&mut self) -> Option<Self::Item> {
        self.iter.next_back().map(|elt|
            unsafe {
                ptr::read(elt as *const _)
            }
        )
    }
}

impl<'a, T: 'a, const CAP: usize> ExactSizeIterator for Drain<'a, T, CAP> {}

impl<'a, T: 'a, const CAP: usize> Drop for Drain<'a, T, CAP> {
    fn drop(&mut self) {
        // len is currently 0 so panicking while dropping will not cause a double drop.

        // exhaust self first
        while let Some(_) = self.next() { }

        if self.tail_len > 0 {
            unsafe {
                let source_vec = &mut *self.vec;
                // memmove back untouched tail, update to new length
                let start = source_vec.len();
                let tail = self.tail_start;
                let ptr = source_vec.as_mut_ptr();
                ptr::copy(ptr.add(tail), ptr.add(start), self.tail_len);
                source_vec.set_len(start + self.tail_len);
            }
        }
    }
}

struct ScopeExitGuard<T, Data, F>
    where F: FnMut(&Data, &mut T)
{
    value: T,
    data: Data,
    f: F,
}

impl<T, Data, F> Drop for ScopeExitGuard<T, Data, F>
    where F: FnMut(&Data, &mut T)
{
    fn drop(&mut self) {
        (self.f)(&self.data, &mut self.value)
    }
}



/// Extend the `ArrayVec` with an iterator.
/// 
/// ***Panics*** if extending the vector exceeds its capacity.
impl<T, const CAP: usize> Extend<T> for ArrayVec<T, CAP> {
    /// Extend the `ArrayVec` with an iterator.
    /// 
    /// ***Panics*** if extending the vector exceeds its capacity.
    #[track_caller]
    fn extend<I: IntoIterator<Item=T>>(&mut self, iter: I) {
        unsafe {
            self.extend_from_iter::<_, true>(iter)
        }
    }
}

#[inline(never)]
#[cold]
#[track_caller]
fn extend_panic() {
    panic!("ArrayVec: capacity exceeded in extend/from_iter");
}

impl<T, const CAP: usize> ArrayVec<T, CAP> {
    /// Extend the arrayvec from the iterable.
    ///
    /// ## Safety
    ///
    /// Unsafe because if CHECK is false, the length of the input is not checked.
    /// The caller must ensure the length of the input fits in the capacity.
    #[track_caller]
    pub(crate) unsafe fn extend_from_iter<I, const CHECK: bool>(&mut self, iterable: I)
        where I: IntoIterator<Item = T>
    {
        let take = self.capacity() - self.len();
        let len = self.len();
        let mut ptr = raw_ptr_add(self.as_mut_ptr(), len);
        let end_ptr = raw_ptr_add(ptr, take);
        // Keep the length in a separate variable, write it back on scope
        // exit. To help the compiler with alias analysis and stuff.
        // We update the length to handle panic in the iteration of the
        // user's iterator, without dropping any elements on the floor.
        let mut guard = ScopeExitGuard {
            value: &mut self.len,
            data: len,
            f: move |&len, self_len| {
                **self_len = len as LenUint;
            }
        };
        let mut iter = iterable.into_iter();
        loop {
            if let Some(elt) = iter.next() {
                if ptr == end_ptr && CHECK { extend_panic(); }
                debug_assert_ne!(ptr, end_ptr);
                ptr.write(elt);
                ptr = raw_ptr_add(ptr, 1);
                guard.data += 1;
            } else {
                return; // success
            }
        }
    }

    /// Extend the ArrayVec with clones of elements from the slice;
    /// the length of the slice must be <= the remaining capacity in the arrayvec.
    pub(crate) fn extend_from_slice(&mut self, slice: &[T])
        where T: Clone
    {
        let take = self.capacity() - self.len();
        debug_assert!(slice.len() <= take);
        unsafe {
            let slice = if take < slice.len() { &slice[..take] } else { slice };
            self.extend_from_iter::<_, false>(slice.iter().cloned());
        }
    }
}

/// Rawptr add but uses arithmetic distance for ZST
unsafe fn raw_ptr_add<T>(ptr: *mut T, offset: usize) -> *mut T {
    if mem::size_of::<T>() == 0 {
        // Special case for ZST
        ptr.cast::<u8>().wrapping_add(offset).cast()
    } else {
        ptr.add(offset)
    }
}

/// Create an `ArrayVec` from an iterator.
/// 
/// ***Panics*** if the number of elements in the iterator exceeds the arrayvec's capacity.
impl<T, const CAP: usize> iter::FromIterator<T> for ArrayVec<T, CAP> {
    /// Create an `ArrayVec` from an iterator.
    /// 
    /// ***Panics*** if the number of elements in the iterator exceeds the arrayvec's capacity.
    fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> Self {
        let mut array = ArrayVec::new();
        array.extend(iter);
        array
    }
}

impl<T, const CAP: usize> Clone for ArrayVec<T, CAP>
    where T: Clone
{
    fn clone(&self) -> Self {
        self.iter().cloned().collect()
    }

    fn clone_from(&mut self, rhs: &Self) {
        // recursive case for the common prefix
        let prefix = cmp::min(self.len(), rhs.len());
        self[..prefix].clone_from_slice(&rhs[..prefix]);

        if prefix < self.len() {
            // rhs was shorter
            self.truncate(prefix);
        } else {
            let rhs_elems = &rhs[self.len()..];
            self.extend_from_slice(rhs_elems);
        }
    }
}

impl<T, const CAP: usize> Hash for ArrayVec<T, CAP>
    where T: Hash
{
    fn hash<H: Hasher>(&self, state: &mut H) {
        Hash::hash(&**self, state)
    }
}

impl<T, const CAP: usize> PartialEq for ArrayVec<T, CAP>
    where T: PartialEq
{
    fn eq(&self, other: &Self) -> bool {
        **self == **other
    }
}

impl<T, const CAP: usize> PartialEq<[T]> for ArrayVec<T, CAP>
    where T: PartialEq
{
    fn eq(&self, other: &[T]) -> bool {
        **self == *other
    }
}

impl<T, const CAP: usize> Eq for ArrayVec<T, CAP> where T: Eq { }

impl<T, const CAP: usize> Borrow<[T]> for ArrayVec<T, CAP> {
    fn borrow(&self) -> &[T] { self }
}

impl<T, const CAP: usize> BorrowMut<[T]> for ArrayVec<T, CAP> {
    fn borrow_mut(&mut self) -> &mut [T] { self }
}

impl<T, const CAP: usize> AsRef<[T]> for ArrayVec<T, CAP> {
    fn as_ref(&self) -> &[T] { self }
}

impl<T, const CAP: usize> AsMut<[T]> for ArrayVec<T, CAP> {
    fn as_mut(&mut self) -> &mut [T] { self }
}

impl<T, const CAP: usize> fmt::Debug for ArrayVec<T, CAP> where T: fmt::Debug {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { (**self).fmt(f) }
}

impl<T, const CAP: usize> Default for ArrayVec<T, CAP> {
    /// Return an empty array
    fn default() -> ArrayVec<T, CAP> {
        ArrayVec::new()
    }
}

impl<T, const CAP: usize> PartialOrd for ArrayVec<T, CAP> where T: PartialOrd {
    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
        (**self).partial_cmp(other)
    }

    fn lt(&self, other: &Self) -> bool {
        (**self).lt(other)
    }

    fn le(&self, other: &Self) -> bool {
        (**self).le(other)
    }

    fn ge(&self, other: &Self) -> bool {
        (**self).ge(other)
    }

    fn gt(&self, other: &Self) -> bool {
        (**self).gt(other)
    }
}

impl<T, const CAP: usize> Ord for ArrayVec<T, CAP> where T: Ord {
    fn cmp(&self, other: &Self) -> cmp::Ordering {
        (**self).cmp(other)
    }
}

#[cfg(feature="std")]
/// `Write` appends written data to the end of the vector.
///
/// Requires `features="std"`.
impl<const CAP: usize> io::Write for ArrayVec<u8, CAP> {
    fn write(&mut self, data: &[u8]) -> io::Result<usize> {
        let len = cmp::min(self.remaining_capacity(), data.len());
        let _result = self.try_extend_from_slice(&data[..len]);
        debug_assert!(_result.is_ok());
        Ok(len)
    }
    fn flush(&mut self) -> io::Result<()> { Ok(()) }
}

#[cfg(feature="serde")]
/// Requires crate feature `"serde"`
impl<T: Serialize, const CAP: usize> Serialize for ArrayVec<T, CAP> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where S: Serializer
    {
        serializer.collect_seq(self)
    }
}

#[cfg(feature="serde")]
/// Requires crate feature `"serde"`
impl<'de, T: Deserialize<'de>, const CAP: usize> Deserialize<'de> for ArrayVec<T, CAP> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where D: Deserializer<'de>
    {
        use serde::de::{Visitor, SeqAccess, Error};
        use std::marker::PhantomData;

        struct ArrayVecVisitor<'de, T: Deserialize<'de>, const CAP: usize>(PhantomData<(&'de (), [T; CAP])>);

        impl<'de, T: Deserialize<'de>, const CAP: usize> Visitor<'de> for ArrayVecVisitor<'de, T, CAP> {
            type Value = ArrayVec<T, CAP>;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                write!(formatter, "an array with no more than {} items", CAP)
            }

            fn visit_seq<SA>(self, mut seq: SA) -> Result<Self::Value, SA::Error>
                where SA: SeqAccess<'de>,
            {
                let mut values = ArrayVec::<T, CAP>::new();

                while let Some(value) = seq.next_element()? {
                    if let Err(_) = values.try_push(value) {
                        return Err(SA::Error::invalid_length(CAP + 1, &self));
                    }
                }

                Ok(values)
            }
        }

        deserializer.deserialize_seq(ArrayVecVisitor::<T, CAP>(PhantomData))
    }
}

/home/ubuntu/.cargo/registry/src/index.crates.io-6f17d22bba15001f/arrayvec-0.7.4/src/arrayvec_impl.rs

Source (jump to first uncovered line)
use std::ptr;
use std::slice;

use crate::CapacityError;

/// Implements basic arrayvec methods - based on a few required methods
/// for length and element access.
pub(crate) trait ArrayVecImpl {
    type Item;
    const CAPACITY: usize;

    fn len(&self) -> usize;

    unsafe fn set_len(&mut self, new_len: usize);

    /// Return a slice containing all elements of the vector.
    fn as_slice(&self) -> &[Self::Item] {
        let len = self.len();
        unsafe {
            slice::from_raw_parts(self.as_ptr(), len)
        }
    }

    /// Return a mutable slice containing all elements of the vector.
    fn as_mut_slice(&mut self) -> &mut [Self::Item] {
        let len = self.len();
        unsafe {
            std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
        }
    }

    /// Return a raw pointer to the vector's buffer.
    fn as_ptr(&self) -> *const Self::Item;

    /// Return a raw mutable pointer to the vector's buffer.
    fn as_mut_ptr(&mut self) -> *mut Self::Item;

    #[track_caller]
    fn push(&mut self, element: Self::Item) {
        self.try_push(element).unwrap()
    }

    fn try_push(&mut self, element: Self::Item) -> Result<(), CapacityError<Self::Item>> {
        if self.len() < Self::CAPACITY {
            unsafe {
                self.push_unchecked(element);
            }
            Ok(())
        } else {
            Err(CapacityError::new(element))
        }
    }

    unsafe fn push_unchecked(&mut self, element: Self::Item) {
        let len = self.len();
        debug_assert!(len < Self::CAPACITY);
        ptr::write(self.as_mut_ptr().add(len), element);
        self.set_len(len + 1);
    }

    fn pop(&mut self) -> Option<Self::Item> {
        if self.len() == 0 {
            return None;
        }
        unsafe {
            let new_len = self.len() - 1;
            self.set_len(new_len);
            Some(ptr::read(self.as_ptr().add(new_len)))
        }
    }

    fn clear(&mut self) {
        self.truncate(0)
    }

    fn truncate(&mut self, new_len: usize) {
        unsafe {
            let len = self.len();
            if new_len < len {
                self.set_len(new_len);
                let tail = slice::from_raw_parts_mut(self.as_mut_ptr().add(new_len), len - new_len);
                ptr::drop_in_place(tail);
            }
        }
    }
}


/home/ubuntu/.cargo/registry/src/index.crates.io-6f17d22bba15001f/arrayvec-0.7.4/src/errors.rs

Source (jump to first uncovered line)
use std::fmt;
#[cfg(feature="std")]
use std::any::Any;
#[cfg(feature="std")]
use std::error::Error;

/// Error value indicating insufficient capacity
#[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
pub struct CapacityError<T = ()> {
    element: T,
}

impl<T> CapacityError<T> {
    /// Create a new `CapacityError` from `element`.
    pub const fn new(element: T) -> CapacityError<T> {
        CapacityError {
            element: element,
        }
    }

    /// Extract the overflowing element
    pub fn element(self) -> T {
        self.element
    }

    /// Convert into a `CapacityError` that does not carry an element.
    pub fn simplify(self) -> CapacityError {
        CapacityError { element: () }
    }
}

const CAPERROR: &'static str = "insufficient capacity";

#[cfg(feature="std")]
/// Requires `features="std"`.
impl<T: Any> Error for CapacityError<T> {}

impl<T> fmt::Display for CapacityError<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", CAPERROR)
    }
}

impl<T> fmt::Debug for CapacityError<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}: {}", "CapacityError", CAPERROR)
    }
}


/home/ubuntu/.cargo/registry/src/index.crates.io-6f17d22bba15001f/libfuzzer-sys-0.4.7/src/lib.rs

Source (jump to first uncovered line)
//! Bindings to [libFuzzer](http://llvm.org/docs/LibFuzzer.html): a runtime for
//! coverage-guided fuzzing.
//!
//! See [the `cargo-fuzz`
//! guide](https://rust-fuzz.github.io/book/cargo-fuzz.html) for a usage
//! tutorial.
//!
//! The main export of this crate is [the `fuzz_target!`
//! macro](./macro.fuzz_target.html), which allows you to define targets for
//! libFuzzer to exercise.

#![deny(missing_docs, missing_debug_implementations)]

pub use arbitrary;
use once_cell::sync::OnceCell;

/// Indicates whether the input should be kept in the corpus or rejected. This
/// should be returned by your fuzz target. If your fuzz target does not return
/// a value (i.e., returns `()`), then the input will be kept in the corpus.
#[derive(Debug)]
pub enum Corpus {
    /// Keep the input in the corpus.
    Keep,

    /// Reject the input and do not keep it in the corpus.
    Reject,
}

impl From<()> for Corpus {
    fn from(_: ()) -> Self {
        Self::Keep
    }
}

impl Corpus {
    #[doc(hidden)]
    /// Convert this Corpus result into the [integer codes used by
    /// `libFuzzer`](https://llvm.org/docs/LibFuzzer.html#rejecting-unwanted-inputs).
    /// This is -1 for reject, 0 for keep.
    pub fn to_libfuzzer_code(self) -> i32 {
        match self {
            Corpus::Keep => 0,
            Corpus::Reject => -1,
        }
    }
}

extern "C" {
    // We do not actually cross the FFI bound here.
    #[allow(improper_ctypes)]
    fn rust_fuzzer_test_input(input: &[u8]) -> i32;

    fn LLVMFuzzerMutate(data: *mut u8, size: usize, max_size: usize) -> usize;
}

#[doc(hidden)]
#[export_name = "LLVMFuzzerTestOneInput"]
pub fn test_input_wrap(data: *const u8, size: usize) -> i32 {
    let test_input = ::std::panic::catch_unwind(|| unsafe {
        let data_slice = ::std::slice::from_raw_parts(data, size);
        rust_fuzzer_test_input(data_slice)
    });

    match test_input {
        Ok(i) => i,
        Err(_) => {
            // hopefully the custom panic hook will be called before and abort the
            // process before the stack frames are unwinded.
            ::std::process::abort();
        }
    }
}

#[doc(hidden)]
pub static RUST_LIBFUZZER_DEBUG_PATH: OnceCell<String> = OnceCell::new();

#[doc(hidden)]
#[export_name = "LLVMFuzzerInitialize"]
pub fn initialize(_argc: *const isize, _argv: *const *const *const u8) -> isize {
    // Registers a panic hook that aborts the process before unwinding.
    // It is useful to abort before unwinding so that the fuzzer will then be
    // able to analyse the process stack frames to tell different bugs appart.
    //
    // HACK / FIXME: it would be better to use `-C panic=abort` but it's currently
    // impossible to build code using compiler plugins with this flag.
    // We will be able to remove this code when
    // https://github.com/rust-lang/cargo/issues/5423 is fixed.
    let default_hook = ::std::panic::take_hook();
    ::std::panic::set_hook(Box::new(move |panic_info| {
        default_hook(panic_info);
        ::std::process::abort();
    }));

    // Initialize the `RUST_LIBFUZZER_DEBUG_PATH` cell with the path so it can be
    // reused with little overhead.
    if let Ok(path) = std::env::var("RUST_LIBFUZZER_DEBUG_PATH") {
        RUST_LIBFUZZER_DEBUG_PATH
            .set(path)
            .expect("Since this is initialize it is only called once so can never fail");
    }
    0
}

/// Define a fuzz target.
///
/// ## Example
///
/// This example takes a `&[u8]` slice and attempts to parse it. The parsing
/// might fail and return an `Err`, but it shouldn't ever panic or segfault.
///
/// ```no_run
/// #![no_main]
///
/// use libfuzzer_sys::fuzz_target;
///
/// // Note: `|input|` is short for `|input: &[u8]|`.
/// fuzz_target!(|input| {
///     let _result: Result<_, _> = my_crate::parse(input);
/// });
/// # mod my_crate { pub fn parse(_: &[u8]) -> Result<(), ()> { unimplemented!() } }
/// ```
///
/// ## Rejecting Inputs
///
/// It may be desirable to reject some inputs, i.e. to not add them to the
/// corpus.
///
/// For example, when fuzzing an API consisting of parsing and other logic,
/// one may want to allow only those inputs into the corpus that parse
/// successfully. To indicate whether an input should be kept in or rejected
/// from the corpus, return either [Corpus::Keep] or [Corpus::Reject] from your
/// fuzz target. The default behavior (e.g. if `()` is returned) is to keep the
/// input in the corpus.
///
/// For example:
///
/// ```no_run
/// #![no_main]
///
/// use libfuzzer_sys::{Corpus, fuzz_target};
///
/// fuzz_target!(|input: String| -> Corpus {
///     let parts: Vec<&str> = input.splitn(2, '=').collect();
///     if parts.len() != 2 {
///         return Corpus::Reject;
///     }
///
///     let key = parts[0];
///     let value = parts[1];
///     let _result: Result<_, _> = my_crate::parse(key, value);
///     Corpus::Keep
/// });
/// # mod my_crate { pub fn parse(_key: &str, _value: &str) -> Result<(), ()> { unimplemented!() } }
/// ```
///
/// ## Arbitrary Input Types
///
/// The input is a `&[u8]` slice by default, but you can take arbitrary input
/// types, as long as the type implements [the `arbitrary` crate's `Arbitrary`
/// trait](https://docs.rs/arbitrary/*/arbitrary/trait.Arbitrary.html) (which is
/// also re-exported as `libfuzzer_sys::arbitrary::Arbitrary` for convenience).
///
/// For example, if you wanted to take an arbitrary RGB color, you could do the
/// following:
///
/// ```no_run
/// #![no_main]
/// # mod foo {
///
/// use libfuzzer_sys::{arbitrary::{Arbitrary, Error, Unstructured}, fuzz_target};
///
/// #[derive(Debug)]
/// pub struct Rgb {
///     r: u8,
///     g: u8,
///     b: u8,
/// }
///
/// impl<'a> Arbitrary<'a> for Rgb {
///     fn arbitrary(raw: &mut Unstructured<'a>) -> Result<Self, Error> {
///         let mut buf = [0; 3];
///         raw.fill_buffer(&mut buf)?;
///         let r = buf[0];
///         let g = buf[1];
///         let b = buf[2];
///         Ok(Rgb { r, g, b })
///     }
/// }
///
/// // Write a fuzz target that works with RGB colors instead of raw bytes.
/// fuzz_target!(|color: Rgb| {
///     my_crate::convert_color(color);
/// });
/// # mod my_crate {
/// #     use super::Rgb;
/// #     pub fn convert_color(_: Rgb) {}
/// # }
/// # }
/// ```
///
/// You can also enable the `arbitrary` crate's custom derive via this crate's
/// `"arbitrary-derive"` cargo feature.
#[macro_export]
macro_rules! fuzz_target {
    (|$bytes:ident| $body:expr) => {
        const _: () = {
            /// Auto-generated function
            #[no_mangle]
            pub extern "C" fn rust_fuzzer_test_input(bytes: &[u8]) -> i32 {
                // When `RUST_LIBFUZZER_DEBUG_PATH` is set, write the debug
                // formatting of the input to that file. This is only intended for
                // `cargo fuzz`'s use!

                // `RUST_LIBFUZZER_DEBUG_PATH` is set in initialization.
                if let Some(path) = $crate::RUST_LIBFUZZER_DEBUG_PATH.get() {
                    use std::io::Write;
                    let mut file = std::fs::File::create(path)
                        .expect("failed to create `RUST_LIBFUZZER_DEBUG_PATH` file");
                    writeln!(&mut file, "{:?}", bytes)
                        .expect("failed to write to `RUST_LIBFUZZER_DEBUG_PATH` file");
                    return 0;
                }

                __libfuzzer_sys_run(bytes);
                0
            }

            // Split out the actual fuzzer into a separate function which is
            // tagged as never being inlined. This ensures that if the fuzzer
            // panics there's at least one stack frame which is named uniquely
            // according to this specific fuzzer that this is embedded within.
            //
            // Systems like oss-fuzz try to deduplicate crashes and without this
            // panics in separate fuzzers can accidentally appear the same
            // because each fuzzer will have a function called
            // `rust_fuzzer_test_input`. By using a normal Rust function here
            // it's named something like `the_fuzzer_name::_::__libfuzzer_sys_run` which should
            // ideally help prevent oss-fuzz from deduplicate fuzz bugs across
            // distinct targets accidentally.
            #[inline(never)]
            fn __libfuzzer_sys_run($bytes: &[u8]) {
                $body
            }
        };
    };

    (|$data:ident: &[u8]| $body:expr) => {
        $crate::fuzz_target!(|$data| $body);
    };

    (|$data:ident: $dty:ty| $body:expr) => {
        $crate::fuzz_target!(|$data: $dty| -> () { $body });
    };

    (|$data:ident: $dty:ty| -> $rty:ty $body:block) => {
        const _: () = {
            /// Auto-generated function
            #[no_mangle]
            pub extern "C" fn rust_fuzzer_test_input(bytes: &[u8]) -> i32 {
                use $crate::arbitrary::{Arbitrary, Unstructured};

                // Early exit if we don't have enough bytes for the `Arbitrary`
                // implementation. This helps the fuzzer avoid exploring all the
                // different not-enough-input-bytes paths inside the `Arbitrary`
                // implementation. Additionally, it exits faster, letting the fuzzer
                // get to longer inputs that actually lead to interesting executions
                // quicker.
                if bytes.len() < <$dty as Arbitrary>::size_hint(0).0 {
                    return -1;
                }

                let mut u = Unstructured::new(bytes);
                let data = <$dty as Arbitrary>::arbitrary_take_rest(u);

                // When `RUST_LIBFUZZER_DEBUG_PATH` is set, write the debug
                // formatting of the input to that file. This is only intended for
                // `cargo fuzz`'s use!

                // `RUST_LIBFUZZER_DEBUG_PATH` is set in initialization.
                if let Some(path) = $crate::RUST_LIBFUZZER_DEBUG_PATH.get() {
                    use std::io::Write;
                    let mut file = std::fs::File::create(path)
                        .expect("failed to create `RUST_LIBFUZZER_DEBUG_PATH` file");
                    (match data {
                        Ok(data) => writeln!(&mut file, "{:#?}", data),
                        Err(err) => writeln!(&mut file, "Arbitrary Error: {}", err),
                    })
                    .expect("failed to write to `RUST_LIBFUZZER_DEBUG_PATH` file");
                    return -1;
                }

                let data = match data {
                    Ok(d) => d,
                    Err(_) => return -1,
                };

                let result = ::libfuzzer_sys::Corpus::from(__libfuzzer_sys_run(data));
                result.to_libfuzzer_code()
            }

            // See above for why this is split to a separate function.
            #[inline(never)]
            fn __libfuzzer_sys_run($data: $dty) -> $rty {
                $body
            }
        };
    };
}

/// Define a custom mutator.
///
/// This is optional, and libFuzzer will use its own, default mutation strategy
/// if this is not provided.
///
/// You might consider using a custom mutator when your fuzz target is very
/// particular about the shape of its input:
///
/// * You want to fuzz "deeper" than just the parser.
/// * The input contains checksums that have to match the hash of some subset of
///   the data or else the whole thing is invalid, and therefore mutating any of
///   that subset means you need to recompute the checksums.
/// * Small random changes to the input buffer make it invalid.
///
/// That is, a custom mutator is useful in similar situations where [a `T:
/// Arbitrary` input type](macro.fuzz_target.html#arbitrary-input-types) is
/// useful. Note that the two approaches are not mutually exclusive; you can use
/// whichever is easier for your problem domain or both!
///
/// ## Implementation Contract
///
/// The original, unmodified input is given in `data[..size]`.
///
/// You must modify the data in place and return the new size.
///
/// The new size should not be greater than `max_size`. If this is not the case,
/// then the `data` will be truncated to fit within `max_size`. Note that
/// `max_size < size` is possible when shrinking test cases.
///
/// You must produce the same mutation given the same `seed`. Generally, when
/// choosing what kind of mutation to make or where to mutate, you should start
/// by creating a random number generator (RNG) that is seeded with the given
/// `seed` and then consult the RNG whenever making a decision:
///
/// ```no_run
/// #![no_main]
///
/// use rand::{rngs::StdRng, Rng, SeedableRng};
///
/// libfuzzer_sys::fuzz_mutator!(|data: &mut [u8], size: usize, max_size: usize, seed: u32| {
///     let mut rng = StdRng::seed_from_u64(seed as u64);
///
/// #   let first_mutation = |_, _, _, _| todo!();
/// #   let second_mutation = |_, _, _, _| todo!();
/// #   let third_mutation = |_, _, _, _| todo!();
/// #   let fourth_mutation = |_, _, _, _| todo!();
///     // Choose which of our four supported kinds of mutations we want to make.
///     match rng.gen_range(0..4) {
///         0 => first_mutation(rng, data, size, max_size),
///         1 => second_mutation(rng, data, size, max_size),
///         2 => third_mutation(rng, data, size, max_size),
///         3 => fourth_mutation(rng, data, size, max_size),
///         _ => unreachable!()
///     }
/// });
/// ```
///
/// ## Example: Compression
///
/// Consider a simple fuzz target that takes compressed data as input,
/// decompresses it, and then asserts that the decompressed data doesn't begin
/// with "boom". It is difficult for `libFuzzer` (or any other fuzzer) to crash
/// this fuzz target because nearly all mutations it makes will invalidate the
/// compression format. Therefore, we use a custom mutator that decompresses the
/// raw input, mutates the decompressed data, and then recompresses it. This
/// allows `libFuzzer` to quickly discover crashing inputs.
///
/// ```no_run
/// #![no_main]
///
/// use flate2::{read::GzDecoder, write::GzEncoder, Compression};
/// use libfuzzer_sys::{fuzz_mutator, fuzz_target};
/// use std::io::{Read, Write};
///
/// fuzz_target!(|data: &[u8]| {
///     // Decompress the input data and crash if it starts with "boom".
///     if let Some(data) = decompress(data) {
///         if data.starts_with(b"boom") {
///             panic!();
///         }
///     }
/// });
///
/// fuzz_mutator!(
///     |data: &mut [u8], size: usize, max_size: usize, _seed: u32| {
///         // Decompress the input data. If that fails, use a dummy value.
///         let mut decompressed = decompress(&data[..size]).unwrap_or_else(|| b"hi".to_vec());
///
///         // Mutate the decompressed data with `libFuzzer`'s default mutator. Make
///         // the `decompressed` vec's extra capacity available for insertion
///         // mutations via `resize`.
///         let len = decompressed.len();
///         let cap = decompressed.capacity();
///         decompressed.resize(cap, 0);
///         let new_decompressed_size = libfuzzer_sys::fuzzer_mutate(&mut decompressed, len, cap);
///
///         // Recompress the mutated data.
///         let compressed = compress(&decompressed[..new_decompressed_size]);
///
///         // Copy the recompressed mutated data into `data` and return the new size.
///         let new_size = std::cmp::min(max_size, compressed.len());
///         data[..new_size].copy_from_slice(&compressed[..new_size]);
///         new_size
///     }
/// );
///
/// fn decompress(compressed_data: &[u8]) -> Option<Vec<u8>> {
///     let mut decoder = GzDecoder::new(compressed_data);
///     let mut decompressed = Vec::new();
///     if decoder.read_to_end(&mut decompressed).is_ok() {
///         Some(decompressed)
///     } else {
///         None
///     }
/// }
///
/// fn compress(data: &[u8]) -> Vec<u8> {
///     let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
///     encoder
///         .write_all(data)
///         .expect("writing into a vec is infallible");
///     encoder.finish().expect("writing into a vec is infallible")
/// }
/// ```
///
/// This example is inspired by [a similar example from the official `libFuzzer`
/// docs](https://github.com/google/fuzzing/blob/master/docs/structure-aware-fuzzing.md#example-compression).
///
/// ## More Example Ideas
///
/// * A PNG custom mutator that decodes a PNG, mutates the image, and then
/// re-encodes the mutated image as a new PNG.
///
/// * A [`serde`](https://serde.rs/) custom mutator that deserializes your
///   structure, mutates it, and then reserializes it.
///
/// * A Wasm binary custom mutator that inserts, replaces, and removes a
///   bytecode instruction in a function's body.
///
/// * An HTTP request custom mutator that inserts, replaces, and removes a
///   header from an HTTP request.
#[macro_export]
macro_rules! fuzz_mutator {
    (
        |
        $data:ident : &mut [u8] ,
        $size:ident : usize ,
        $max_size:ident : usize ,
        $seed:ident : u32 $(,)*
        |
        $body:block
    ) => {
        /// Auto-generated function.
        #[export_name = "LLVMFuzzerCustomMutator"]
        pub fn rust_fuzzer_custom_mutator(
            $data: *mut u8,
            $size: usize,
            $max_size: usize,
            $seed: std::os::raw::c_uint,
        ) -> usize {
            // Depending on if we are growing or shrinking the test case, `size`
            // might be larger or smaller than `max_size`. The `data`'s capacity
            // is the maximum of the two.
            let len = std::cmp::max($max_size, $size);
            let $data: &mut [u8] = unsafe { std::slice::from_raw_parts_mut($data, len) };

            // `unsigned int` is generally a `u32`, but not on all targets. Do
            // an infallible (and potentially lossy, but that's okay because it
            // preserves determinism) conversion.
            let $seed = $seed as u32;

            // Truncate the new size if it is larger than the max.
            let new_size = { $body };
            std::cmp::min(new_size, $max_size)
        }
    };
}

/// The default `libFuzzer` mutator.
///
/// You generally don't have to use this at all unless you're defining a
/// custom mutator with [the `fuzz_mutator!` macro][crate::fuzz_mutator].
///
/// Mutates `data[..size]` in place such that the mutated data is no larger than
/// `max_size` and returns the new size of the mutated data.
///
/// To only allow shrinking mutations, make `max_size < size`.
///
/// To additionally allow mutations that grow the size of the data, make
/// `max_size > size`.
///
/// Both `size` and `max_size` must be less than or equal to `data.len()`.
///
/// # Example
///
/// ```no_run
/// // Create some data in a buffer.
/// let mut data = vec![0; 128];
/// data[..b"hello".len()].copy_from_slice(b"hello");
///
/// // Ask `libFuzzer` to mutate the data. By setting `max_size` to our buffer's
/// // full length, we are allowing `libFuzzer` to perform mutations that grow
/// // the size of the data, such as insertions.
/// let size = b"hello".len();
/// let max_size = data.len();
/// let new_size = libfuzzer_sys::fuzzer_mutate(&mut data, size, max_size);
///
/// // Get the mutated data out of the buffer.
/// let mutated_data = &data[..new_size];
/// ```
pub fn fuzzer_mutate(data: &mut [u8], size: usize, max_size: usize) -> usize {
    assert!(size <= data.len());
    assert!(max_size <= data.len());
    let new_size = unsafe { LLVMFuzzerMutate(data.as_mut_ptr(), size, max_size) };
    assert!(new_size <= data.len());
    new_size
}

/home/ubuntu/.cargo/registry/src/index.crates.io-6f17d22bba15001f/once_cell-1.18.0/src/imp_std.rs

Source (jump to first uncovered line)
// There's a lot of scary concurrent code in this module, but it is copied from
// `std::sync::Once` with two changes:
//   * no poisoning
//   * init function can fail

use std::{
    cell::{Cell, UnsafeCell},
    panic::{RefUnwindSafe, UnwindSafe},
    sync::atomic::{AtomicBool, AtomicPtr, Ordering},
    thread::{self, Thread},
};

#[derive(Debug)]
pub(crate) struct OnceCell<T> {
    // This `queue` field is the core of the implementation. It encodes two
    // pieces of information:
    //
    // * The current state of the cell (`INCOMPLETE`, `RUNNING`, `COMPLETE`)
    // * Linked list of threads waiting for the current cell.
    //
    // State is encoded in two low bits. Only `INCOMPLETE` and `RUNNING` states
    // allow waiters.
    queue: AtomicPtr<Waiter>,
    value: UnsafeCell<Option<T>>,
}

// Why do we need `T: Send`?
// Thread A creates a `OnceCell` and shares it with
// scoped thread B, which fills the cell, which is
// then destroyed by A. That is, destructor observes
// a sent value.
unsafe impl<T: Sync + Send> Sync for OnceCell<T> {}
unsafe impl<T: Send> Send for OnceCell<T> {}

impl<T: RefUnwindSafe + UnwindSafe> RefUnwindSafe for OnceCell<T> {}
impl<T: UnwindSafe> UnwindSafe for OnceCell<T> {}

impl<T> OnceCell<T> {
    pub(crate) const fn new() -> OnceCell<T> {
        OnceCell { queue: AtomicPtr::new(INCOMPLETE_PTR), value: UnsafeCell::new(None) }
    }

    pub(crate) const fn with_value(value: T) -> OnceCell<T> {
        OnceCell { queue: AtomicPtr::new(COMPLETE_PTR), value: UnsafeCell::new(Some(value)) }
    }

    /// Safety: synchronizes with store to value via Release/(Acquire|SeqCst).
    #[inline]
    pub(crate) fn is_initialized(&self) -> bool {
        // An `Acquire` load is enough because that makes all the initialization
        // operations visible to us, and, this being a fast path, weaker
        // ordering helps with performance. This `Acquire` synchronizes with
        // `SeqCst` operations on the slow path.
        self.queue.load(Ordering::Acquire) == COMPLETE_PTR
    }

    /// Safety: synchronizes with store to value via SeqCst read from state,
    /// writes value only once because we never get to INCOMPLETE state after a
    /// successful write.
    #[cold]
    pub(crate) fn initialize<F, E>(&self, f: F) -> Result<(), E>
    where
        F: FnOnce() -> Result<T, E>,
    {
        let mut f = Some(f);
        let mut res: Result<(), E> = Ok(());
        let slot: *mut Option<T> = self.value.get();
        initialize_or_wait(
            &self.queue,
            Some(&mut || {
                let f = unsafe { f.take().unwrap_unchecked() };
                match f() {
                    Ok(value) => {
                        unsafe { *slot = Some(value) };
                        true
                    }
                    Err(err) => {
                        res = Err(err);
                        false
                    }
                }
            }),
        );
        res
    }

    #[cold]
    pub(crate) fn wait(&self) {
        initialize_or_wait(&self.queue, None);
    }

    /// Get the reference to the underlying value, without checking if the cell
    /// is initialized.
    ///
    /// # Safety
    ///
    /// Caller must ensure that the cell is in initialized state, and that
    /// the contents are acquired by (synchronized to) this thread.
    pub(crate) unsafe fn get_unchecked(&self) -> &T {
        debug_assert!(self.is_initialized());
        let slot = &*self.value.get();
        slot.as_ref().unwrap_unchecked()
    }

    /// Gets the mutable reference to the underlying value.
    /// Returns `None` if the cell is empty.
    pub(crate) fn get_mut(&mut self) -> Option<&mut T> {
        // Safe b/c we have a unique access.
        unsafe { &mut *self.value.get() }.as_mut()
    }

    /// Consumes this `OnceCell`, returning the wrapped value.
    /// Returns `None` if the cell was empty.
    #[inline]
    pub(crate) fn into_inner(self) -> Option<T> {
        // Because `into_inner` takes `self` by value, the compiler statically
        // verifies that it is not currently borrowed.
        // So, it is safe to move out `Option<T>`.
        self.value.into_inner()
    }
}

// Three states that a OnceCell can be in, encoded into the lower bits of `queue` in
// the OnceCell structure.
const INCOMPLETE: usize = 0x0;
const RUNNING: usize = 0x1;
const COMPLETE: usize = 0x2;
const INCOMPLETE_PTR: *mut Waiter = INCOMPLETE as *mut Waiter;
const COMPLETE_PTR: *mut Waiter = COMPLETE as *mut Waiter;

// Mask to learn about the state. All other bits are the queue of waiters if
// this is in the RUNNING state.
const STATE_MASK: usize = 0x3;

/// Representation of a node in the linked list of waiters in the RUNNING state.
/// A waiters is stored on the stack of the waiting threads.
#[repr(align(4))] // Ensure the two lower bits are free to use as state bits.
struct Waiter {
    thread: Cell<Option<Thread>>,
    signaled: AtomicBool,
    next: *mut Waiter,
}

/// Drains and notifies the queue of waiters on drop.
struct Guard<'a> {
    queue: &'a AtomicPtr<Waiter>,
    new_queue: *mut Waiter,
}

impl Drop for Guard<'_> {
    fn drop(&mut self) {
        let queue = self.queue.swap(self.new_queue, Ordering::AcqRel);

        let state = strict::addr(queue) & STATE_MASK;
        assert_eq!(state, RUNNING);

        unsafe {
            let mut waiter = strict::map_addr(queue, |q| q & !STATE_MASK);
            while !waiter.is_null() {
                let next = (*waiter).next;
                let thread = (*waiter).thread.take().unwrap();
                (*waiter).signaled.store(true, Ordering::Release);
                waiter = next;
                thread.unpark();
            }
        }
    }
}

// Corresponds to `std::sync::Once::call_inner`.
//
// Originally copied from std, but since modified to remove poisoning and to
// support wait.
//
// Note: this is intentionally monomorphic
#[inline(never)]
fn initialize_or_wait(queue: &AtomicPtr<Waiter>, mut init: Option<&mut dyn FnMut() -> bool>) {
    let mut curr_queue = queue.load(Ordering::Acquire);

    loop {
        let curr_state = strict::addr(curr_queue) & STATE_MASK;
        match (curr_state, &mut init) {
            (COMPLETE, _) => return,
            (INCOMPLETE, Some(init)) => {
                let exchange = queue.compare_exchange(
                    curr_queue,
                    strict::map_addr(curr_queue, |q| (q & !STATE_MASK) | RUNNING),
                    Ordering::Acquire,
                    Ordering::Acquire,
                );
                if let Err(new_queue) = exchange {
                    curr_queue = new_queue;
                    continue;
                }
                let mut guard = Guard { queue, new_queue: INCOMPLETE_PTR };
                if init() {
                    guard.new_queue = COMPLETE_PTR;
                }
                return;
            }
            (INCOMPLETE, None) | (RUNNING, _) => {
                wait(queue, curr_queue);
                curr_queue = queue.load(Ordering::Acquire);
            }
            _ => debug_assert!(false),
        }
    }
}

fn wait(queue: &AtomicPtr<Waiter>, mut curr_queue: *mut Waiter) {
    let curr_state = strict::addr(curr_queue) & STATE_MASK;
    loop {
        let node = Waiter {
            thread: Cell::new(Some(thread::current())),
            signaled: AtomicBool::new(false),
            next: strict::map_addr(curr_queue, |q| q & !STATE_MASK),
        };
        let me = &node as *const Waiter as *mut Waiter;

        let exchange = queue.compare_exchange(
            curr_queue,
            strict::map_addr(me, |q| q | curr_state),
            Ordering::Release,
            Ordering::Relaxed,
        );
        if let Err(new_queue) = exchange {
            if strict::addr(new_queue) & STATE_MASK != curr_state {
                return;
            }
            curr_queue = new_queue;
            continue;
        }

        while !node.signaled.load(Ordering::Acquire) {
            thread::park();
        }
        break;
    }
}

// Polyfill of strict provenance from https://crates.io/crates/sptr.
//
// Use free-standing function rather than a trait to keep things simple and
// avoid any potential conflicts with future stabile std API.
mod strict {
    #[must_use]
    #[inline]
    pub(crate) fn addr<T>(ptr: *mut T) -> usize
    where
        T: Sized,
    {
        // FIXME(strict_provenance_magic): I am magic and should be a compiler intrinsic.
        // SAFETY: Pointer-to-integer transmutes are valid (if you are okay with losing the
        // provenance).
        unsafe { core::mem::transmute(ptr) }
    }

    #[must_use]
    #[inline]
    pub(crate) fn with_addr<T>(ptr: *mut T, addr: usize) -> *mut T
    where
        T: Sized,
    {
        // FIXME(strict_provenance_magic): I am magic and should be a compiler intrinsic.
        //
        // In the mean-time, this operation is defined to be "as if" it was
        // a wrapping_offset, so we can emulate it as such. This should properly
        // restore pointer provenance even under today's compiler.
        let self_addr = self::addr(ptr) as isize;
        let dest_addr = addr as isize;
        let offset = dest_addr.wrapping_sub(self_addr);

        // This is the canonical desugarring of this operation,
        // but `pointer::cast` was only stabilized in 1.38.
        // self.cast::<u8>().wrapping_offset(offset).cast::<T>()
        (ptr as *mut u8).wrapping_offset(offset) as *mut T
    }

    #[must_use]
    #[inline]
    pub(crate) fn map_addr<T>(ptr: *mut T, f: impl FnOnce(usize) -> usize) -> *mut T
    where
        T: Sized,
    {
        self::with_addr(ptr, f(addr(ptr)))
    }
}

// These test are snatched from std as well.
#[cfg(test)]
mod tests {
    use std::panic;
    use std::{sync::mpsc::channel, thread};

    use super::OnceCell;

    impl<T> OnceCell<T> {
        fn init(&self, f: impl FnOnce() -> T) {
            enum Void {}
            let _ = self.initialize(|| Ok::<T, Void>(f()));
        }
    }

    #[test]
    fn smoke_once() {
        static O: OnceCell<()> = OnceCell::new();
        let mut a = 0;
        O.init(|| a += 1);
        assert_eq!(a, 1);
        O.init(|| a += 1);
        assert_eq!(a, 1);
    }

    #[test]
    fn stampede_once() {
        static O: OnceCell<()> = OnceCell::new();
        static mut RUN: bool = false;

        let (tx, rx) = channel();
        for _ in 0..10 {
            let tx = tx.clone();
            thread::spawn(move || {
                for _ in 0..4 {
                    thread::yield_now()
                }
                unsafe {
                    O.init(|| {
                        assert!(!RUN);
                        RUN = true;
                    });
                    assert!(RUN);
                }
                tx.send(()).unwrap();
            });
        }

        unsafe {
            O.init(|| {
                assert!(!RUN);
                RUN = true;
            });
            assert!(RUN);
        }

        for _ in 0..10 {
            rx.recv().unwrap();
        }
    }

    #[test]
    fn poison_bad() {
        static O: OnceCell<()> = OnceCell::new();

        // poison the once
        let t = panic::catch_unwind(|| {
            O.init(|| panic!());
        });
        assert!(t.is_err());

        // we can subvert poisoning, however
        let mut called = false;
        O.init(|| {
            called = true;
        });
        assert!(called);

        // once any success happens, we stop propagating the poison
        O.init(|| {});
    }

    #[test]
    fn wait_for_force_to_finish() {
        static O: OnceCell<()> = OnceCell::new();

        // poison the once
        let t = panic::catch_unwind(|| {
            O.init(|| panic!());
        });
        assert!(t.is_err());

        // make sure someone's waiting inside the once via a force
        let (tx1, rx1) = channel();
        let (tx2, rx2) = channel();
        let t1 = thread::spawn(move || {
            O.init(|| {
                tx1.send(()).unwrap();
                rx2.recv().unwrap();
            });
        });

        rx1.recv().unwrap();

        // put another waiter on the once
        let t2 = thread::spawn(|| {
            let mut called = false;
            O.init(|| {
                called = true;
            });
            assert!(!called);
        });

        tx2.send(()).unwrap();

        assert!(t1.join().is_ok());
        assert!(t2.join().is_ok());
    }

    #[test]
    #[cfg(target_pointer_width = "64")]
    fn test_size() {
        use std::mem::size_of;

        assert_eq!(size_of::<OnceCell<u32>>(), 4 * size_of::<u32>());
    }
}

/home/ubuntu/.cargo/registry/src/index.crates.io-6f17d22bba15001f/once_cell-1.18.0/src/lib.rs

Source (jump to first uncovered line)
//! # Overview
//!
//! `once_cell` provides two new cell-like types, [`unsync::OnceCell`] and
//! [`sync::OnceCell`]. A `OnceCell` might store arbitrary non-`Copy` types, can
//! be assigned to at most once and provides direct access to the stored
//! contents. The core API looks *roughly* like this (and there's much more
//! inside, read on!):
//!
//! ```rust,ignore
//! impl<T> OnceCell<T> {
//!     const fn new() -> OnceCell<T> { ... }
//!     fn set(&self, value: T) -> Result<(), T> { ... }
//!     fn get(&self) -> Option<&T> { ... }
//! }
//! ```
//!
//! Note that, like with [`RefCell`] and [`Mutex`], the `set` method requires
//! only a shared reference. Because of the single assignment restriction `get`
//! can return a `&T` instead of `Ref<T>` or `MutexGuard<T>`.
//!
//! The `sync` flavor is thread-safe (that is, implements the [`Sync`] trait),
//! while the `unsync` one is not.
//!
//! [`unsync::OnceCell`]: unsync/struct.OnceCell.html
//! [`sync::OnceCell`]: sync/struct.OnceCell.html
//! [`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html
//! [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html
//! [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
//!
//! # Recipes
//!
//! `OnceCell` might be useful for a variety of patterns.
//!
//! ## Safe Initialization of Global Data
//!
//! ```rust
//! use std::{env, io};
//!
//! use once_cell::sync::OnceCell;
//!
//! #[derive(Debug)]
//! pub struct Logger {
//!     // ...
//! }
//! static INSTANCE: OnceCell<Logger> = OnceCell::new();
//!
//! impl Logger {
//!     pub fn global() -> &'static Logger {
//!         INSTANCE.get().expect("logger is not initialized")
//!     }
//!
//!     fn from_cli(args: env::Args) -> Result<Logger, std::io::Error> {
//!        // ...
//! #      Ok(Logger {})
//!     }
//! }
//!
//! fn main() {
//!     let logger = Logger::from_cli(env::args()).unwrap();
//!     INSTANCE.set(logger).unwrap();
//!     // use `Logger::global()` from now on
//! }
//! ```
//!
//! ## Lazy Initialized Global Data
//!
//! This is essentially the `lazy_static!` macro, but without a macro.
//!
//! ```rust
//! use std::{sync::Mutex, collections::HashMap};
//!
//! use once_cell::sync::OnceCell;
//!
//! fn global_data() -> &'static Mutex<HashMap<i32, String>> {
//!     static INSTANCE: OnceCell<Mutex<HashMap<i32, String>>> = OnceCell::new();
//!     INSTANCE.get_or_init(|| {
//!         let mut m = HashMap::new();
//!         m.insert(13, "Spica".to_string());
//!         m.insert(74, "Hoyten".to_string());
//!         Mutex::new(m)
//!     })
//! }
//! ```
//!
//! There are also the [`sync::Lazy`] and [`unsync::Lazy`] convenience types to
//! streamline this pattern:
//!
//! ```rust
//! use std::{sync::Mutex, collections::HashMap};
//! use once_cell::sync::Lazy;
//!
//! static GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| {
//!     let mut m = HashMap::new();
//!     m.insert(13, "Spica".to_string());
//!     m.insert(74, "Hoyten".to_string());
//!     Mutex::new(m)
//! });
//!
//! fn main() {
//!     println!("{:?}", GLOBAL_DATA.lock().unwrap());
//! }
//! ```
//!
//! Note that the variable that holds `Lazy` is declared as `static`, *not*
//! `const`. This is important: using `const` instead compiles, but works wrong.
//!
//! [`sync::Lazy`]: sync/struct.Lazy.html
//! [`unsync::Lazy`]: unsync/struct.Lazy.html
//!
//! ## General purpose lazy evaluation
//!
//! Unlike `lazy_static!`, `Lazy` works with local variables.
//!
//! ```rust
//! use once_cell::unsync::Lazy;
//!
//! fn main() {
//!     let ctx = vec![1, 2, 3];
//!     let thunk = Lazy::new(|| {
//!         ctx.iter().sum::<i32>()
//!     });
//!     assert_eq!(*thunk, 6);
//! }
//! ```
//!
//! If you need a lazy field in a struct, you probably should use `OnceCell`
//! directly, because that will allow you to access `self` during
//! initialization.
//!
//! ```rust
//! use std::{fs, path::PathBuf};
//!
//! use once_cell::unsync::OnceCell;
//!
//! struct Ctx {
//!     config_path: PathBuf,
//!     config: OnceCell<String>,
//! }
//!
//! impl Ctx {
//!     pub fn get_config(&self) -> Result<&str, std::io::Error> {
//!         let cfg = self.config.get_or_try_init(|| {
//!             fs::read_to_string(&self.config_path)
//!         })?;
//!         Ok(cfg.as_str())
//!     }
//! }
//! ```
//!
//! ## Lazily Compiled Regex
//!
//! This is a `regex!` macro which takes a string literal and returns an
//! *expression* that evaluates to a `&'static Regex`:
//!
//! ```
//! macro_rules! regex {
//!     ($re:literal $(,)?) => {{
//!         static RE: once_cell::sync::OnceCell<regex::Regex> = once_cell::sync::OnceCell::new();
//!         RE.get_or_init(|| regex::Regex::new($re).unwrap())
//!     }};
//! }
//! ```
//!
//! This macro can be useful to avoid the "compile regex on every loop
//! iteration" problem.
//!
//! ## Runtime `include_bytes!`
//!
//! The `include_bytes` macro is useful to include test resources, but it slows
//! down test compilation a lot. An alternative is to load the resources at
//! runtime:
//!
//! ```
//! use std::path::Path;
//!
//! use once_cell::sync::OnceCell;
//!
//! pub struct TestResource {
//!     path: &'static str,
//!     cell: OnceCell<Vec<u8>>,
//! }
//!
//! impl TestResource {
//!     pub const fn new(path: &'static str) -> TestResource {
//!         TestResource { path, cell: OnceCell::new() }
//!     }
//!     pub fn bytes(&self) -> &[u8] {
//!         self.cell.get_or_init(|| {
//!             let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
//!             let path = Path::new(dir.as_str()).join(self.path);
//!             std::fs::read(&path).unwrap_or_else(|_err| {
//!                 panic!("failed to load test resource: {}", path.display())
//!             })
//!         }).as_slice()
//!     }
//! }
//!
//! static TEST_IMAGE: TestResource = TestResource::new("test_data/lena.png");
//!
//! #[test]
//! fn test_sobel_filter() {
//!     let rgb: &[u8] = TEST_IMAGE.bytes();
//!     // ...
//! # drop(rgb);
//! }
//! ```
//!
//! ## `lateinit`
//!
//! `LateInit` type for delayed initialization. It is reminiscent of Kotlin's
//! `lateinit` keyword and allows construction of cyclic data structures:
//!
//!
//! ```
//! use once_cell::sync::OnceCell;
//!
//! pub struct LateInit<T> { cell: OnceCell<T> }
//!
//! impl<T> LateInit<T> {
//!     pub fn init(&self, value: T) {
//!         assert!(self.cell.set(value).is_ok())
//!     }
//! }
//!
//! impl<T> Default for LateInit<T> {
//!     fn default() -> Self { LateInit { cell: OnceCell::default() } }
//! }
//!
//! impl<T> std::ops::Deref for LateInit<T> {
//!     type Target = T;
//!     fn deref(&self) -> &T {
//!         self.cell.get().unwrap()
//!     }
//! }
//!
//! #[derive(Default)]
//! struct A<'a> {
//!     b: LateInit<&'a B<'a>>,
//! }
//!
//! #[derive(Default)]
//! struct B<'a> {
//!     a: LateInit<&'a A<'a>>
//! }
//!
//!
//! fn build_cycle() {
//!     let a = A::default();
//!     let b = B::default();
//!     a.b.init(&b);
//!     b.a.init(&a);
//!
//!     let _a = &a.b.a.b.a;
//! }
//! ```
//!
//! # Comparison with std
//!
//! |`!Sync` types         | Access Mode            | Drawbacks                                     |
//! |----------------------|------------------------|-----------------------------------------------|
//! |`Cell<T>`             | `T`                    | requires `T: Copy` for `get`                  |
//! |`RefCell<T>`          | `RefMut<T>` / `Ref<T>` | may panic at runtime                          |
//! |`unsync::OnceCell<T>` | `&T`                   | assignable only once                          |
//!
//! |`Sync` types          | Access Mode            | Drawbacks                                     |
//! |----------------------|------------------------|-----------------------------------------------|
//! |`AtomicT`             | `T`                    | works only with certain `Copy` types          |
//! |`Mutex<T>`            | `MutexGuard<T>`        | may deadlock at runtime, may block the thread |
//! |`sync::OnceCell<T>`   | `&T`                   | assignable only once, may block the thread    |
//!
//! Technically, calling `get_or_init` will also cause a panic or a deadlock if
//! it recursively calls itself. However, because the assignment can happen only
//! once, such cases should be more rare than equivalents with `RefCell` and
//! `Mutex`.
//!
//! # Minimum Supported `rustc` Version
//!
//! This crate's minimum supported `rustc` version is `1.56.0`.
//!
//! If only the `std` feature is enabled, MSRV will be updated conservatively,
//! supporting at least latest 8 versions of the compiler. When using other
//! features, like `parking_lot`, MSRV might be updated more frequently, up to
//! the latest stable. In both cases, increasing MSRV is *not* considered a
//! semver-breaking change.
//!
//! # Implementation details
//!
//! The implementation is based on the
//! [`lazy_static`](https://github.com/rust-lang-nursery/lazy-static.rs/) and
//! [`lazy_cell`](https://github.com/indiv0/lazycell/) crates and
//! [`std::sync::Once`]. In some sense, `once_cell` just streamlines and unifies
//! those APIs.
//!
//! To implement a sync flavor of `OnceCell`, this crates uses either a custom
//! re-implementation of `std::sync::Once` or `parking_lot::Mutex`. This is
//! controlled by the `parking_lot` feature (disabled by default). Performance
//! is the same for both cases, but the `parking_lot` based `OnceCell<T>` is
//! smaller by up to 16 bytes.
//!
//! This crate uses `unsafe`.
//!
//! [`std::sync::Once`]: https://doc.rust-lang.org/std/sync/struct.Once.html
//!
//! # F.A.Q.
//!
//! **Should I use the sync or unsync flavor?**
//!
//! Because Rust compiler checks thread safety for you, it's impossible to
//! accidentally use `unsync` where `sync` is required. So, use `unsync` in
//! single-threaded code and `sync` in multi-threaded. It's easy to switch
//! between the two if code becomes multi-threaded later.
//!
//! At the moment, `unsync` has an additional benefit that reentrant
//! initialization causes a panic, which might be easier to debug than a
//! deadlock.
//!
//! **Does this crate support async?**
//!
//! No, but you can use
//! [`async_once_cell`](https://crates.io/crates/async_once_cell) instead.
//!
//! **Does this crate support `no_std`?**
//!
//! Yes, but with caveats. `OnceCell` is a synchronization primitive which
//! _semantically_ relies on blocking. `OnceCell` guarantees that at most one
//! `f` will be called to compute the value. If two threads of execution call
//! `get_or_init` concurrently, one of them has to wait.
//!
//! Waiting fundamentally requires OS support. Execution environment needs to
//! understand who waits on whom to prevent deadlocks due to priority inversion.
//! You _could_ make code to compile by blindly using pure spinlocks, but the
//! runtime behavior would be subtly wrong.
//!
//! Given these constraints, `once_cell` provides the following options:
//!
//! - The `race` module provides similar, but distinct synchronization primitive
//!   which is compatible with `no_std`. With `race`, the `f` function can be
//!   called multiple times by different threads, but only one thread will win
//!   to install the value.
//! - `critical-section` feature (with a `-`, not `_`) uses `critical_section`
//!   to implement blocking.
//!
//! **Can I bring my own mutex?**
//!
//! There is [generic_once_cell](https://crates.io/crates/generic_once_cell) to
//! allow just that.
//!
//! **Should I use `std::cell::OnceCell`, `once_cell`, or `lazy_static`?**
//!
//! If you can use `std` version (your MSRV is at least 1.70, and you don't need
//! extra features `once_cell` provides), use `std`. Otherwise, use `once_cell`.
//! Don't use `lazy_static`.
//!
//! # Related crates
//!
//! * Most of this crate's functionality is available in `std` starting with
//!   Rust 1.70. See `std::cell::OnceCell` and `std::sync::OnceLock`.
//! * [double-checked-cell](https://github.com/niklasf/double-checked-cell)
//! * [lazy-init](https://crates.io/crates/lazy-init)
//! * [lazycell](https://crates.io/crates/lazycell)
//! * [mitochondria](https://crates.io/crates/mitochondria)
//! * [lazy_static](https://crates.io/crates/lazy_static)
//! * [async_once_cell](https://crates.io/crates/async_once_cell)
//! * [generic_once_cell](https://crates.io/crates/generic_once_cell) (bring
//!   your own mutex)

#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(feature = "alloc")]
extern crate alloc;

#[cfg(all(feature = "critical-section", not(feature = "std")))]
#[path = "imp_cs.rs"]
mod imp;

#[cfg(all(feature = "std", feature = "parking_lot"))]
#[path = "imp_pl.rs"]
mod imp;

#[cfg(all(feature = "std", not(feature = "parking_lot")))]
#[path = "imp_std.rs"]
mod imp;

/// Single-threaded version of `OnceCell`.
pub mod unsync {
    use core::{
        cell::{Cell, UnsafeCell},
        fmt, mem,
        ops::{Deref, DerefMut},
        panic::{RefUnwindSafe, UnwindSafe},
    };

    /// A cell which can be written to only once. It is not thread safe.
    ///
    /// Unlike [`std::cell::RefCell`], a `OnceCell` provides simple `&`
    /// references to the contents.
    ///
    /// [`std::cell::RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html
    ///
    /// # Example
    /// ```
    /// use once_cell::unsync::OnceCell;
    ///
    /// let cell = OnceCell::new();
    /// assert!(cell.get().is_none());
    ///
    /// let value: &String = cell.get_or_init(|| {
    ///     "Hello, World!".to_string()
    /// });
    /// assert_eq!(value, "Hello, World!");
    /// assert!(cell.get().is_some());
    /// ```
    pub struct OnceCell<T> {
        // Invariant: written to at most once.
        inner: UnsafeCell<Option<T>>,
    }

    // Similarly to a `Sync` bound on `sync::OnceCell`, we can use
    // `&unsync::OnceCell` to sneak a `T` through `catch_unwind`,
    // by initializing the cell in closure and extracting the value in the
    // `Drop`.
    impl<T: RefUnwindSafe + UnwindSafe> RefUnwindSafe for OnceCell<T> {}
    impl<T: UnwindSafe> UnwindSafe for OnceCell<T> {}

    impl<T> Default for OnceCell<T> {
        fn default() -> Self {
            Self::new()
        }
    }

    impl<T: fmt::Debug> fmt::Debug for OnceCell<T> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self.get() {
                Some(v) => f.debug_tuple("OnceCell").field(v).finish(),
                None => f.write_str("OnceCell(Uninit)"),
            }
        }
    }

    impl<T: Clone> Clone for OnceCell<T> {
        fn clone(&self) -> OnceCell<T> {
            match self.get() {
                Some(value) => OnceCell::with_value(value.clone()),
                None => OnceCell::new(),
            }
        }

        fn clone_from(&mut self, source: &Self) {
            match (self.get_mut(), source.get()) {
                (Some(this), Some(source)) => this.clone_from(source),
                _ => *self = source.clone(),
            }
        }
    }

    impl<T: PartialEq> PartialEq for OnceCell<T> {
        fn eq(&self, other: &Self) -> bool {
            self.get() == other.get()
        }
    }

    impl<T: Eq> Eq for OnceCell<T> {}

    impl<T> From<T> for OnceCell<T> {
        fn from(value: T) -> Self {
            OnceCell::with_value(value)
        }
    }

    impl<T> OnceCell<T> {
        /// Creates a new empty cell.
        pub const fn new() -> OnceCell<T> {
            OnceCell { inner: UnsafeCell::new(None) }
        }

        /// Creates a new initialized cell.
        pub const fn with_value(value: T) -> OnceCell<T> {
            OnceCell { inner: UnsafeCell::new(Some(value)) }
        }

        /// Gets a reference to the underlying value.
        ///
        /// Returns `None` if the cell is empty.
        #[inline]
        pub fn get(&self) -> Option<&T> {
            // Safe due to `inner`'s invariant of being written to at most once.
            // Had multiple writes to `inner` been allowed, a reference to the
            // value we return now would become dangling by a write of a
            // different value later.
            unsafe { &*self.inner.get() }.as_ref()
        }

        /// Gets a mutable reference to the underlying value.
        ///
        /// Returns `None` if the cell is empty.
        ///
        /// This method is allowed to violate the invariant of writing to a `OnceCell`
        /// at most once because it requires `&mut` access to `self`. As with all
        /// interior mutability, `&mut` access permits arbitrary modification:
        ///
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let mut cell: OnceCell<u32> = OnceCell::new();
        /// cell.set(92).unwrap();
        /// *cell.get_mut().unwrap() = 93;
        /// assert_eq!(cell.get(), Some(&93));
        /// ```
        #[inline]
        pub fn get_mut(&mut self) -> Option<&mut T> {
            // Safe because we have unique access
            unsafe { &mut *self.inner.get() }.as_mut()
        }

        /// Sets the contents of this cell to `value`.
        ///
        /// Returns `Ok(())` if the cell was empty and `Err(value)` if it was
        /// full.
        ///
        /// # Example
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let cell = OnceCell::new();
        /// assert!(cell.get().is_none());
        ///
        /// assert_eq!(cell.set(92), Ok(()));
        /// assert_eq!(cell.set(62), Err(62));
        ///
        /// assert!(cell.get().is_some());
        /// ```
        pub fn set(&self, value: T) -> Result<(), T> {
            match self.try_insert(value) {
                Ok(_) => Ok(()),
                Err((_, value)) => Err(value),
            }
        }

        /// Like [`set`](Self::set), but also returns a reference to the final cell value.
        ///
        /// # Example
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let cell = OnceCell::new();
        /// assert!(cell.get().is_none());
        ///
        /// assert_eq!(cell.try_insert(92), Ok(&92));
        /// assert_eq!(cell.try_insert(62), Err((&92, 62)));
        ///
        /// assert!(cell.get().is_some());
        /// ```
        pub fn try_insert(&self, value: T) -> Result<&T, (&T, T)> {
            if let Some(old) = self.get() {
                return Err((old, value));
            }

            let slot = unsafe { &mut *self.inner.get() };
            // This is the only place where we set the slot, no races
            // due to reentrancy/concurrency are possible, and we've
            // checked that slot is currently `None`, so this write
            // maintains the `inner`'s invariant.
            *slot = Some(value);
            Ok(unsafe { slot.as_ref().unwrap_unchecked() })
        }

        /// Gets the contents of the cell, initializing it with `f`
        /// if the cell was empty.
        ///
        /// # Panics
        ///
        /// If `f` panics, the panic is propagated to the caller, and the cell
        /// remains uninitialized.
        ///
        /// It is an error to reentrantly initialize the cell from `f`. Doing
        /// so results in a panic.
        ///
        /// # Example
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let cell = OnceCell::new();
        /// let value = cell.get_or_init(|| 92);
        /// assert_eq!(value, &92);
        /// let value = cell.get_or_init(|| unreachable!());
        /// assert_eq!(value, &92);
        /// ```
        pub fn get_or_init<F>(&self, f: F) -> &T
        where
            F: FnOnce() -> T,
        {
            enum Void {}
            match self.get_or_try_init(|| Ok::<T, Void>(f())) {
                Ok(val) => val,
                Err(void) => match void {},
            }
        }

        /// Gets the contents of the cell, initializing it with `f` if
        /// the cell was empty. If the cell was empty and `f` failed, an
        /// error is returned.
        ///
        /// # Panics
        ///
        /// If `f` panics, the panic is propagated to the caller, and the cell
        /// remains uninitialized.
        ///
        /// It is an error to reentrantly initialize the cell from `f`. Doing
        /// so results in a panic.
        ///
        /// # Example
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let cell = OnceCell::new();
        /// assert_eq!(cell.get_or_try_init(|| Err(())), Err(()));
        /// assert!(cell.get().is_none());
        /// let value = cell.get_or_try_init(|| -> Result<i32, ()> {
        ///     Ok(92)
        /// });
        /// assert_eq!(value, Ok(&92));
        /// assert_eq!(cell.get(), Some(&92))
        /// ```
        pub fn get_or_try_init<F, E>(&self, f: F) -> Result<&T, E>
        where
            F: FnOnce() -> Result<T, E>,
        {
            if let Some(val) = self.get() {
                return Ok(val);
            }
            let val = f()?;
            // Note that *some* forms of reentrant initialization might lead to
            // UB (see `reentrant_init` test). I believe that just removing this
            // `assert`, while keeping `set/get` would be sound, but it seems
            // better to panic, rather than to silently use an old value.
            assert!(self.set(val).is_ok(), "reentrant init");
            Ok(unsafe { self.get().unwrap_unchecked() })
        }

        /// Takes the value out of this `OnceCell`, moving it back to an uninitialized state.
        ///
        /// Has no effect and returns `None` if the `OnceCell` hasn't been initialized.
        ///
        /// # Examples
        ///
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let mut cell: OnceCell<String> = OnceCell::new();
        /// assert_eq!(cell.take(), None);
        ///
        /// let mut cell = OnceCell::new();
        /// cell.set("hello".to_string()).unwrap();
        /// assert_eq!(cell.take(), Some("hello".to_string()));
        /// assert_eq!(cell.get(), None);
        /// ```
        ///
        /// This method is allowed to violate the invariant of writing to a `OnceCell`
        /// at most once because it requires `&mut` access to `self`. As with all
        /// interior mutability, `&mut` access permits arbitrary modification:
        ///
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let mut cell: OnceCell<u32> = OnceCell::new();
        /// cell.set(92).unwrap();
        /// cell = OnceCell::new();
        /// ```
        pub fn take(&mut self) -> Option<T> {
            mem::take(self).into_inner()
        }

        /// Consumes the `OnceCell`, returning the wrapped value.
        ///
        /// Returns `None` if the cell was empty.
        ///
        /// # Examples
        ///
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let cell: OnceCell<String> = OnceCell::new();
        /// assert_eq!(cell.into_inner(), None);
        ///
        /// let cell = OnceCell::new();
        /// cell.set("hello".to_string()).unwrap();
        /// assert_eq!(cell.into_inner(), Some("hello".to_string()));
        /// ```
        pub fn into_inner(self) -> Option<T> {
            // Because `into_inner` takes `self` by value, the compiler statically verifies
            // that it is not currently borrowed. So it is safe to move out `Option<T>`.
            self.inner.into_inner()
        }
    }

    /// A value which is initialized on the first access.
    ///
    /// # Example
    /// ```
    /// use once_cell::unsync::Lazy;
    ///
    /// let lazy: Lazy<i32> = Lazy::new(|| {
    ///     println!("initializing");
    ///     92
    /// });
    /// println!("ready");
    /// println!("{}", *lazy);
    /// println!("{}", *lazy);
    ///
    /// // Prints:
    /// //   ready
    /// //   initializing
    /// //   92
    /// //   92
    /// ```
    pub struct Lazy<T, F = fn() -> T> {
        cell: OnceCell<T>,
        init: Cell<Option<F>>,
    }

    impl<T, F: RefUnwindSafe> RefUnwindSafe for Lazy<T, F> where OnceCell<T>: RefUnwindSafe {}

    impl<T: fmt::Debug, F> fmt::Debug for Lazy<T, F> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.debug_struct("Lazy").field("cell", &self.cell).field("init", &"..").finish()
        }
    }

    impl<T, F> Lazy<T, F> {
        /// Creates a new lazy value with the given initializing function.
        ///
        /// # Example
        /// ```
        /// # fn main() {
        /// use once_cell::unsync::Lazy;
        ///
        /// let hello = "Hello, World!".to_string();
        ///
        /// let lazy = Lazy::new(|| hello.to_uppercase());
        ///
        /// assert_eq!(&*lazy, "HELLO, WORLD!");
        /// # }
        /// ```
        pub const fn new(init: F) -> Lazy<T, F> {
            Lazy { cell: OnceCell::new(), init: Cell::new(Some(init)) }
        }

        /// Consumes this `Lazy` returning the stored value.
        ///
        /// Returns `Ok(value)` if `Lazy` is initialized and `Err(f)` otherwise.
        pub fn into_value(this: Lazy<T, F>) -> Result<T, F> {
            let cell = this.cell;
            let init = this.init;
            cell.into_inner().ok_or_else(|| {
                init.take().unwrap_or_else(|| panic!("Lazy instance has previously been poisoned"))
            })
        }
    }

    impl<T, F: FnOnce() -> T> Lazy<T, F> {
        /// Forces the evaluation of this lazy value and returns a reference to
        /// the result.
        ///
        /// This is equivalent to the `Deref` impl, but is explicit.
        ///
        /// # Example
        /// ```
        /// use once_cell::unsync::Lazy;
        ///
        /// let lazy = Lazy::new(|| 92);
        ///
        /// assert_eq!(Lazy::force(&lazy), &92);
        /// assert_eq!(&*lazy, &92);
        /// ```
        pub fn force(this: &Lazy<T, F>) -> &T {
            this.cell.get_or_init(|| match this.init.take() {
                Some(f) => f(),
                None => panic!("Lazy instance has previously been poisoned"),
            })
        }

        /// Forces the evaluation of this lazy value and returns a mutable reference to
        /// the result.
        ///
        /// This is equivalent to the `DerefMut` impl, but is explicit.
        ///
        /// # Example
        /// ```
        /// use once_cell::unsync::Lazy;
        ///
        /// let mut lazy = Lazy::new(|| 92);
        ///
        /// assert_eq!(Lazy::force_mut(&mut lazy), &92);
        /// assert_eq!(*lazy, 92);
        /// ```
        pub fn force_mut(this: &mut Lazy<T, F>) -> &mut T {
            if this.cell.get_mut().is_none() {
                let value = match this.init.get_mut().take() {
                    Some(f) => f(),
                    None => panic!("Lazy instance has previously been poisoned"),
                };
                this.cell = OnceCell::with_value(value);
            }
            this.cell.get_mut().unwrap_or_else(|| unreachable!())
        }

        /// Gets the reference to the result of this lazy value if
        /// it was initialized, otherwise returns `None`.
        ///
        /// # Example
        /// ```
        /// use once_cell::unsync::Lazy;
        ///
        /// let lazy = Lazy::new(|| 92);
        ///
        /// assert_eq!(Lazy::get(&lazy), None);
        /// assert_eq!(&*lazy, &92);
        /// assert_eq!(Lazy::get(&lazy), Some(&92));
        /// ```
        pub fn get(this: &Lazy<T, F>) -> Option<&T> {
            this.cell.get()
        }

        /// Gets the mutable reference to the result of this lazy value if
        /// it was initialized, otherwise returns `None`.
        ///
        /// # Example
        /// ```
        /// use once_cell::unsync::Lazy;
        ///
        /// let mut lazy = Lazy::new(|| 92);
        ///
        /// assert_eq!(Lazy::get_mut(&mut lazy), None);
        /// assert_eq!(*lazy, 92);
        /// assert_eq!(Lazy::get_mut(&mut lazy), Some(&mut 92));
        /// ```
        pub fn get_mut(this: &mut Lazy<T, F>) -> Option<&mut T> {
            this.cell.get_mut()
        }
    }

    impl<T, F: FnOnce() -> T> Deref for Lazy<T, F> {
        type Target = T;
        fn deref(&self) -> &T {
            Lazy::force(self)
        }
    }

    impl<T, F: FnOnce() -> T> DerefMut for Lazy<T, F> {
        fn deref_mut(&mut self) -> &mut T {
            Lazy::force_mut(self)
        }
    }

    impl<T: Default> Default for Lazy<T> {
        /// Creates a new lazy value using `Default` as the initializing function.
        fn default() -> Lazy<T> {
            Lazy::new(T::default)
        }
    }
}

/// Thread-safe, blocking version of `OnceCell`.
#[cfg(any(feature = "std", feature = "critical-section"))]
pub mod sync {
    use core::{
        cell::Cell,
        fmt, mem,
        ops::{Deref, DerefMut},
        panic::RefUnwindSafe,
    };

    use super::imp::OnceCell as Imp;

    /// A thread-safe cell which can be written to only once.
    ///
    /// `OnceCell` provides `&` references to the contents without RAII guards.
    ///
    /// Reading a non-`None` value out of `OnceCell` establishes a
    /// happens-before relationship with a corresponding write. For example, if
    /// thread A initializes the cell with `get_or_init(f)`, and thread B
    /// subsequently reads the result of this call, B also observes all the side
    /// effects of `f`.
    ///
    /// # Example
    /// ```
    /// use once_cell::sync::OnceCell;
    ///
    /// static CELL: OnceCell<String> = OnceCell::new();
    /// assert!(CELL.get().is_none());
    ///
    /// std::thread::spawn(|| {
    ///     let value: &String = CELL.get_or_init(|| {
    ///         "Hello, World!".to_string()
    ///     });
    ///     assert_eq!(value, "Hello, World!");
    /// }).join().unwrap();
    ///
    /// let value: Option<&String> = CELL.get();
    /// assert!(value.is_some());
    /// assert_eq!(value.unwrap().as_str(), "Hello, World!");
    /// ```
    pub struct OnceCell<T>(Imp<T>);

    impl<T> Default for OnceCell<T> {
        fn default() -> OnceCell<T> {
            OnceCell::new()
        }
    }

    impl<T: fmt::Debug> fmt::Debug for OnceCell<T> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self.get() {
                Some(v) => f.debug_tuple("OnceCell").field(v).finish(),
                None => f.write_str("OnceCell(Uninit)"),
            }
        }
    }

    impl<T: Clone> Clone for OnceCell<T> {
        fn clone(&self) -> OnceCell<T> {
            match self.get() {
                Some(value) => Self::with_value(value.clone()),
                None => Self::new(),
            }
        }

        fn clone_from(&mut self, source: &Self) {
            match (self.get_mut(), source.get()) {
                (Some(this), Some(source)) => this.clone_from(source),
                _ => *self = source.clone(),
            }
        }
    }

    impl<T> From<T> for OnceCell<T> {
        fn from(value: T) -> Self {
            Self::with_value(value)
        }
    }

    impl<T: PartialEq> PartialEq for OnceCell<T> {
        fn eq(&self, other: &OnceCell<T>) -> bool {
            self.get() == other.get()
        }
    }

    impl<T: Eq> Eq for OnceCell<T> {}

    impl<T> OnceCell<T> {
        /// Creates a new empty cell.
        pub const fn new() -> OnceCell<T> {
            OnceCell(Imp::new())
        }

        /// Creates a new initialized cell.
        pub const fn with_value(value: T) -> OnceCell<T> {
            OnceCell(Imp::with_value(value))
        }

        /// Gets the reference to the underlying value.
        ///
        /// Returns `None` if the cell is empty, or being initialized. This
        /// method never blocks.
        pub fn get(&self) -> Option<&T> {
            if self.0.is_initialized() {
                // Safe b/c value is initialized.
                Some(unsafe { self.get_unchecked() })
            } else {
                None
            }
        }

        /// Gets the reference to the underlying value, blocking the current
        /// thread until it is set.
        ///
        /// ```
        /// use once_cell::sync::OnceCell;
        ///
        /// let mut cell = std::sync::Arc::new(OnceCell::new());
        /// let t = std::thread::spawn({
        ///     let cell = std::sync::Arc::clone(&cell);
        ///     move || cell.set(92).unwrap()
        /// });
        ///
        /// // Returns immediately, but might return None.
        /// let _value_or_none = cell.get();
        ///
        /// // Will return 92, but might block until the other thread does `.set`.
        /// let value: &u32 = cell.wait();
        /// assert_eq!(*value, 92);
        /// t.join().unwrap();
        /// ```
        #[cfg(feature = "std")]
        pub fn wait(&self) -> &T {
            if !self.0.is_initialized() {
                self.0.wait()
            }
            debug_assert!(self.0.is_initialized());
            // Safe b/c of the wait call above and the fact that we didn't
            // relinquish our borrow.
            unsafe { self.get_unchecked() }
        }

        /// Gets the mutable reference to the underlying value.
        ///
        /// Returns `None` if the cell is empty.
        ///
        /// This method is allowed to violate the invariant of writing to a `OnceCell`
        /// at most once because it requires `&mut` access to `self`. As with all
        /// interior mutability, `&mut` access permits arbitrary modification:
        ///
        /// ```
        /// use once_cell::sync::OnceCell;
        ///
        /// let mut cell: OnceCell<u32> = OnceCell::new();
        /// cell.set(92).unwrap();
        /// cell = OnceCell::new();
        /// ```
        #[inline]
        pub fn get_mut(&mut self) -> Option<&mut T> {
            self.0.get_mut()
        }

        /// Get the reference to the underlying value, without checking if the
        /// cell is initialized.
        ///
        /// # Safety
        ///
        /// Caller must ensure that the cell is in initialized state, and that
        /// the contents are acquired by (synchronized to) this thread.
        #[inline]
        pub unsafe fn get_unchecked(&self) -> &T {
            self.0.get_unchecked()
        }

        /// Sets the contents of this cell to `value`.
        ///
        /// Returns `Ok(())` if the cell was empty and `Err(value)` if it was
        /// full.
        ///
        /// # Example
        ///
        /// ```
        /// use once_cell::sync::OnceCell;
        ///
        /// static CELL: OnceCell<i32> = OnceCell::new();
        ///
        /// fn main() {
        ///     assert!(CELL.get().is_none());
        ///
        ///     std::thread::spawn(|| {
        ///         assert_eq!(CELL.set(92), Ok(()));
        ///     }).join().unwrap();
        ///
        ///     assert_eq!(CELL.set(62), Err(62));
        ///     assert_eq!(CELL.get(), Some(&92));
        /// }
        /// ```
        pub fn set(&self, value: T) -> Result<(), T> {
            match self.try_insert(value) {
                Ok(_) => Ok(()),
                Err((_, value)) => Err(value),
            }
        }

        /// Like [`set`](Self::set), but also returns a reference to the final cell value.
        ///
        /// # Example
        ///
        /// ```
        /// use once_cell::unsync::OnceCell;
        ///
        /// let cell = OnceCell::new();
        /// assert!(cell.get().is_none());
        ///
        /// assert_eq!(cell.try_insert(92), Ok(&92));
        /// assert_eq!(cell.try_insert(62), Err((&92, 62)));
        ///
        /// assert!(cell.get().is_some());
        /// ```
        pub fn try_insert(&self, value: T) -> Result<&T, (&T, T)> {
            let mut value = Some(value);
            let res = self.get_or_init(|| unsafe { value.take().unwrap_unchecked() });
            match value {
                None => Ok(res),
                Some(value) => Err((res, value)),
            }
        }

        /// Gets the contents of the cell, initializing it with `f` if the cell
        /// was empty.
        ///
        /// Many threads may call `get_or_init` concurrently with different
        /// initializing functions, but it is guaranteed that only one function
        /// will be executed.
        ///
        /// # Panics
        ///
        /// If `f` panics, the panic is propagated to the caller, and the cell
        /// remains uninitialized.
        ///
        /// It is an error to reentrantly initialize the cell from `f`. The
        /// exact outcome is unspecified. Current implementation deadlocks, but
        /// this may be changed to a panic in the future.
        ///
        /// # Example
        /// ```
        /// use once_cell::sync::OnceCell;
        ///
        /// let cell = OnceCell::new();
        /// let value = cell.get_or_init(|| 92);
        /// assert_eq!(value, &92);
        /// let value = cell.get_or_init(|| unreachable!());
        /// assert_eq!(value, &92);
        /// ```
        pub fn get_or_init<F>(&self, f: F) -> &T
        where
            F: FnOnce() -> T,
        {
            enum Void {}
            match self.get_or_try_init(|| Ok::<T, Void>(f())) {
                Ok(val) => val,
                Err(void) => match void {},
            }
        }

        /// Gets the contents of the cell, initializing it with `f` if
        /// the cell was empty. If the cell was empty and `f` failed, an
        /// error is returned.
        ///
        /// # Panics
        ///
        /// If `f` panics, the panic is propagated to the caller, and
        /// the cell remains uninitialized.
        ///
        /// It is an error to reentrantly initialize the cell from `f`.
        /// The exact outcome is unspecified. Current implementation
        /// deadlocks, but this may be changed to a panic in the future.
        ///
        /// # Example
        /// ```
        /// use once_cell::sync::OnceCell;
        ///
        /// let cell = OnceCell::new();
        /// assert_eq!(cell.get_or_try_init(|| Err(())), Err(()));
        /// assert!(cell.get().is_none());
        /// let value = cell.get_or_try_init(|| -> Result<i32, ()> {
        ///     Ok(92)
        /// });
        /// assert_eq!(value, Ok(&92));
        /// assert_eq!(cell.get(), Some(&92))
        /// ```
        pub fn get_or_try_init<F, E>(&self, f: F) -> Result<&T, E>
        where
            F: FnOnce() -> Result<T, E>,
        {
            // Fast path check
            if let Some(value) = self.get() {
                return Ok(value);
            }

            self.0.initialize(f)?;

            // Safe b/c value is initialized.
            debug_assert!(self.0.is_initialized());
            Ok(unsafe { self.get_unchecked() })
        }

        /// Takes the value out of this `OnceCell`, moving it back to an uninitialized state.
        ///
        /// Has no effect and returns `None` if the `OnceCell` hasn't been initialized.
        ///
        /// # Examples
        ///
        /// ```
        /// use once_cell::sync::OnceCell;
        ///
        /// let mut cell: OnceCell<String> = OnceCell::new();
        /// assert_eq!(cell.take(), None);
        ///
        /// let mut cell = OnceCell::new();
        /// cell.set("hello".to_string()).unwrap();
        /// assert_eq!(cell.take(), Some("hello".to_string()));
        /// assert_eq!(cell.get(), None);
        /// ```
        ///
        /// This method is allowed to violate the invariant of writing to a `OnceCell`
        /// at most once because it requires `&mut` access to `self`. As with all
        /// interior mutability, `&mut` access permits arbitrary modification:
        ///
        /// ```
        /// use once_cell::sync::OnceCell;
        ///
        /// let mut cell: OnceCell<u32> = OnceCell::new();
        /// cell.set(92).unwrap();
        /// cell = OnceCell::new();
        /// ```
        pub fn take(&mut self) -> Option<T> {
            mem::take(self).into_inner()
        }

        /// Consumes the `OnceCell`, returning the wrapped value. Returns
        /// `None` if the cell was empty.
        ///
        /// # Examples
        ///
        /// ```
        /// use once_cell::sync::OnceCell;
        ///
        /// let cell: OnceCell<String> = OnceCell::new();
        /// assert_eq!(cell.into_inner(), None);
        ///
        /// let cell = OnceCell::new();
        /// cell.set("hello".to_string()).unwrap();
        /// assert_eq!(cell.into_inner(), Some("hello".to_string()));
        /// ```
        #[inline]
        pub fn into_inner(self) -> Option<T> {
            self.0.into_inner()
        }
    }

    /// A value which is initialized on the first access.
    ///
    /// This type is thread-safe and can be used in statics.
    ///
    /// # Example
    ///
    /// ```
    /// use std::collections::HashMap;
    ///
    /// use once_cell::sync::Lazy;
    ///
    /// static HASHMAP: Lazy<HashMap<i32, String>> = Lazy::new(|| {
    ///     println!("initializing");
    ///     let mut m = HashMap::new();
    ///     m.insert(13, "Spica".to_string());
    ///     m.insert(74, "Hoyten".to_string());
    ///     m
    /// });
    ///
    /// fn main() {
    ///     println!("ready");
    ///     std::thread::spawn(|| {
    ///         println!("{:?}", HASHMAP.get(&13));
    ///     }).join().unwrap();
    ///     println!("{:?}", HASHMAP.get(&74));
    ///
    ///     // Prints:
    ///     //   ready
    ///     //   initializing
    ///     //   Some("Spica")
    ///     //   Some("Hoyten")
    /// }
    /// ```
    pub struct Lazy<T, F = fn() -> T> {
        cell: OnceCell<T>,
        init: Cell<Option<F>>,
    }

    impl<T: fmt::Debug, F> fmt::Debug for Lazy<T, F> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.debug_struct("Lazy").field("cell", &self.cell).field("init", &"..").finish()
        }
    }

    // We never create a `&F` from a `&Lazy<T, F>` so it is fine to not impl
    // `Sync` for `F`. We do create a `&mut Option<F>` in `force`, but this is
    // properly synchronized, so it only happens once so it also does not
    // contribute to this impl.
    unsafe impl<T, F: Send> Sync for Lazy<T, F> where OnceCell<T>: Sync {}
    // auto-derived `Send` impl is OK.

    impl<T, F: RefUnwindSafe> RefUnwindSafe for Lazy<T, F> where OnceCell<T>: RefUnwindSafe {}

    impl<T, F> Lazy<T, F> {
        /// Creates a new lazy value with the given initializing
        /// function.
        pub const fn new(f: F) -> Lazy<T, F> {
            Lazy { cell: OnceCell::new(), init: Cell::new(Some(f)) }
        }

        /// Consumes this `Lazy` returning the stored value.
        ///
        /// Returns `Ok(value)` if `Lazy` is initialized and `Err(f)` otherwise.
        pub fn into_value(this: Lazy<T, F>) -> Result<T, F> {
            let cell = this.cell;
            let init = this.init;
            cell.into_inner().ok_or_else(|| {
                init.take().unwrap_or_else(|| panic!("Lazy instance has previously been poisoned"))
            })
        }
    }

    impl<T, F: FnOnce() -> T> Lazy<T, F> {
        /// Forces the evaluation of this lazy value and
        /// returns a reference to the result. This is equivalent
        /// to the `Deref` impl, but is explicit.
        ///
        /// # Example
        /// ```
        /// use once_cell::sync::Lazy;
        ///
        /// let lazy = Lazy::new(|| 92);
        ///
        /// assert_eq!(Lazy::force(&lazy), &92);
        /// assert_eq!(&*lazy, &92);
        /// ```
        pub fn force(this: &Lazy<T, F>) -> &T {
            this.cell.get_or_init(|| match this.init.take() {
                Some(f) => f(),
                None => panic!("Lazy instance has previously been poisoned"),
            })
        }

        /// Forces the evaluation of this lazy value and
        /// returns a mutable reference to the result. This is equivalent
        /// to the `Deref` impl, but is explicit.
        ///
        /// # Example
        /// ```
        /// use once_cell::sync::Lazy;
        ///
        /// let mut lazy = Lazy::new(|| 92);
        ///
        /// assert_eq!(Lazy::force_mut(&mut lazy), &mut 92);
        /// ```
        pub fn force_mut(this: &mut Lazy<T, F>) -> &mut T {
            if this.cell.get_mut().is_none() {
                let value = match this.init.get_mut().take() {
                    Some(f) => f(),
                    None => panic!("Lazy instance has previously been poisoned"),
                };
                this.cell = OnceCell::with_value(value);
            }
            this.cell.get_mut().unwrap_or_else(|| unreachable!())
        }

        /// Gets the reference to the result of this lazy value if
        /// it was initialized, otherwise returns `None`.
        ///
        /// # Example
        /// ```
        /// use once_cell::sync::Lazy;
        ///
        /// let lazy = Lazy::new(|| 92);
        ///
        /// assert_eq!(Lazy::get(&lazy), None);
        /// assert_eq!(&*lazy, &92);
        /// assert_eq!(Lazy::get(&lazy), Some(&92));
        /// ```
        pub fn get(this: &Lazy<T, F>) -> Option<&T> {
            this.cell.get()
        }

        /// Gets the reference to the result of this lazy value if
        /// it was initialized, otherwise returns `None`.
        ///
        /// # Example
        /// ```
        /// use once_cell::sync::Lazy;
        ///
        /// let mut lazy = Lazy::new(|| 92);
        ///
        /// assert_eq!(Lazy::get_mut(&mut lazy), None);
        /// assert_eq!(&*lazy, &92);
        /// assert_eq!(Lazy::get_mut(&mut lazy), Some(&mut 92));
        /// ```
        pub fn get_mut(this: &mut Lazy<T, F>) -> Option<&mut T> {
            this.cell.get_mut()
        }
    }

    impl<T, F: FnOnce() -> T> Deref for Lazy<T, F> {
        type Target = T;
        fn deref(&self) -> &T {
            Lazy::force(self)
        }
    }

    impl<T, F: FnOnce() -> T> DerefMut for Lazy<T, F> {
        fn deref_mut(&mut self) -> &mut T {
            Lazy::force_mut(self)
        }
    }

    impl<T: Default> Default for Lazy<T> {
        /// Creates a new lazy value using `Default` as the initializing function.
        fn default() -> Lazy<T> {
            Lazy::new(T::default)
        }
    }

    /// ```compile_fail
    /// struct S(*mut ());
    /// unsafe impl Sync for S {}
    ///
    /// fn share<T: Sync>(_: &T) {}
    /// share(&once_cell::sync::OnceCell::<S>::new());
    /// ```
    ///
    /// ```compile_fail
    /// struct S(*mut ());
    /// unsafe impl Sync for S {}
    ///
    /// fn share<T: Sync>(_: &T) {}
    /// share(&once_cell::sync::Lazy::<S>::new(|| unimplemented!()));
    /// ```
    fn _dummy() {}
}

#[cfg(feature = "race")]
pub mod race;

/home/ubuntu/.cargo/registry/src/index.crates.io-6f17d22bba15001f/once_cell-1.18.0/src/race.rs

Source (jump to first uncovered line)
//! Thread-safe, non-blocking, "first one wins" flavor of `OnceCell`.
//!
//! If two threads race to initialize a type from the `race` module, they
//! don't block, execute initialization function together, but only one of
//! them stores the result.
//!
//! This module does not require `std` feature.
//!
//! # Atomic orderings
//!
//! All types in this module use `Acquire` and `Release`
//! [atomic orderings](Ordering) for all their operations. While this is not
//! strictly necessary for types other than `OnceBox`, it is useful for users as
//! it allows them to be certain that after `get` or `get_or_init` returns on
//! one thread, any side-effects caused by the setter thread prior to them
//! calling `set` or `get_or_init` will be made visible to that thread; without
//! it, it's possible for it to appear as if they haven't happened yet from the
//! getter thread's perspective. This is an acceptable tradeoff to make since
//! `Acquire` and `Release` have very little performance overhead on most
//! architectures versus `Relaxed`.

#[cfg(feature = "critical-section")]
use atomic_polyfill as atomic;
#[cfg(not(feature = "critical-section"))]
use core::sync::atomic;

use atomic::{AtomicPtr, AtomicUsize, Ordering};
use core::cell::UnsafeCell;
use core::marker::PhantomData;
use core::num::NonZeroUsize;
use core::ptr;

/// A thread-safe cell which can be written to only once.
#[derive(Default, Debug)]
pub struct OnceNonZeroUsize {
    inner: AtomicUsize,
}

impl OnceNonZeroUsize {
    /// Creates a new empty cell.
    #[inline]
    pub const fn new() -> OnceNonZeroUsize {
        OnceNonZeroUsize { inner: AtomicUsize::new(0) }
    }

    /// Gets the underlying value.
    #[inline]
    pub fn get(&self) -> Option<NonZeroUsize> {
        let val = self.inner.load(Ordering::Acquire);
        NonZeroUsize::new(val)
    }

    /// Sets the contents of this cell to `value`.
    ///
    /// Returns `Ok(())` if the cell was empty and `Err(())` if it was
    /// full.
    #[inline]
    pub fn set(&self, value: NonZeroUsize) -> Result<(), ()> {
        let exchange =
            self.inner.compare_exchange(0, value.get(), Ordering::AcqRel, Ordering::Acquire);
        match exchange {
            Ok(_) => Ok(()),
            Err(_) => Err(()),
        }
    }

    /// Gets the contents of the cell, initializing it with `f` if the cell was
    /// empty.
    ///
    /// If several threads concurrently run `get_or_init`, more than one `f` can
    /// be called. However, all threads will return the same value, produced by
    /// some `f`.
    pub fn get_or_init<F>(&self, f: F) -> NonZeroUsize
    where
        F: FnOnce() -> NonZeroUsize,
    {
        enum Void {}
        match self.get_or_try_init(|| Ok::<NonZeroUsize, Void>(f())) {
            Ok(val) => val,
            Err(void) => match void {},
        }
    }

    /// Gets the contents of the cell, initializing it with `f` if
    /// the cell was empty. If the cell was empty and `f` failed, an
    /// error is returned.
    ///
    /// If several threads concurrently run `get_or_init`, more than one `f` can
    /// be called. However, all threads will return the same value, produced by
    /// some `f`.
    pub fn get_or_try_init<F, E>(&self, f: F) -> Result<NonZeroUsize, E>
    where
        F: FnOnce() -> Result<NonZeroUsize, E>,
    {
        let val = self.inner.load(Ordering::Acquire);
        let res = match NonZeroUsize::new(val) {
            Some(it) => it,
            None => {
                let mut val = f()?.get();
                let exchange =
                    self.inner.compare_exchange(0, val, Ordering::AcqRel, Ordering::Acquire);
                if let Err(old) = exchange {
                    val = old;
                }
                unsafe { NonZeroUsize::new_unchecked(val) }
            }
        };
        Ok(res)
    }
}

/// A thread-safe cell which can be written to only once.
#[derive(Default, Debug)]
pub struct OnceBool {
    inner: OnceNonZeroUsize,
}

impl OnceBool {
    /// Creates a new empty cell.
    #[inline]
    pub const fn new() -> OnceBool {
        OnceBool { inner: OnceNonZeroUsize::new() }
    }

    /// Gets the underlying value.
    #[inline]
    pub fn get(&self) -> Option<bool> {
        self.inner.get().map(OnceBool::from_usize)
    }

    /// Sets the contents of this cell to `value`.
    ///
    /// Returns `Ok(())` if the cell was empty and `Err(())` if it was
    /// full.
    #[inline]
    pub fn set(&self, value: bool) -> Result<(), ()> {
        self.inner.set(OnceBool::to_usize(value))
    }

    /// Gets the contents of the cell, initializing it with `f` if the cell was
    /// empty.
    ///
    /// If several threads concurrently run `get_or_init`, more than one `f` can
    /// be called. However, all threads will return the same value, produced by
    /// some `f`.
    pub fn get_or_init<F>(&self, f: F) -> bool
    where
        F: FnOnce() -> bool,
    {
        OnceBool::from_usize(self.inner.get_or_init(|| OnceBool::to_usize(f())))
    }

    /// Gets the contents of the cell, initializing it with `f` if
    /// the cell was empty. If the cell was empty and `f` failed, an
    /// error is returned.
    ///
    /// If several threads concurrently run `get_or_init`, more than one `f` can
    /// be called. However, all threads will return the same value, produced by
    /// some `f`.
    pub fn get_or_try_init<F, E>(&self, f: F) -> Result<bool, E>
    where
        F: FnOnce() -> Result<bool, E>,
    {
        self.inner.get_or_try_init(|| f().map(OnceBool::to_usize)).map(OnceBool::from_usize)
    }

    #[inline]
    fn from_usize(value: NonZeroUsize) -> bool {
        value.get() == 1
    }

    #[inline]
    fn to_usize(value: bool) -> NonZeroUsize {
        unsafe { NonZeroUsize::new_unchecked(if value { 1 } else { 2 }) }
    }
}

/// A thread-safe cell which can be written to only once.
pub struct OnceRef<'a, T> {
    inner: AtomicPtr<T>,
    ghost: PhantomData<UnsafeCell<&'a T>>,
}

// TODO: Replace UnsafeCell with SyncUnsafeCell once stabilized
unsafe impl<'a, T: Sync> Sync for OnceRef<'a, T> {}

impl<'a, T> core::fmt::Debug for OnceRef<'a, T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "OnceRef({:?})", self.inner)
    }
}

impl<'a, T> Default for OnceRef<'a, T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<'a, T> OnceRef<'a, T> {
    /// Creates a new empty cell.
    pub const fn new() -> OnceRef<'a, T> {
        OnceRef { inner: AtomicPtr::new(ptr::null_mut()), ghost: PhantomData }
    }

    /// Gets a reference to the underlying value.
    pub fn get(&self) -> Option<&'a T> {
        let ptr = self.inner.load(Ordering::Acquire);
        unsafe { ptr.as_ref() }
    }

    /// Sets the contents of this cell to `value`.
    ///
    /// Returns `Ok(())` if the cell was empty and `Err(value)` if it was
    /// full.
    pub fn set(&self, value: &'a T) -> Result<(), ()> {
        let ptr = value as *const T as *mut T;
        let exchange =
            self.inner.compare_exchange(ptr::null_mut(), ptr, Ordering::AcqRel, Ordering::Acquire);
        match exchange {
            Ok(_) => Ok(()),
            Err(_) => Err(()),
        }
    }

    /// Gets the contents of the cell, initializing it with `f` if the cell was
    /// empty.
    ///
    /// If several threads concurrently run `get_or_init`, more than one `f` can
    /// be called. However, all threads will return the same value, produced by
    /// some `f`.
    pub fn get_or_init<F>(&self, f: F) -> &'a T
    where
        F: FnOnce() -> &'a T,
    {
        enum Void {}
        match self.get_or_try_init(|| Ok::<&'a T, Void>(f())) {
            Ok(val) => val,
            Err(void) => match void {},
        }
    }

    /// Gets the contents of the cell, initializing it with `f` if
    /// the cell was empty. If the cell was empty and `f` failed, an
    /// error is returned.
    ///
    /// If several threads concurrently run `get_or_init`, more than one `f` can
    /// be called. However, all threads will return the same value, produced by
    /// some `f`.
    pub fn get_or_try_init<F, E>(&self, f: F) -> Result<&'a T, E>
    where
        F: FnOnce() -> Result<&'a T, E>,
    {
        let mut ptr = self.inner.load(Ordering::Acquire);

        if ptr.is_null() {
            // TODO replace with `cast_mut` when MSRV reaches 1.65.0 (also in `set`)
            ptr = f()? as *const T as *mut T;
            let exchange = self.inner.compare_exchange(
                ptr::null_mut(),
                ptr,
                Ordering::AcqRel,
                Ordering::Acquire,
            );
            if let Err(old) = exchange {
                ptr = old;
            }
        }

        Ok(unsafe { &*ptr })
    }

    /// ```compile_fail
    /// use once_cell::race::OnceRef;
    ///
    /// let mut l = OnceRef::new();
    ///
    /// {
    ///     let y = 2;
    ///     let mut r = OnceRef::new();
    ///     r.set(&y).unwrap();
    ///     core::mem::swap(&mut l, &mut r);
    /// }
    ///
    /// // l now contains a dangling reference to y
    /// eprintln!("uaf: {}", l.get().unwrap());
    /// ```
    fn _dummy() {}
}

#[cfg(feature = "alloc")]
pub use self::once_box::OnceBox;

#[cfg(feature = "alloc")]
mod once_box {
    use super::atomic::{AtomicPtr, Ordering};
    use core::{marker::PhantomData, ptr};

    use alloc::boxed::Box;

    /// A thread-safe cell which can be written to only once.
    pub struct OnceBox<T> {
        inner: AtomicPtr<T>,
        ghost: PhantomData<Option<Box<T>>>,
    }

    impl<T> core::fmt::Debug for OnceBox<T> {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            write!(f, "OnceBox({:?})", self.inner.load(Ordering::Relaxed))
        }
    }

    impl<T> Default for OnceBox<T> {
        fn default() -> Self {
            Self::new()
        }
    }

    impl<T> Drop for OnceBox<T> {
        fn drop(&mut self) {
            let ptr = *self.inner.get_mut();
            if !ptr.is_null() {
                drop(unsafe { Box::from_raw(ptr) })
            }
        }
    }

    impl<T> OnceBox<T> {
        /// Creates a new empty cell.
        pub const fn new() -> OnceBox<T> {
            OnceBox { inner: AtomicPtr::new(ptr::null_mut()), ghost: PhantomData }
        }

        /// Gets a reference to the underlying value.
        pub fn get(&self) -> Option<&T> {
            let ptr = self.inner.load(Ordering::Acquire);
            if ptr.is_null() {
                return None;
            }
            Some(unsafe { &*ptr })
        }

        /// Sets the contents of this cell to `value`.
        ///
        /// Returns `Ok(())` if the cell was empty and `Err(value)` if it was
        /// full.
        pub fn set(&self, value: Box<T>) -> Result<(), Box<T>> {
            let ptr = Box::into_raw(value);
            let exchange = self.inner.compare_exchange(
                ptr::null_mut(),
                ptr,
                Ordering::AcqRel,
                Ordering::Acquire,
            );
            if exchange.is_err() {
                let value = unsafe { Box::from_raw(ptr) };
                return Err(value);
            }
            Ok(())
        }

        /// Gets the contents of the cell, initializing it with `f` if the cell was
        /// empty.
        ///
        /// If several threads concurrently run `get_or_init`, more than one `f` can
        /// be called. However, all threads will return the same value, produced by
        /// some `f`.
        pub fn get_or_init<F>(&self, f: F) -> &T
        where
            F: FnOnce() -> Box<T>,
        {
            enum Void {}
            match self.get_or_try_init(|| Ok::<Box<T>, Void>(f())) {
                Ok(val) => val,
                Err(void) => match void {},
            }
        }

        /// Gets the contents of the cell, initializing it with `f` if
        /// the cell was empty. If the cell was empty and `f` failed, an
        /// error is returned.
        ///
        /// If several threads concurrently run `get_or_init`, more than one `f` can
        /// be called. However, all threads will return the same value, produced by
        /// some `f`.
        pub fn get_or_try_init<F, E>(&self, f: F) -> Result<&T, E>
        where
            F: FnOnce() -> Result<Box<T>, E>,
        {
            let mut ptr = self.inner.load(Ordering::Acquire);

            if ptr.is_null() {
                let val = f()?;
                ptr = Box::into_raw(val);
                let exchange = self.inner.compare_exchange(
                    ptr::null_mut(),
                    ptr,
                    Ordering::AcqRel,
                    Ordering::Acquire,
                );
                if let Err(old) = exchange {
                    drop(unsafe { Box::from_raw(ptr) });
                    ptr = old;
                }
            };
            Ok(unsafe { &*ptr })
        }
    }

    unsafe impl<T: Sync + Send> Sync for OnceBox<T> {}

    /// ```compile_fail
    /// struct S(*mut ());
    /// unsafe impl Sync for S {}
    ///
    /// fn share<T: Sync>(_: &T) {}
    /// share(&once_cell::race::OnceBox::<S>::new());
    /// ```
    fn _dummy() {}
}

/mnt/h/flex-dns/src/additional.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::answer::DnsAClass;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::question::DnsQType;
use crate::rdata::{DnsAType, RData};
use crate::write::WriteBytes;

pub struct DnsAdditionals<
    const PTR_STORAGE: usize,
    B: Buffer,
> {
    message: DnsMessage<PTR_STORAGE, { DnsSection::Additionals }, B>,
    remaining: usize,
}

impl<
    const PTR_STORAGE: usize,
    B: Buffer,
> DnsAdditionals<PTR_STORAGE, B> {
    #[inline(always)]
    pub(crate) fn new(message: DnsMessage<PTR_STORAGE, { DnsSection::Additionals }, B>) -> Self {
        let remaining = message.header().unwrap().answer_count() as usize;
        Self {
            message,
            remaining,
        }
    }

    pub fn append(&mut self, answer: DnsAdditional<DnsAType>) -> Result<(), DnsMessageError> {
        let (buffer, position) = self.message.buffer_and_position();
        // Truncate the buffer to the current position.
        buffer.truncate(*position)?;
        answer.write(&mut self.message)?;
        // Set answer_count in the header to the current answer count + 1.
        let answer_count = self.message.header().unwrap().answer_count();
        let answer_count = answer_count + 1 - self.remaining as u16;
        self.message.header_mut()?.set_answer_count(answer_count);
        self.message.header_mut()?.set_name_server_count(0);
        self.message.header_mut()?.set_additional_records_count(0);
        self.remaining = 0;

        Ok(())
    }

    #[inline]
    pub fn iter(&mut self) -> Result<DnsAdditionalsIterator, DnsMessageError> {
        let (buffer, position) = self.message.buffer_and_position();
        let buffer = buffer.bytes();

        Ok(DnsAdditionalsIterator {
            buffer,
            current_position: position,
            remaining: &mut self.remaining,
        })
    }

    #[inline]
    pub fn complete(mut self) -> Result<DnsMessage<PTR_STORAGE, { DnsSection::Additionals }, B>, DnsMessageError> {
        if self.remaining != 0 {
            for x in self.iter()? { x?; }
        }

        Ok(DnsMessage {
            buffer: self.message.buffer,
            position: self.message.position,
            ptr_storage: self.message.ptr_storage,
        })
    }
}

pub struct DnsAdditionalsIterator<'a> {
    buffer: &'a [u8],
    current_position: &'a mut usize,
    remaining: &'a mut usize,
}

impl<'a> Iterator for DnsAdditionalsIterator<'a> {
    type Item = Result<DnsAdditional<'a, RData<'a>>, DnsMessageError>;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        if *self.remaining == 0 {
            return None;
        }

        let additional = DnsAdditional::parse(
            self.buffer, self.current_position
        );
        *self.remaining -= 1;

        Some(additional)
    }
}

#[derive(Debug, PartialEq)]
pub struct DnsAdditional<'a, D> {
    pub name: DnsName<'a>,
    pub rdata: D,
    pub cache_flush: bool,
    pub aclass: DnsAClass,
    pub ttl: u32,
}

impl<'a> DnsAdditional<'a, RData<'a>> {
    pub fn parse(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        let name = DnsName::parse(bytes, i)?;
        let atype_id = u16::parse(bytes, i)?;
        let atype = DnsQType::from_id(atype_id);
        let cache_flush = atype_id & 0b1000_0000_0000_0000 != 0;
        let aclass = DnsAClass::from_id(u16::parse(bytes, i)?);
        let ttl = u32::parse(bytes, i)?;
        let rdata = RData::parse(bytes, i, atype)?;

        Ok(Self {
            name,
            rdata,
            cache_flush,
            aclass,
            ttl,
        })
    }

    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        // Write the name to the buffer using the pointer storage for compression.
        message.write_name(self.name)?;
        // Write the atype and aclass to the buffer.
        self.rdata.id().write(message)?;
        let mut aclass = self.aclass.id();
        if self.cache_flush {
            aclass |= 0b1000_0000;
        }
        aclass.write(message)?;
        // Write the ttl to the buffer.
        self.ttl.write(message)?;
        (self.rdata.byte_len()? as u16).write(message)?;
        // Write the type specific data to the buffer.
        self.rdata.write(message)?;

        Ok(())
    }

    pub fn into_parsed(self) -> Result<DnsAdditional<'a, DnsAType<'a>>, DnsMessageError> {
        Ok(DnsAdditional {
            name: self.name,
            rdata: self.rdata.into_parsed()?,
            cache_flush: self.cache_flush,
            aclass: self.aclass,
            ttl: self.ttl,
        })
    }
}

impl<'a> DnsAdditional<'a, DnsAType<'a>> {
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        // Write the name to the buffer using the pointer storage for compression.
        self.name.write(message)?;
        // Write the atype and aclass to the buffer.
        self.rdata.id().write(message)?;
        let mut aclass = self.aclass.id();
        if self.cache_flush {
            aclass |= 0b1000_0000;
        }
        aclass.write(message)?;
        // Write the ttl to the buffer.
        self.ttl.write(message)?;
        let rdata_len = self.rdata.byte_len()? as u16;
        rdata_len.write(message)?;
        // Write the type specific data to the buffer.
        self.rdata.write(message)?;

        Ok(())
    }
}

/mnt/h/flex-dns/src/answer.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::question::DnsQType;
use crate::rdata::{DnsAType, RData};
use crate::write::WriteBytes;

pub struct DnsAnswers<
    const PTR_STORAGE: usize,
    B: Buffer,
> {
    message: DnsMessage<PTR_STORAGE, { DnsSection::Answers }, B>,
    remaining: usize,
}

impl<
    const PTR_STORAGE: usize,
    B: Buffer,
> DnsAnswers<PTR_STORAGE, B> {
    #[inline(always)]
    pub(crate) fn new(message: DnsMessage<PTR_STORAGE, { DnsSection::Answers }, B>) -> Self {
        let remaining = message.header().unwrap().answer_count() as usize;
        Self {
            message,
            remaining,
        }
    }

    pub fn append(&mut self, answer: DnsAnswer<DnsAType>) -> Result<(), DnsMessageError> {
        let (buffer, position) = self.message.buffer_and_position();
        // Truncate the buffer to the current position.
        buffer.truncate(*position)?;
        answer.write(&mut self.message)?;
        // Set answer_count in the header to the current answer count + 1.
        let answer_count = self.message.header().unwrap().answer_count();
        let answer_count = answer_count + 1 - self.remaining as u16;
        self.message.header_mut()?.set_answer_count(answer_count);
        self.message.header_mut()?.set_name_server_count(0);
        self.message.header_mut()?.set_additional_records_count(0);
        self.remaining = 0;

        Ok(())
    }

    #[inline]
    pub fn iter(&mut self) -> Result<DnsAnswerIterator, DnsMessageError> {
        let (buffer, position) = self.message.buffer_and_position();
        let buffer = buffer.bytes();

        Ok(DnsAnswerIterator {
            buffer,
            current_position: position,
            remaining: &mut self.remaining,
        })
    }

    #[inline]
    pub fn complete(mut self) -> Result<DnsMessage<PTR_STORAGE, { DnsSection::NameServers }, B>, DnsMessageError> {
        if self.remaining != 0 {
            for x in self.iter()? { x?; }
        }

        Ok(DnsMessage {
            buffer: self.message.buffer,
            position: self.message.position,
            ptr_storage: self.message.ptr_storage,
        })
    }
}

pub struct DnsAnswerIterator<'a> {
    buffer: &'a [u8],
    current_position: &'a mut usize,
    remaining: &'a mut usize,
}

impl<'a> Iterator for DnsAnswerIterator<'a> {
    type Item = Result<DnsAnswer<'a, RData<'a>>, DnsMessageError>;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        if *self.remaining == 0 {
            return None;
        }

        let answer = DnsAnswer::parse(
            self.buffer, self.current_position
        );
        *self.remaining -= 1;

        Some(answer)
    }
}

#[derive(Debug, PartialEq)]
pub struct DnsAnswer<'a, D> {
    pub name: DnsName<'a>,
    pub rdata: D,
    pub cache_flush: bool,
    pub aclass: DnsAClass,
    pub ttl: u32,
}

impl<'a> DnsAnswer<'a, RData<'a>> {
    pub fn parse(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        let name = DnsName::parse(bytes, i)?;
        let atype_id = u16::parse(bytes, i)?;
        let atype = DnsQType::from_id(atype_id);
        let cache_flush = atype_id & 0b1000_0000_0000_0000 != 0;
        let aclass = DnsAClass::from_id(u16::parse(bytes, i)?);
        let ttl = u32::parse(bytes, i)?;
        let rdata = RData::parse(bytes, i, atype)?;

        Ok(Self {
            name,
            rdata,
            cache_flush,
            aclass,
            ttl,
        })
    }

    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        // Write the name to the buffer using the pointer storage for compression.
        message.write_name(self.name)?;
        // Write the atype and aclass to the buffer.
        self.rdata.id().write(message)?;
        let mut aclass = self.aclass.id();
        if self.cache_flush {
            aclass |= 0b1000_0000;
        }
        aclass.write(message)?;
        // Write the ttl to the buffer.
        self.ttl.write(message)?;
        (self.rdata.byte_len()? as u16).write(message)?;
        // Write the type specific data to the buffer.
        self.rdata.write(message)?;

        Ok(())
    }

    pub fn into_parsed(self) -> Result<DnsAnswer<'a, DnsAType<'a>>, DnsMessageError> {
        Ok(DnsAnswer {
            name: self.name,
            rdata: self.rdata.into_parsed()?,
            cache_flush: self.cache_flush,
            aclass: self.aclass,
            ttl: self.ttl,
        })
    }
}

impl<'a> DnsAnswer<'a, DnsAType<'a>> {
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        // Write the name to the buffer using the pointer storage for compression.
        self.name.write(message)?;
        // Write the atype and aclass to the buffer.
        self.rdata.id().write(message)?;
        let mut aclass = self.aclass.id();
        if self.cache_flush {
            aclass |= 0b1000_0000;
        }
        aclass.write(message)?;
        // Write the ttl to the buffer.
        self.ttl.write(message)?;
        let rdata_len = self.rdata.byte_len()? as u16;
        rdata_len.write(message)?;
        // Write the type specific data to the buffer.
        self.rdata.write(message)?;

        Ok(())
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
#[repr(u16)]
pub enum DnsAClass {
    IN = 1,
    CS = 2,
    CH = 3,
    HS = 4,
    Reserved,
}

impl DnsAClass {
    #[inline(always)]
    pub fn from_id(id: u16) -> Self {
        match id {
            1..=4 => unsafe { core::mem::transmute(id) },
            _ => DnsAClass::Reserved,
        }
    }

    #[inline(always)]
    pub fn id(&self) -> u16 {
        match self {
            DnsAClass::Reserved => panic!("Reserved QClass"),
            _ => *self as u16,
        }
    }
}

impl From<DnsAClass> for u16 {
    #[inline(always)]
    fn from(q: DnsAClass) -> Self {
        DnsAClass::id(&q)
    }
}

impl From<u16> for DnsAClass {
    #[inline(always)]
    fn from(n: u16) -> Self {
        DnsAClass::from_id(n)
    }
}

/mnt/h/flex-dns/src/characters.rs

Source (jump to first uncovered line)
use core::fmt::Display;
use crate::{Buffer, DnsError, DnsMessage, DnsMessageError, DnsSection};
use crate::parse::ParseBytes;

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Characters<'a> {
    bytes: &'a [u8],
}

const MAX_CHARACTER_STRING_LENGTH: usize = 255;

#[macro_export]
macro_rules! dns_characters {
    ($value:expr $(,)?) => {
        {
            const CHARACTERS: [u8; $value.len() + 1] = {
                let mut result = [0; $value.len() + 1];
                let mut index = 0;
                loop {
                    if index == $value.len() {
                        result[0] = index as u8;

                        break;
                    }

                    result[index + 1] = $value[index];
                    index += 1;
                }

                result
            };
            unsafe { flex_dns::characters::Characters::new_unchecked(&CHARACTERS) }
        }
    };
}

impl<'a> ParseBytes<'a> for Characters<'a> {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        let length = u8::parse_bytes(bytes, i)? as usize;

        if length > MAX_CHARACTER_STRING_LENGTH {
            return Err(DnsMessageError::DnsError(DnsError::CharacterStringTooLong));
        }

        if *i + length > bytes.len() {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let bytes = &bytes[*i..*i + length];
        *i += length;

        Ok(Characters { bytes })
    }
}

impl<'a> Characters<'a> {
    #[inline]
    pub const fn new(bytes: &'a [u8]) -> Result<Self, DnsMessageError> {
        if bytes.len() > MAX_CHARACTER_STRING_LENGTH {
            return Err(DnsMessageError::DnsError(DnsError::CharacterStringTooLong));
        }

        Ok(Characters { bytes })
    }

    #[inline]
    pub const unsafe fn new_unchecked(bytes: &'a [u8]) -> Self {
        Characters { bytes }
    }

    #[inline]
    pub fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(&[self.bytes.len() as u8])?;
        message.write_bytes(self.bytes)?;

        Ok(())
    }

    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(1 + self.bytes.len())
    }
}

impl<'a> AsRef<[u8]> for Characters<'a> {
    #[inline]
    fn as_ref(&self) -> &[u8] {
        self.bytes
    }
}

impl<'a> From<&'a [u8]> for Characters<'a> {
    #[inline]
    fn from(bytes: &'a [u8]) -> Self {
        Characters { bytes }
    }
}

impl<'a> From<Characters<'a>> for &'a [u8] {
    #[inline]
    fn from(characters: Characters<'a>) -> Self {
        characters.bytes
    }
}

impl<'a> Display for Characters<'a> {
    #[inline]
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        for byte in self.bytes {
            write!(f, "\\x{:02x}", byte)?;
        }

        Ok(())
    }
}

/mnt/h/flex-dns/src/header.rs

Source (jump to first uncovered line)
/// A DNS header.
#[derive(Copy, Clone)]
#[repr(C)]
pub struct DnsHeader {
    id: [u8; 2],
    flags: [u8; 2],
    question_count: [u8; 2],
    answer_count: [u8; 2],
    name_server_count: [u8; 2],
    additional_records_count: [u8; 2],
}

impl DnsHeader {
    #[inline(always)]
    pub fn from_bytes_mut(bytes: &mut [u8]) -> &mut Self {
        unsafe { &mut *(bytes.as_mut_ptr() as *mut Self) }
    }

    #[inline(always)]
    pub fn from_bytes(bytes: &[u8]) -> &Self {
        unsafe { & *(bytes.as_ptr() as *const Self) }
    }

    #[inline(always)]
    pub fn id(&self) -> u16 {
        u16::from_be_bytes(self.id)
    }

    #[inline(always)]
    pub fn kind(&self) -> DnsHeaderKind {
        if (self.flags[0] & 0b10000000) == 0 {
            DnsHeaderKind::Query
        } else {
            DnsHeaderKind::Response
        }
    }

    #[inline(always)]
    pub fn opcode(&self) -> DnsHeaderOpcode {
        (self.flags[0] & 0b01111000).into()
    }

    #[inline(always)]
    pub fn authoritative_answer(&self) -> bool {
        (self.flags[0] & 0b00000100) != 0
    }

    #[inline(always)]
    pub fn truncated(&self) -> bool {
        (self.flags[0] & 0b00000010) != 0
    }

    #[inline(always)]
    pub fn recursion_desired(&self) -> bool {
        (self.flags[0] & 0b00000001) != 0
    }

    #[inline(always)]
    pub fn recursion_available(&self) -> bool {
        (self.flags[1] & 0b10000000) != 0
    }

    #[inline(always)]
    pub fn response_code(&self) -> DnsHeaderResponseCode {
        (self.flags[1] & 0b00001111).into()
    }

    #[inline(always)]
    pub fn question_count(&self) -> u16 {
        u16::from_be_bytes(self.question_count)
    }

    #[inline(always)]
    pub fn answer_count(&self) -> u16 {
        u16::from_be_bytes(self.answer_count)
    }

    #[inline(always)]
    pub fn name_server_count(&self) -> u16 {
        u16::from_be_bytes(self.name_server_count)
    }

    #[inline(always)]
    pub fn additional_records_count(&self) -> u16 {
        u16::from_be_bytes(self.additional_records_count)
    }

    #[inline(always)]
    pub fn set_id(&mut self, id: u16) {
        self.id = id.to_be_bytes();
    }

    #[inline(always)]
    pub fn set_kind(&mut self, kind: DnsHeaderKind) {
        match kind {
            DnsHeaderKind::Query => self.flags[0] &= 0b01111111,
            DnsHeaderKind::Response => self.flags[0] |= 0b10000000,
        }
    }

    #[inline(always)]
    pub fn set_opcode(&mut self, opcode: DnsHeaderOpcode) {
        self.flags[0] &= 0b10000111;
        self.flags[0] |= (u8::from(opcode) & 0b0000_1111) << 3;
    }

    #[inline(always)]
    pub fn set_authoritative_answer(&mut self, authoritative_answer: bool) {
        if authoritative_answer {
            self.flags[0] |= 0b00000100;
        } else {
            self.flags[0] &= 0b11111011;
        }
    }

    #[inline(always)]
    pub fn set_truncated(&mut self, truncated: bool) {
        if truncated {
            self.flags[0] |= 0b00000010;
        } else {
            self.flags[0] &= 0b11111101;
        }
    }

    #[inline(always)]
    pub fn set_recursion_desired(&mut self, recursion_desired: bool) {
        if recursion_desired {
            self.flags[0] |= 0b00000001;
        } else {
            self.flags[0] &= 0b11111110;
        }
    }

    #[inline(always)]
    pub fn set_recursion_available(&mut self, recursion_available: bool) {
        if recursion_available {
            self.flags[1] |= 0b10000000;
        } else {
            self.flags[1] &= 0b01111111;
        }
    }

    #[inline(always)]
    pub fn set_response_code(&mut self, response_code: DnsHeaderResponseCode) {
        self.flags[1] &= 0b11110000;
        self.flags[1] |= u8::from(response_code) & 0b00001111;
    }

    #[inline(always)]
    pub(crate) fn set_question_count(&mut self, question_count: u16) {
        self.question_count = question_count.to_be_bytes();
    }

    #[inline(always)]
    pub(crate) fn set_answer_count(&mut self, answer_count: u16) {
        self.answer_count = answer_count.to_be_bytes();
    }

    #[inline(always)]
    pub(crate) fn set_name_server_count(&mut self, name_server_count: u16) {
        self.name_server_count = name_server_count.to_be_bytes();
    }

    #[inline(always)]
    pub(crate) fn set_additional_records_count(&mut self, additional_records_count: u16) {
        self.additional_records_count = additional_records_count.to_be_bytes();
    }
}

impl core::fmt::Debug for DnsHeader {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("Header")
            .field("id", &self.id())
            .field("kind", &self.kind())
            .field("opcode", &self.opcode())
            .field("authoritative_answer", &self.authoritative_answer())
            .field("truncated", &self.truncated())
            .field("recursion_desired", &self.recursion_desired())
            .field("recursion_available", &self.recursion_available())
            .field("response_code", &self.response_code())
            .field("question_count", &self.question_count())
            .field("answer_count", &self.answer_count())
            .field("name_server_count", &self.name_server_count())
            .field("additional_records_count", &self.additional_records_count())
            .finish()
    }
}

/// The kind of a DNS header.
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum DnsHeaderKind {
    Query,
    Response,
}

/// A DNS opcode.
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum DnsHeaderOpcode {
    Query,
    InverseQuery,
    Status,
    Notify,
    Update,
    Reserved(u8),
}

impl From<u8> for DnsHeaderOpcode {
    fn from(value: u8) -> Self {
        match value {
            0 => DnsHeaderOpcode::Query,
            1 => DnsHeaderOpcode::InverseQuery,
            2 => DnsHeaderOpcode::Status,
            4 => DnsHeaderOpcode::Notify,
            5 => DnsHeaderOpcode::Update,
            _ => DnsHeaderOpcode::Reserved(value),
        }
    }
}

impl From<DnsHeaderOpcode> for u8 {
    fn from(value: DnsHeaderOpcode) -> Self {
        match value {
            DnsHeaderOpcode::Query => 0,
            DnsHeaderOpcode::InverseQuery => 1,
            DnsHeaderOpcode::Status => 2,
            DnsHeaderOpcode::Notify => 4,
            DnsHeaderOpcode::Update => 5,
            DnsHeaderOpcode::Reserved(value) => value,
        }
    }
}

/// A DNS response code.
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum DnsHeaderResponseCode {
    NoError,
    FormatError,
    ServerFailure,
    NonExistentDomain,
    NotImplemented,
    Refused,
    ExistentDomain,
    ExistentRrSet,
    NonExistentRrSet,
    NotAuthoritative,
    NotZone,
    BadOptVersionOrBadSignature,
    BadKey,
    BadTime,
    BadMode,
    BadName,
    BadAlg,
    Reserved(u8),
}

impl From<DnsHeaderResponseCode> for u8 {
    fn from(r: DnsHeaderResponseCode) -> Self {
        match r {
            DnsHeaderResponseCode::NoError => 0,
            DnsHeaderResponseCode::FormatError => 1,
            DnsHeaderResponseCode::ServerFailure => 2,
            DnsHeaderResponseCode::NonExistentDomain => 3,
            DnsHeaderResponseCode::NotImplemented => 4,
            DnsHeaderResponseCode::Refused => 5,
            DnsHeaderResponseCode::ExistentDomain => 6,
            DnsHeaderResponseCode::ExistentRrSet => 7,
            DnsHeaderResponseCode::NonExistentRrSet => 8,
            DnsHeaderResponseCode::NotAuthoritative => 9,
            DnsHeaderResponseCode::NotZone => 10,
            DnsHeaderResponseCode::BadOptVersionOrBadSignature => 16,
            DnsHeaderResponseCode::BadKey => 17,
            DnsHeaderResponseCode::BadTime => 18,
            DnsHeaderResponseCode::BadMode => 19,
            DnsHeaderResponseCode::BadName => 20,
            DnsHeaderResponseCode::BadAlg => 21,
            DnsHeaderResponseCode::Reserved(n) => n,
        }
    }
}

impl From<u8> for DnsHeaderResponseCode {
    fn from(n: u8) -> Self {
        match n {
            0 => DnsHeaderResponseCode::NoError,
            1 => DnsHeaderResponseCode::FormatError,
            2 => DnsHeaderResponseCode::ServerFailure,
            3 => DnsHeaderResponseCode::NonExistentDomain,
            4 => DnsHeaderResponseCode::NotImplemented,
            5 => DnsHeaderResponseCode::Refused,
            6 => DnsHeaderResponseCode::ExistentDomain,
            7 => DnsHeaderResponseCode::ExistentRrSet,
            8 => DnsHeaderResponseCode::NonExistentRrSet,
            9 => DnsHeaderResponseCode::NotAuthoritative,
            10 => DnsHeaderResponseCode::NotZone,
            16 => DnsHeaderResponseCode::BadOptVersionOrBadSignature,
            17 => DnsHeaderResponseCode::BadKey,
            18 => DnsHeaderResponseCode::BadTime,
            19 => DnsHeaderResponseCode::BadMode,
            20 => DnsHeaderResponseCode::BadName,
            21 => DnsHeaderResponseCode::BadAlg,
            n => DnsHeaderResponseCode::Reserved(n),
        }
    }
}

/mnt/h/flex-dns/src/lib.rs

Source (jump to first uncovered line)
#![feature(ip_in_core)]
#![feature(adt_const_params)]
#![feature(generic_const_exprs)]
#![no_std]

extern crate alloc;

use arrayvec::ArrayVec;
use core::marker::ConstParamTy;
use crate::additional::DnsAdditionals;
use crate::answer::DnsAnswers;

use crate::header::DnsHeader;
use crate::name::DnsName;
use crate::name_servers::DnsNameServers;
use crate::parse::Parse;
use crate::question::DnsQuestions;

pub mod header;
pub mod name;
pub mod characters;
pub mod question;
pub mod name_servers;
pub mod additional;
pub mod answer;
pub mod rdata;
mod parse;
mod write;

#[derive(Debug, PartialEq)]
pub enum DnsMessageError {
    DnsError(DnsError),
    BufferError(BufferError),
}

impl From<DnsError> for DnsMessageError {
    fn from(e: DnsError) -> Self {
        DnsMessageError::DnsError(e)
    }
}

impl From<BufferError> for DnsMessageError {
    fn from(e: BufferError) -> Self {
        DnsMessageError::BufferError(e)
    }
}

#[derive(Debug, PartialEq)]
pub enum DnsError {
    MessageTooShort,
    InvalidHeader,
    InvalidQuestion,
    InvalidAnswer,
    InvalidAuthority,
    InvalidAdditional,
    PointerIntoTheFuture,
    PointerCycle,
    NameTooLong,
    LabelTooLong,
    CharacterStringTooLong,
    RDataLongerThanMessage,
    UnexpectedEndOfBuffer,
    InvalidTxtRecord,
}

#[derive(Debug, PartialEq)]
pub enum BufferError {
    OutOfMemory,
    LengthOutOfBounds,
    InvalidLength,
    OffsetOutOfBounds,
}

pub trait Buffer {
    fn len(&self) -> usize;
    fn truncate(&mut self, new_len: usize) -> Result<(), BufferError>;
    fn write_bytes_at(&mut self, offset: usize, data: &[u8]) -> Result<(), BufferError>;
    fn write_array_at<const BYTES: usize>(&mut self, offset: usize, data: [u8; BYTES]) -> Result<(), BufferError>;
    fn write_at(&mut self, offset: usize, data: u8) -> Result<(), BufferError>;
    fn write_bytes(&mut self, data: &[u8]) -> Result<(), BufferError>;
    fn write_array<const BYTES: usize>(&mut self, data: [u8; BYTES]) -> Result<(), BufferError>;
    fn write(&mut self, data: u8) -> Result<(), BufferError>;

    fn read_bytes_at(&self, offset: usize, length: usize) -> Result<&[u8], BufferError>;
    fn read_bytes_at_mut(&mut self, offset: usize, length: usize) -> Result<&mut [u8], BufferError>;
    fn read_at(&self, offset: usize) -> Result<u8, BufferError>;
    fn bytes(&self) -> &[u8];
}

#[inline(always)]
fn check_length<const SIZE: usize>(offset: usize, length: usize) -> Result<(), BufferError> {
    if offset + length > SIZE {
        if offset > SIZE {
            return Err(BufferError::OffsetOutOfBounds);
        }
        return Err(BufferError::LengthOutOfBounds);
    }

    Ok(())
}

impl<const SIZE: usize> Buffer for ArrayVec<u8, SIZE> {
    #[inline(always)]
    fn len(&self) -> usize {
        ArrayVec::len(self)
    }

    #[inline(always)]
    fn truncate(&mut self, new_len: usize) -> Result<(), BufferError> {
        if new_len > self.len() {
            return Err(BufferError::InvalidLength);
        }

        ArrayVec::truncate(self, new_len);
        Ok(())
    }

    #[inline]
    fn write_bytes_at(&mut self, offset: usize, data: &[u8]) -> Result<(), BufferError> {
        check_length::<SIZE>(offset, data.len())?;
        // Grow the buffer to the required size
        unsafe { self.set_len(core::cmp::max(self.len(), offset + data.len())); };
        // Copy the data into the buffer
        self.as_mut_slice()[offset..offset + data.len()].copy_from_slice(data);

        Ok(())
    }

    #[inline]
    fn write_array_at<const BYTES: usize>(&mut self, offset: usize, data: [u8; BYTES]) -> Result<(), BufferError> {
        check_length::<SIZE>(offset, BYTES)?;
        // Grow the buffer to the required size
        unsafe { self.set_len(core::cmp::max(self.len(), offset + BYTES)); };
        self.as_mut_slice()[offset..offset + BYTES].copy_from_slice(&data);

        Ok(())
    }

    #[inline]
    fn write_at(&mut self, offset: usize, data: u8) -> Result<(), BufferError> {
        check_length::<SIZE>(offset, 1)?;
        // Grow the buffer to the required size
        unsafe { self.set_len(core::cmp::max(self.len(), offset + 1)); };
        self.as_mut_slice()[offset] = data;

        Ok(())
    }

    #[inline]
    fn write_bytes(&mut self, data: &[u8]) -> Result<(), BufferError> {
        check_length::<SIZE>(self.len(), data.len())?;
        self.try_extend_from_slice(data).map_err(|_| BufferError::OutOfMemory)?;

        Ok(())
    }

    #[inline]
    fn write_array<const BYTES: usize>(&mut self, data: [u8; BYTES]) -> Result<(), BufferError> {
        check_length::<SIZE>(self.len(), BYTES)?;
        self.try_extend_from_slice(&data).map_err(|_| BufferError::OutOfMemory)?;

        Ok(())
    }

    #[inline]
    fn write(&mut self, data: u8) -> Result<(), BufferError> {
        check_length::<SIZE>(self.len(), 1)?;
        self.push(data);

        Ok(())
    }

    #[inline]
    fn read_bytes_at(&self, offset: usize, length: usize) -> Result<&[u8], BufferError> {
        if offset + length > self.len() {
            if offset > self.len() {
                return Err(BufferError::OffsetOutOfBounds);
            }
            return Err(BufferError::LengthOutOfBounds);
        }

        Ok(&self.as_slice()[offset..offset + length])
    }

    #[inline]
    fn read_bytes_at_mut(&mut self, offset: usize, length: usize) -> Result<&mut [u8], BufferError> {
        check_length::<SIZE>(offset, length)?;
        unsafe { self.set_len(core::cmp::max(self.len(), offset + length)); };
        Ok(&mut self.as_mut_slice()[offset..offset + length])
    }

    #[inline]
    fn read_at(&self, offset: usize) -> Result<u8, BufferError> {
        if offset + 1 > self.len() {
            if offset > self.len() {
                return Err(BufferError::OffsetOutOfBounds);
            }
            return Err(BufferError::LengthOutOfBounds);
        }

        Ok(self.as_slice()[offset])
    }

    #[inline]
    fn bytes(&self) -> &[u8] {
        self.as_slice()
    }
}

#[cfg(feature = "alloc")]
mod vec {
    extern crate alloc;

    use crate::{Buffer, BufferError};

    impl Buffer for alloc::vec::Vec<u8> {
        #[inline]
        fn len(&self) -> usize {
            <alloc::vec::Vec<u8>>::len(self)
        }

        #[inline]
        fn truncate(&mut self, new_len: usize) -> Result<(), BufferError> {
            if new_len > self.len() {
                return Err(BufferError::InvalidLength);
            }

            <alloc::vec::Vec<u8>>::truncate(self, new_len);
            Ok(())
        }

        #[inline]
        fn write_bytes_at(&mut self, offset: usize, data: &[u8]) -> Result<(), BufferError> {
            if offset + data.len() > self.len() {
                if offset > self.len() {
                    return Err(BufferError::OffsetOutOfBounds);
                }
                return Err(BufferError::LengthOutOfBounds);
            }

            self.as_mut_slice()[offset..offset + data.len()].copy_from_slice(data);

            Ok(())
        }

        #[inline]
        fn write_array_at<const BYTES: usize>(&mut self, offset: usize, data: [u8; BYTES]) -> Result<(), BufferError> {
            if offset + BYTES > self.len() {
                if offset > self.len() {
                    return Err(BufferError::OffsetOutOfBounds);
                }
                return Err(BufferError::LengthOutOfBounds);
            }

            self.as_mut_slice()[offset..offset + BYTES].copy_from_slice(&data);

            Ok(())
        }

        #[inline]
        fn write_at(&mut self, offset: usize, data: u8) -> Result<(), BufferError> {
            if offset + 1 > self.len() {
                if offset > self.len() {
                    return Err(BufferError::OffsetOutOfBounds);
                }
                return Err(BufferError::LengthOutOfBounds);
            }

            self.as_mut_slice()[offset] = data;

            Ok(())
        }

        #[inline]
        fn write_bytes(&mut self, data: &[u8]) -> Result<(), BufferError> {
            self.extend_from_slice(data);
            Ok(())
        }

        #[inline]
        fn write_array<const BYTES: usize>(&mut self, data: [u8; BYTES]) -> Result<(), BufferError> {
            self.extend_from_slice(&data);
            Ok(())
        }

        fn write(&mut self, data: u8) -> Result<(), BufferError> {
            self.push(data);
            Ok(())
        }

        #[inline]
        fn read_bytes_at(&self, offset: usize, length: usize) -> Result<&[u8], BufferError> {
            if offset + length > self.len() {
                if offset > self.len() {
                    return Err(BufferError::OffsetOutOfBounds);
                }
                return Err(BufferError::LengthOutOfBounds);
            }

            Ok(&self.as_slice()[offset..offset + length])
        }

        #[inline]
        fn read_bytes_at_mut(&mut self, offset: usize, length: usize) -> Result<&mut [u8], BufferError> {
            if offset + length > self.len() {
                if offset > self.len() {
                    return Err(BufferError::OffsetOutOfBounds);
                }
                return Err(BufferError::LengthOutOfBounds);
            }

            Ok(&mut self.as_mut_slice()[offset..offset + length])
        }

        #[inline]
        fn read_at(&self, offset: usize) -> Result<u8, BufferError> {
            if offset + 1 > self.len() {
                if offset > self.len() {
                    return Err(BufferError::OffsetOutOfBounds);
                }
                return Err(BufferError::LengthOutOfBounds);
            }

            Ok(self.as_slice()[offset])
        }

        #[inline]
        fn bytes(&self) -> &[u8] {
            self.as_slice()
        }
    }
}


const DNS_HEADER_SIZE: usize = 12;

#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, ConstParamTy)]
pub enum DnsSection {
    Questions,
    Answers,
    NameServers,
    Additionals,
}

pub struct DnsMessage<
    const PTR_STORAGE: usize,
    const DNS_SECTION: DnsSection,
    B: Buffer,
> {
    buffer: B,
    position: usize,
    // Pointers are stored as offsets from the start of the buffer
    // We dont need this for reading, but we need it for writing compressed pointers
    ptr_storage: ArrayVec<usize, PTR_STORAGE>,
}

macro_rules! to_section_impl {
    ($from:expr, $to:expr) => {
        impl<
            const PTR_STORAGE: usize,
            B: Buffer,
        > DnsMessage<PTR_STORAGE, { $from }, B> {
            #[inline]
            pub fn next_section(self) -> DnsMessage<PTR_STORAGE, { $to }, B> {
                DnsMessage {
                    buffer: self.buffer,
                    position: self.position,
                    ptr_storage: self.ptr_storage,
                }
            }
        }
    };
}

to_section_impl!(DnsSection::Questions, DnsSection::Answers);
to_section_impl!(DnsSection::Answers, DnsSection::NameServers);
to_section_impl!(DnsSection::NameServers, DnsSection::Additionals);

impl<
    const PTR_STORAGE: usize,
    const SECTION: DnsSection,
    B: Buffer,
> DnsMessage<PTR_STORAGE, SECTION, B> {
    #[inline]
    pub fn new(mut buffer: B) -> Result<Self, DnsMessageError> {
        if buffer.len() < DNS_HEADER_SIZE {
            buffer.write_bytes(&[0; DNS_HEADER_SIZE])?;
        }

        Ok(Self {
            buffer,
            position: DNS_HEADER_SIZE,
            ptr_storage: ArrayVec::new(),
        })
    }

    #[inline(always)]
    pub(crate) fn buffer_and_position(&mut self) -> (&mut B, &mut usize) {
        (&mut self.buffer, &mut self.position)
    }

    #[inline(always)]
    pub fn reset(self) -> DnsMessage<PTR_STORAGE, { DnsSection::Questions }, B> {
        DnsMessage {
            buffer: self.buffer,
            position: 0,
            ptr_storage: self.ptr_storage,
        }
    }

    #[inline(always)]
    pub fn complete(self) -> Result<B, DnsMessageError> {
        Ok(self.buffer)
    }

    #[inline]
    pub fn header_mut(&mut self) -> Result<&mut DnsHeader, DnsMessageError> {
        self.position = core::cmp::max(self.position, DNS_HEADER_SIZE);
        Ok(DnsHeader::from_bytes_mut(
            self.buffer.read_bytes_at_mut(0, DNS_HEADER_SIZE)?
        ))
    }

    #[inline]
    pub fn header(&self) -> Result<&DnsHeader, DnsMessageError> {
        if self.buffer.len() < DNS_HEADER_SIZE {
            return Err(DnsMessageError::DnsError(DnsError::MessageTooShort));
        }

        Ok(DnsHeader::from_bytes(
            self.buffer.read_bytes_at(0, DNS_HEADER_SIZE)?
        ))
    }

    #[inline(always)]
    pub(crate) fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), DnsMessageError> {
        self.position += bytes.len();

        Ok(self.buffer.write_bytes(bytes)?)
    }

    pub(crate) fn write_name(
        &mut self,
        name: DnsName,
    ) -> Result<(), DnsMessageError> {
        // Try to find match
        for idx in self.ptr_storage.iter().copied() {
            let mut i = idx;
            let name_at_idx = DnsName::parse(self.buffer.bytes(), &mut i)?;
            if name_at_idx == name {
                self.write_bytes(&(idx as u16 | 0b1100_0000_0000_0000).to_be_bytes())?;
                return Ok(());
            }
        }

        // No match found, write name
        let (first, rest) = name.split_first()?;
        let original_position = self.position;
        self.write_bytes(&[first.len() as u8])?;
        self.write_bytes(first)?;

        if let Some(rest) = rest {
            self.write_name(rest)?;
        } else {
            self.write_bytes(&[0])?; // Null terminator
        }
        if self.ptr_storage.len() < PTR_STORAGE {
            // Store pointer for later, if we have space
            // If we dont have space, we just write the name uncompressed
            // in the future
            self.ptr_storage.push(original_position);
        }

        Ok(())
    }
}

impl<
    const PTR_STORAGE: usize,
    B: Buffer,
> DnsMessage<PTR_STORAGE, { DnsSection::Questions }, B> {
    #[inline(always)]
    pub fn questions(self) -> DnsQuestions<PTR_STORAGE, B> {
        DnsQuestions::new(self)
    }
}

impl<
    const PTR_STORAGE: usize,
    B: Buffer,
> DnsMessage<PTR_STORAGE, { DnsSection::Answers }, B> {
    pub fn answers(self) -> DnsAnswers<PTR_STORAGE, B> {
        DnsAnswers::new(self)
    }
}

impl<
    const PTR_STORAGE: usize,
    B: Buffer,
> DnsMessage<PTR_STORAGE, { DnsSection::NameServers }, B> {
    pub fn name_servers(self) -> DnsNameServers<PTR_STORAGE, B> {
        DnsNameServers::new(self)
    }
}

impl<
    const PTR_STORAGE: usize,
    B: Buffer,
> DnsMessage<PTR_STORAGE, { DnsSection::Additionals }, B> {
    pub fn additionals(self) -> DnsAdditionals<PTR_STORAGE, B> {
        DnsAdditionals::new(self)
    }
}

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

    mod question {
        use crate::header::{DnsHeaderOpcode, DnsHeaderResponseCode};
        use crate::question::{DnsQClass, DnsQType, DnsQuestion};
        use super::*;

        #[test]
        fn test_question() {
            let buffer: ArrayVec<u8, 512> = ArrayVec::new();
            let mut message: DnsMessage<8, { DnsSection::Questions }, _> = DnsMessage::new(buffer).unwrap();
            message.header_mut().unwrap().set_id(0x1234);
            message.header_mut().unwrap().set_opcode(DnsHeaderOpcode::Query);
            message.header_mut().unwrap().set_authoritative_answer(false);
            message.header_mut().unwrap().set_truncated(false);
            message.header_mut().unwrap().set_recursion_desired(false);
            message.header_mut().unwrap().set_recursion_available(false);
            message.header_mut().unwrap().set_response_code(DnsHeaderResponseCode::NoError);
            let mut questions = message.questions();
            questions.append(DnsQuestion {
                name: DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap(),
                qtype: DnsQType::A,
                qclass: DnsQClass::IN,
            }).unwrap();
            let message = questions.complete().unwrap();
            let buffer = message.complete().unwrap();

            assert_eq!(buffer.as_slice(), [
                0x12, 0x34, // ID
                0b0000_0000, 0b0000_0000, // Flags
                0x00, 0x01, // Question count
                0x00, 0x00, // Answer count
                0x00, 0x00, // Authority count
                0x00, 0x00, // Additional count
                0x03, b'w', b'w', b'w', // Name
                0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e', // Name
                0x03, b'c', b'o', b'm', // Name
                0x00, // Name
                0x00, 0x01, // Type
                0x00, 0x01, // Class
            ].as_slice());

            // Decode
            let message: DnsMessage<8, { DnsSection::Questions }, _> = DnsMessage::new(buffer).unwrap();
            assert_eq!(message.header().unwrap().id(), 0x1234);
            assert_eq!(message.header().unwrap().opcode(), DnsHeaderOpcode::Query);
            assert_eq!(message.header().unwrap().authoritative_answer(), false);
            assert_eq!(message.header().unwrap().truncated(), false);
            assert_eq!(message.header().unwrap().recursion_desired(), false);
            assert_eq!(message.header().unwrap().recursion_available(), false);
            assert_eq!(message.header().unwrap().response_code(), DnsHeaderResponseCode::NoError);
            let mut questions = message.questions();
            let mut question_iter = questions.iter().unwrap();
            let question = question_iter.next().unwrap().unwrap();
            assert_eq!(question.name, DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap());
            assert_eq!(question.qtype, DnsQType::A);
            assert_eq!(question.qclass, DnsQClass::IN);
            assert!(question_iter.next().is_none());
        }

        #[test]
        fn query_google_com() {
            let buffer = ArrayVec::from([
                0x00, 0x03, // ID
                0x01, 0x00, // Flags
                0x00, 0x01, // Question count
                0x00, 0x00, // Answer count
                0x00, 0x00, // Authority count
                0x00, 0x00, // Additional count
                0x06, b'g', b'o', b'o', b'g', b'l', b'e', // Name
                0x03, b'c', b'o', b'm', // Name
                0x00, // Name
                0x00, 0x01, // Type
                0x00, 0x01, // Class
            ]);
            let message: DnsMessage<8, { DnsSection::Questions }, _> = DnsMessage::new(buffer).unwrap();
            assert_eq!(message.header().unwrap().id(), 0x0003);
            assert_eq!(message.header().unwrap().opcode(), DnsHeaderOpcode::Query);
            assert_eq!(message.header().unwrap().authoritative_answer(), false);
            assert_eq!(message.header().unwrap().truncated(), false);
            assert_eq!(message.header().unwrap().recursion_desired(), true);
            assert_eq!(message.header().unwrap().recursion_available(), false);
            assert_eq!(message.header().unwrap().response_code(), DnsHeaderResponseCode::NoError);
            let mut questions = message.questions();
            let mut question_iter = questions.iter().unwrap();
            let question = question_iter.next().unwrap().unwrap();
            assert_eq!(question.name, DnsName::from_bytes(b"\x06google\x03com\x00").unwrap());
            assert_eq!(question.qtype, DnsQType::A);
            assert_eq!(question.qclass, DnsQClass::IN);
            assert!(question_iter.next().is_none());
        }

        #[test]
        fn multiple_questions_compression() {
            let buffer: ArrayVec<u8, 512> = ArrayVec::new();
            let mut message: DnsMessage<8, { DnsSection::Questions }, _> = DnsMessage::new(buffer).unwrap();
            message.header_mut().unwrap().set_id(0x1234);
            message.header_mut().unwrap().set_opcode(DnsHeaderOpcode::Query);
            message.header_mut().unwrap().set_authoritative_answer(false);
            message.header_mut().unwrap().set_truncated(false);
            message.header_mut().unwrap().set_recursion_desired(false);
            message.header_mut().unwrap().set_recursion_available(false);
            message.header_mut().unwrap().set_response_code(DnsHeaderResponseCode::NoError);
            let mut questions = message.questions();
            questions.append(DnsQuestion {
                name: DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap(),
                qtype: DnsQType::A,
                qclass: DnsQClass::IN,
            }).unwrap();
            questions.append(DnsQuestion {
                name: DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap(),
                qtype: DnsQType::AAAA,
                qclass: DnsQClass::IN,
            }).unwrap();
            questions.append(DnsQuestion {
                name: DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap(),
                qtype: DnsQType::MX,
                qclass: DnsQClass::IN,
            }).unwrap();
            questions.append(DnsQuestion {
                name: DnsName::from_bytes(b"\x03www\x08examples\x03com\x00").unwrap(),
                qtype: DnsQType::TXT,
                qclass: DnsQClass::IN,
            }).unwrap();
            questions.append(DnsQuestion {
                name: DnsName::from_bytes(b"\x08examples\x03com\x00").unwrap(),
                qtype: DnsQType::CERT,
                qclass: DnsQClass::IN,
            }).unwrap();
            let message = questions.complete().unwrap();
            let buffer = message.complete().unwrap();

            assert_eq!(
                buffer.as_slice(),
                [
                    0x12, 0x34, // ID
                    0b0000_0000, 0b0000_0000, // Flags
                    0x00, 0x05, // Question count
                    0x00, 0x00, // Answer count
                    0x00, 0x00, // Authority count
                    0x00, 0x00, // Additional count
                    0x03, b'w', b'w', b'w', // Name
                    0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e', // Name
                    0x03, b'c', b'o', b'm', // Name
                    0x00, // Name
                    0x00, 0x01, // Type
                    0x00, 0x01, // Class
                    0xC0, 0x0C, // Name Pointer (0x0C = 12)
                    0x00, 0x1C, // Type
                    0x00, 0x01, // Class
                    0xC0, 0x0C, // Name Pointer (0x0C = 12)
                    0x00, 0x0F, // Type
                    0x00, 0x01, // Class
                    0x03, b'w', b'w', b'w', // Name
                    0x08, b'e', b'x', b'a', b'm', b'p', b'l', b'e', b's', // Name
                    0xC0, 0x18, // Name Pointer (0x18 = 24)
                    0x00, 0x10, // Type
                    0x00, 0x01, // Class
                    0xC0, 0x31, // Name Pointer (0x31 = 48)
                    0x00, 0x25, // Type
                    0x00, 0x01, // Class
                ].as_slice()
            );

            // Decode the message again and check that it is the same
            let message: DnsMessage<8, { DnsSection::Questions }, _> = DnsMessage::new(buffer).unwrap();
            assert_eq!(message.header().unwrap().id(), 0x1234);
            assert_eq!(message.header().unwrap().opcode(), DnsHeaderOpcode::Query);
            assert_eq!(message.header().unwrap().authoritative_answer(), false);
            assert_eq!(message.header().unwrap().truncated(), false);
            assert_eq!(message.header().unwrap().recursion_desired(), false);
            assert_eq!(message.header().unwrap().recursion_available(), false);
            assert_eq!(message.header().unwrap().response_code(), DnsHeaderResponseCode::NoError);
            let mut questions = message.questions();
            let mut question_iter = questions.iter().unwrap();
            let question = question_iter.next().unwrap().unwrap();
            assert_eq!(question.name, DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap());
            assert_eq!(question.qtype, DnsQType::A);
            assert_eq!(question.qclass, DnsQClass::IN);
            let question = question_iter.next().unwrap().unwrap();
            assert_eq!(question.name, DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap());
            assert_eq!(question.qtype, DnsQType::AAAA);
            assert_eq!(question.qclass, DnsQClass::IN);
            let question = question_iter.next().unwrap().unwrap();
            assert_eq!(question.name, DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap());
            assert_eq!(question.qtype, DnsQType::MX);
            assert_eq!(question.qclass, DnsQClass::IN);
            let question = question_iter.next().unwrap().unwrap();
            assert_eq!(question.name, DnsName::from_bytes(b"\x03www\x08examples\x03com\x00").unwrap());
            assert_eq!(question.qtype, DnsQType::TXT);
            assert_eq!(question.qclass, DnsQClass::IN);
            let question = question_iter.next().unwrap().unwrap();
            assert_eq!(question.name, DnsName::from_bytes(b"\x08examples\x03com\x00").unwrap());
            assert_eq!(question.qtype, DnsQType::CERT);
            assert_eq!(question.qclass, DnsQClass::IN);
            assert!(question_iter.next().is_none());
        }
    }

    mod answer {
        use core::net::Ipv4Addr;
        use crate::answer::{DnsAClass, DnsAnswer};
        use crate::header::{DnsHeaderOpcode, DnsHeaderResponseCode};
        use crate::rdata::{A, DnsAType};
        use super::*;

        #[test]
        fn single_answer() {
            let buffer: ArrayVec<u8, 512> = ArrayVec::new();
            let mut message: DnsMessage<8, { DnsSection::Questions }, _> = DnsMessage::new(buffer).unwrap();
            message.header_mut().unwrap().set_id(0x1234);
            message.header_mut().unwrap().set_opcode(DnsHeaderOpcode::Query);
            message.header_mut().unwrap().set_authoritative_answer(false);
            message.header_mut().unwrap().set_truncated(false);
            message.header_mut().unwrap().set_recursion_desired(false);
            message.header_mut().unwrap().set_recursion_available(false);
            message.header_mut().unwrap().set_response_code(DnsHeaderResponseCode::NoError);
            let message = message.questions().complete().unwrap();
            let message = {
                let mut answers = message.answers();
                answers.append(DnsAnswer {
                    name: DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap(),
                    aclass: DnsAClass::IN,
                    ttl: 0x12345678,
                    rdata: DnsAType::A(A { address: Ipv4Addr::new(127, 0, 0, 1) }),
                    cache_flush: false,
                }).unwrap();
                answers.complete().unwrap()
            };
            let buffer = message.complete().unwrap();

            assert_eq!(
                buffer.as_slice(),
                [
                    0x12, 0x34, // ID
                    0b0000_0000, 0b0000_0000, // Flags
                    0x00, 0x00, // Question count
                    0x00, 0x01, // Answer count
                    0x00, 0x00, // Authority count
                    0x00, 0x00, // Additional count
                    0x03, b'w', b'w', b'w', // Name
                    0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e', // Name
                    0x03, b'c', b'o', b'm', // Name
                    0x00, // Name
                    0x00, 0x01, // Type
                    0x00, 0x01, // Class
                    0x12, 0x34, 0x56, 0x78, // TTL
                    0x00, 0x04, // Data length
                    127, 0, 0, 1, // Data
                ].as_slice()
            );

            // Decode the message again and check that it is the same
            let message: DnsMessage<8, { DnsSection::Answers }, _> = DnsMessage::new(buffer).unwrap();
            assert_eq!(message.header().unwrap().id(), 0x1234);
            assert_eq!(message.header().unwrap().opcode(), DnsHeaderOpcode::Query);
            assert_eq!(message.header().unwrap().authoritative_answer(), false);
            assert_eq!(message.header().unwrap().truncated(), false);
            assert_eq!(message.header().unwrap().recursion_desired(), false);
            assert_eq!(message.header().unwrap().recursion_available(), false);
            assert_eq!(message.header().unwrap().response_code(), DnsHeaderResponseCode::NoError);
            let mut answers = message.answers();
            let mut answer_iter = answers.iter().unwrap();
            let answer = answer_iter.next().unwrap().unwrap();
            assert_eq!(answer.name, DnsName::from_bytes(b"\x03www\x07example\x03com\x00").unwrap());
            assert_eq!(answer.ttl, 0x12345678);
            assert_eq!(answer.into_parsed().unwrap().rdata, DnsAType::A(A { address: Ipv4Addr::new(127, 0, 0, 1) }));
            assert!(answer_iter.next().is_none());
        }
    }

    mod error {
        use crate::header::{DnsHeaderOpcode, DnsHeaderResponseCode};
        use super::*;

        #[test]
        fn truncated() {
            let buffer: ArrayVec<u8, 12> = ArrayVec::from([
                0x12, 0x34, // ID
                0b0000_0000, 0b0000_0000, // Flags
                0x00, 0x01, // Question count
                0x00, 0x00, // Answer count
                0x00, 0x00, // Authority count
                0x00, 0x00, // Additional count
                // Premature end of message
            ]);
            let message: DnsMessage<8, { DnsSection::Questions }, _> = DnsMessage::new(buffer).unwrap();
            assert_eq!(message.header().unwrap().id(), 0x1234);
            assert_eq!(message.header().unwrap().opcode(), DnsHeaderOpcode::Query);
            assert_eq!(message.header().unwrap().authoritative_answer(), false);
            assert_eq!(message.header().unwrap().truncated(), false);
            assert_eq!(message.header().unwrap().recursion_desired(), false);
            assert_eq!(message.header().unwrap().recursion_available(), false);
            assert_eq!(message.header().unwrap().response_code(), DnsHeaderResponseCode::NoError);
            let mut questions = message.questions();
            let mut question_iter = questions.iter().unwrap();
            assert_eq!(
                question_iter.next(),
                Some(Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer)))
            );
        }
    }
}

/mnt/h/flex-dns/src/name.rs

Source (jump to first uncovered line)
use core::fmt::{Debug, Display, Formatter};
use arrayvec::ArrayVec;
use crate::{Buffer, DnsError, DnsMessage, DnsMessageError, DnsSection};
use crate::parse::ParseBytes;

const MAX_DOMAIN_NAME_LENGTH: usize = 255;
const MAX_DOMAIN_NAME_DEPTH: usize = 128;
const MAX_DOMAIN_NAME_LABEL_LENGTH: usize = 63;

/// A DNS name.
#[derive(Clone, Copy)]
pub struct DnsName<'a> {
    bytes: &'a [u8],
    offset: usize,
}

#[macro_export]
macro_rules! dns_name {
    ($value:expr $(,)?) => {
        {
            const NAME: [u8; $value.len() + 2] = {
                let mut result = [0; $value.len() + 2];
                let mut label_start = 0;
                let mut index = 0;
                loop {
                    if index == $value.len() {
                        result[label_start] = (index - label_start) as u8;

                        break;
                    }

                    let byte = $value[index];
                    if byte == b'.' {
                        result[label_start] = (index - label_start) as u8;
                        label_start = index + 1;
                    } else {
                        result[index + 1] = byte;
                    }

                    index += 1;
                }

                result
            };
            unsafe { DnsName::from_bytes_unchecked(&NAME) }
        }
    };
}

impl<'a> ParseBytes<'a> for DnsName<'a> {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        const MAX_LENGTH: usize = 255;
        let mut j = *i;

        loop {
            if j - *i >= MAX_LENGTH {
                return Err(DnsMessageError::DnsError(DnsError::NameTooLong));
            }

            match LabelType::from_bytes(bytes, &mut j)? {
                LabelType::Pointer(_) => {
                    break;
                }
                LabelType::Part(len) => {
                    j += len as usize;

                    if len == 0 {
                        break;
                    }

                    if len > MAX_DOMAIN_NAME_LABEL_LENGTH as u8 {
                        return Err(DnsMessageError::DnsError(DnsError::LabelTooLong));
                    }
                }
            }
        }

        let offset = *i;
        *i = j;

        Ok(Self { bytes, offset })
    }
}

impl<'a> DnsName<'a> {
    /// Create a new name from a string (Dot-separated labels).
    pub fn from_str(s: &'a mut str) -> Self {
        // Check that the name is ascii and that it is not too long.
        assert!(s.is_ascii());
        assert!(s.len() <= MAX_DOMAIN_NAME_LENGTH);
        let bytes = unsafe { s.as_bytes_mut() };

        let mut l = 0; // The length of the current label.
        let mut iter = bytes.iter_mut();
        let mut part_len_byte = iter.next().unwrap();
        let mut last_byte = *part_len_byte; // The last byte visited.
        while let Some(byte) = iter.next() {
            let b = *byte;

            if b == b'.' {
                // We've reached the end of a label.
                *part_len_byte = l as u8;
                l = 0;
                *byte = last_byte;
                part_len_byte = iter.next().unwrap();
                last_byte = *part_len_byte;
            } else {
                // We're still in the middle of a label.
                l += 1;
                *byte = last_byte;
                last_byte = b;
            }
        }

        Self { bytes, offset: 0 }
    }

    /// Read a name from a byte buffer (DNS wire format).
    pub fn from_bytes(bytes: &'a [u8]) -> Result<Self, DnsMessageError> {
        for part in (NameIterator {
            bytes,
            offset: 0,
            depth: ArrayVec::new(),
        }) {
            part?;
        }

        Ok(Self { bytes, offset: 0 })
    }

    /// Read a name from a byte buffer (DNS wire format).
    pub const unsafe fn from_bytes_unchecked(bytes: &'a [u8]) -> Self {
        Self { bytes, offset: 0 }
    }

    #[inline(always)]
    pub fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_name(*self)
    }

    pub fn iter(&self) -> NameIterator<'a> {
        NameIterator {
            bytes: self.bytes,
            offset: self.offset,
            depth: ArrayVec::new(),
        }
    }

    pub fn split_first(&self) -> Result<(&'a [u8], Option<Self>), DnsMessageError> {
        let mut iter = self.iter();
        let first = iter.next().unwrap()?;
        if let Some(next) = iter.next() {
            let next = next?;

            // Calculate offset from address of the second pointer.
            let offset = next.as_ptr() as usize - self.bytes.as_ptr() as usize - 1;

            Ok((first, Some(Self {
                bytes: self.bytes,
                offset,
            })))
        } else {
            Ok((first, None))
        }
    }

    pub fn verify(&self) -> Result<(), DnsMessageError> {
        for part in self.iter() {
            part?;
        }

        Ok(())
    }

    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        self.iter().map(|part| part.map(|part| part.len() + 1)).sum()
    }
}

pub struct NameIterator<'a> {
    bytes: &'a [u8],
    offset: usize,
    depth: ArrayVec<usize, MAX_DOMAIN_NAME_DEPTH>,
}

impl<'a> Iterator for NameIterator<'a> {
    type Item = Result<&'a [u8], DnsMessageError>;

    fn next(&mut self) -> Option<Self::Item> {
        let mut i = self.offset;
        loop {
            self.depth.push(i);
            if self.depth.len() >= MAX_DOMAIN_NAME_DEPTH {
                return None;
            }

            match LabelType::from_bytes(self.bytes, &mut i).unwrap() {
                LabelType::Pointer(ptr) => {
                    if ptr < self.offset as u16 {
                        // The pointer points to an earlier part of the message.
                        i = ptr as usize;

                        if self.depth.contains(&i) {
                            // The pointer points to a part of the message that we've already visited.
                            return Some(Err(DnsMessageError::DnsError(DnsError::PointerCycle)));
                        }

                        continue;
                    } else {
                        // The pointer points into the future.
                        return Some(Err(DnsMessageError::DnsError(DnsError::PointerIntoTheFuture)));
                    }
                }
                LabelType::Part(len) => {
                    if len == 0 {
                        // We've reached the end of the name.
                        return None;
                    }

                    if len > MAX_DOMAIN_NAME_LABEL_LENGTH as u8 {
                        return Some(Err(DnsMessageError::DnsError(DnsError::LabelTooLong)));
                    }

                    if self.bytes.len() < i + len as usize {
                        // The name is longer than the buffer.
                        return Some(Err(DnsMessageError::DnsError(DnsError::MessageTooShort)));
                    }

                    let part = &self.bytes[i..i + len as usize];
                    self.offset = i + len as usize;

                    return Some(Ok(part))
                }
            }
        }
    }
}

impl PartialEq<DnsName<'_>> for DnsName<'_> {
    fn eq(&self, other: &DnsName<'_>) -> bool {
        for (a, b) in self.iter().zip(other.iter()) {
            match (a, b) {
                (Ok(a), Ok(b)) => {
                    if a != b {
                        return false;
                    }
                }
                _ => {
                    return false;
                }
            }
        }

        true
    }
}

impl Display for DnsName<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        let mut first = true;
        for part in self.iter() {
            if first {
                first = false;
            } else {
                f.write_str(".")?;
            }

            let part = part.map_err(|_| core::fmt::Error)?;
            f.write_str(core::str::from_utf8(part).unwrap())?;
        }

        Ok(())
    }
}

impl Debug for DnsName<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        f.write_str("DnsName(")?;
        Display::fmt(self, f)?;
        f.write_str(")")?;

        Ok(())
    }
}

#[derive(PartialEq)]
enum LabelType {
    Pointer(u16),
    Part(u8),
}

impl LabelType {
    fn from_bytes(bytes: &[u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        const PTR_MASK: u8 = 0b11000000;
        const LEN_MASK: u8 = !PTR_MASK;

        let c = u8::parse_bytes(bytes, i)?;

        if c & PTR_MASK == PTR_MASK {
            let c = c & LEN_MASK;
            let pointer = u16::from_be_bytes([c, u8::parse_bytes(bytes, i)?]);
            if pointer >= *i as u16 {
                // Cannot point to the future.
                return Err(DnsMessageError::DnsError(DnsError::PointerIntoTheFuture));
            }

            Ok(Self::Pointer(pointer))
        } else {
            let len = c & LEN_MASK;

            Ok(Self::Part(len))
        }
    }
}

/mnt/h/flex-dns/src/name_servers.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::answer::DnsAClass;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::question::DnsQType;
use crate::rdata::{DnsAType, RData};
use crate::write::WriteBytes;

pub struct DnsNameServers<
    const PTR_STORAGE: usize,
    B: Buffer,
> {
    message: DnsMessage<PTR_STORAGE, { DnsSection::NameServers }, B>,
    remaining: usize,
}

impl<
    const PTR_STORAGE: usize,
    B: Buffer,
> DnsNameServers<PTR_STORAGE, B> {
    #[inline(always)]
    pub(crate) fn new(message: DnsMessage<PTR_STORAGE, { DnsSection::NameServers }, B>) -> Self {
        let remaining = message.header().unwrap().answer_count() as usize;
        Self {
            message,
            remaining,
        }
    }

    pub fn append(&mut self, answer: NameServer<DnsAType>) -> Result<(), DnsMessageError> {
        let (buffer, position) = self.message.buffer_and_position();
        // Truncate the buffer to the current position.
        buffer.truncate(*position)?;
        answer.write(&mut self.message)?;
        // Set answer_count in the header to the current answer count + 1.
        let answer_count = self.message.header().unwrap().answer_count();
        let answer_count = answer_count + 1 - self.remaining as u16;
        self.message.header_mut()?.set_answer_count(answer_count);
        self.message.header_mut()?.set_name_server_count(0);
        self.message.header_mut()?.set_additional_records_count(0);
        self.remaining = 0;

        Ok(())
    }

    #[inline]
    pub fn iter(&mut self) -> Result<DnsNameServersIterator, DnsMessageError> {
        let (buffer, position) = self.message.buffer_and_position();
        let buffer = buffer.bytes();

        Ok(DnsNameServersIterator {
            buffer,
            current_position: position,
            remaining: &mut self.remaining,
        })
    }

    #[inline]
    pub fn complete(mut self) -> Result<DnsMessage<PTR_STORAGE, { DnsSection::Additionals }, B>, DnsMessageError> {
        if self.remaining != 0 {
            for x in self.iter()? { x?; }
        }

        Ok(DnsMessage {
            buffer: self.message.buffer,
            position: self.message.position,
            ptr_storage: self.message.ptr_storage,
        })
    }
}

pub struct DnsNameServersIterator<'a> {
    buffer: &'a [u8],
    current_position: &'a mut usize,
    remaining: &'a mut usize,
}

impl<'a> Iterator for DnsNameServersIterator<'a> {
    type Item = Result<NameServer<'a, RData<'a>>, DnsMessageError>;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        if *self.remaining == 0 {
            return None;
        }

        let name_server = NameServer::parse(
            self.buffer, self.current_position
        );
        *self.remaining -= 1;

        Some(name_server)
    }
}

#[derive(Debug, PartialEq)]
pub struct NameServer<'a, D> {
    pub name: DnsName<'a>,
    pub rdata: D,
    pub cache_flush: bool,
    pub aclass: DnsAClass,
    pub ttl: u32,
}

impl<'a> NameServer<'a, RData<'a>> {
    pub fn parse(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        let name = DnsName::parse(bytes, i)?;
        let atype_id = u16::parse(bytes, i)?;
        let atype = DnsQType::from_id(atype_id);
        let cache_flush = atype_id & 0b1000_0000_0000_0000 != 0;
        let aclass = DnsAClass::from_id(u16::parse(bytes, i)?);
        let ttl = u32::parse(bytes, i)?;
        let rdata = RData::parse(bytes, i, atype)?;

        Ok(Self {
            name,
            rdata,
            cache_flush,
            aclass,
            ttl,
        })
    }

    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        // Write the name to the buffer using the pointer storage for compression.
        message.write_name(self.name)?;
        // Write the atype and aclass to the buffer.
        self.rdata.id().write(message)?;
        let mut aclass = self.aclass.id();
        if self.cache_flush {
            aclass |= 0b1000_0000;
        }
        aclass.write(message)?;
        // Write the ttl to the buffer.
        self.ttl.write(message)?;
        (self.rdata.byte_len()? as u16).write(message)?;
        // Write the type specific data to the buffer.
        self.rdata.write(message)?;

        Ok(())
    }

    pub fn into_parsed(self) -> Result<NameServer<'a, DnsAType<'a>>, DnsMessageError> {
        Ok(NameServer {
            name: self.name,
            rdata: self.rdata.into_parsed()?,
            cache_flush: self.cache_flush,
            aclass: self.aclass,
            ttl: self.ttl,
        })
    }
}

impl<'a> NameServer<'a, DnsAType<'a>> {
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        // Write the name to the buffer using the pointer storage for compression.
        self.name.write(message)?;
        // Write the atype and aclass to the buffer.
        self.rdata.id().write(message)?;
        let mut aclass = self.aclass.id();
        if self.cache_flush {
            aclass |= 0b1000_0000;
        }
        aclass.write(message)?;
        // Write the ttl to the buffer.
        self.ttl.write(message)?;
        let rdata_len = self.rdata.byte_len()? as u16;
        rdata_len.write(message)?;
        // Write the type specific data to the buffer.
        self.rdata.write(message)?;

        Ok(())
    }
}

/mnt/h/flex-dns/src/parse.rs

Source
use core::net::{Ipv4Addr, Ipv6Addr};
use crate::{DnsError, DnsMessageError};

pub(crate) trait ParseData<'a> {
    fn parse_data(&self) -> &'a [u8];
}

impl<'a> ParseData<'a> for &'a [u8] {
    #[inline(always)]
    fn parse_data(&self) -> &'a [u8] {
        *self
    }
}

pub(crate) trait Parse<'a>: Sized {
    fn parse<T: ParseData<'a>>(bytes: T, i: &mut usize) -> Result<Self, DnsMessageError>;
}

impl<'a, S: ParseBytes<'a>> Parse<'a> for S {
    #[inline(always)]
    fn parse<T: ParseData<'a>>(bytes: T, i: &mut usize) -> Result<Self, DnsMessageError> {
        Self::parse_bytes(bytes.parse_data(), i)
    }
}

pub(crate) trait ParseBytes<'a>: Sized {
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError>;
}

impl<'a> ParseBytes<'a> for u8 {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        if bytes.len() < *i + 1 {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let value = bytes[*i];
        *i += 1;

        Ok(value)
    }
}

impl<'a> ParseBytes<'a> for u16 {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        if bytes.len() < *i + 2 {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let value = u16::from_be_bytes([
            bytes[*i],
            bytes[*i + 1]
        ]);
        *i += 2;

        Ok(value)
    }
}

impl<'a> ParseBytes<'a> for u32 {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        if bytes.len() < *i + 4 {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let value = u32::from_be_bytes([
            bytes[*i],
            bytes[*i + 1],
            bytes[*i + 2],
            bytes[*i + 3]
        ]);
        *i += 4;

        Ok(value)
    }
}

impl<'a> ParseBytes<'a> for u64 {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        if bytes.len() < *i + 8 {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let value = u64::from_be_bytes([
            bytes[*i],
            bytes[*i + 1],
            bytes[*i + 2],
            bytes[*i + 3],
            bytes[*i + 4],
            bytes[*i + 5],
            bytes[*i + 6],
            bytes[*i + 7]
        ]);
        *i += 8;

        Ok(value)
    }
}

impl<'a, const SIZE: usize> ParseBytes<'a> for [u8; SIZE] {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        if bytes.len() < *i + SIZE {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let mut value = [0u8; SIZE];
        value.copy_from_slice(&bytes[*i..*i + SIZE]);
        *i += SIZE;

        Ok(value)
    }
}

impl<'a> ParseBytes<'a> for Ipv4Addr {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        if bytes.len() < *i + 4 {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let address = Ipv4Addr::new(
            bytes[*i],
            bytes[*i + 1],
            bytes[*i + 2],
            bytes[*i + 3]
        );
        *i += 4;

        Ok(address)
    }
}

impl<'a> ParseBytes<'a> for Ipv6Addr {
    #[inline]
    fn parse_bytes(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        if bytes.len() < *i + 16 {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let address = Ipv6Addr::new(
            ((bytes[*i] as u16) << 8) | (bytes[*i + 1] as u16),
            ((bytes[*i + 2] as u16) << 8) | (bytes[*i + 3] as u16),
            ((bytes[*i + 4] as u16) << 8) | (bytes[*i + 5] as u16),
            ((bytes[*i + 6] as u16) << 8) | (bytes[*i + 7] as u16),
            ((bytes[*i + 8] as u16) << 8) | (bytes[*i + 9] as u16),
            ((bytes[*i + 10] as u16) << 8) | (bytes[*i + 11] as u16),
            ((bytes[*i + 12] as u16) << 8) | (bytes[*i + 13] as u16),
            ((bytes[*i + 14] as u16) << 8) | (bytes[*i + 15] as u16),
        );
        *i += 16;

        Ok(address)
    }
}

/mnt/h/flex-dns/src/question.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::write::WriteBytes;

pub struct DnsQuestions<
    const PTR_STORAGE: usize,
    B: Buffer,
> {
    message: DnsMessage<PTR_STORAGE, { DnsSection::Questions }, B>,
    remaining: usize,
}

impl<
    const PTR_STORAGE: usize,
    B: Buffer,
> DnsQuestions<PTR_STORAGE, B> {
    #[inline(always)]
    pub(crate) fn new(message: DnsMessage<PTR_STORAGE, { DnsSection::Questions }, B>) -> Self {
        let remaining = message.header().unwrap().question_count() as usize;
        Self {
            message,
            remaining,
        }
    }

    pub fn append(&mut self, question: DnsQuestion) -> Result<(), DnsMessageError> {
        let (buffer, position) = self.message.buffer_and_position();
        // Truncate the buffer to the current position.
        buffer.truncate(*position)?;
        question.write(&mut self.message)?;
        // Set question_count in the header to the current question count + 1.
        let question_count = self.message.header().unwrap().question_count();
        let question_count = question_count + 1 - self.remaining as u16;
        self.message.header_mut()?.set_question_count(question_count);
        self.message.header_mut()?.set_answer_count(0);
        self.message.header_mut()?.set_name_server_count(0);
        self.message.header_mut()?.set_additional_records_count(0);
        self.remaining = 0;

        Ok(())
    }

    #[inline]
    pub fn iter(&mut self) -> Result<DnsQuestionIterator, DnsMessageError> {
        let (buffer, position) = self.message.buffer_and_position();
        let buffer = buffer.bytes();

        Ok(DnsQuestionIterator {
            buffer,
            current_position: position,
            remaining: &mut self.remaining,
        })
    }

    #[inline]
    pub fn complete(mut self) -> Result<DnsMessage<PTR_STORAGE, { DnsSection::Answers }, B>, DnsMessageError> {
        if self.remaining != 0 {
            for x in self.iter()? { x?; }
        }

        Ok(DnsMessage {
            buffer: self.message.buffer,
            position: self.message.position,
            ptr_storage: self.message.ptr_storage,
        })
    }
}

pub struct DnsQuestionIterator<'a> {
    buffer: &'a [u8],
    current_position: &'a mut usize,
    remaining: &'a mut usize,
}

impl<'a> Iterator for DnsQuestionIterator<'a> {
    type Item = Result<DnsQuestion<'a>, DnsMessageError>;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        if *self.remaining == 0 {
            return None;
        }

        let question = DnsQuestion::parse(
            self.buffer, self.current_position
        );
        *self.remaining -= 1;

        Some(question)
    }
}

#[derive(Debug, PartialEq)]
pub struct DnsQuestion<'a> {
    pub name: DnsName<'a>,
    pub qtype: DnsQType,
    pub qclass: DnsQClass,
}

impl<'a> DnsQuestion<'a> {
    pub fn parse(bytes: &'a [u8], i: &mut usize) -> Result<Self, DnsMessageError> {
        let name = DnsName::parse(bytes, i)?;
        let qtype = u16::parse(bytes, i)?.into();
        let qclass = u16::parse(bytes, i)?.into();

        Ok(Self {
            name,
            qtype,
            qclass,
        })
    }

    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.name.write(message)?;
        self.qtype.id().write(message)?;
        self.qclass.id().write(message)?;

        Ok(())
    }
}

/// The kind of a DNS query.
///
/// According to [RFC 1035 Section 3.2.2](https://tools.ietf.org/rfc/rfc1035#section-3.2.2)
/// and [RFC 1035 Section 3.2.3](https://tools.ietf.org/rfc/rfc1035#section-3.2.3).
#[derive(Copy, Clone, Debug, PartialEq)]
#[repr(u16)]
pub enum DnsQType {
    A = 1,
    NS = 2,
    CNAME = 5,
    SOA = 6,
    PTR = 12,
    HINFO = 13,
    MX = 15,
    TXT = 16,
    RP = 17,
    AFSDB = 18,
    SIG = 24,
    KEY = 25,
    AAAA = 28,
    LOC = 29,
    SRV = 33,
    NAPTR = 35,
    KX = 36,
    CERT = 37,
    DNAME = 39,
    OPT = 41,
    APL = 42,
    DS = 43,
    SSHFP = 44,
    IPSECKEY = 45,
    RRSIG = 46,
    NSEC = 47,
    DNSKEY = 48,
    DHCID = 49,
    NSEC3 = 50,
    NSEC3PARAM = 51,
    TLSA = 52,
    SMIMEA = 53,
    HIP = 55,
    CDS = 59,
    CDNSKEY = 60,
    OPENPGPKEY = 61,
    CSYNC = 62,
    ZONEMD = 63,
    SVCB = 64,
    HTTPS = 65,
    EUI48 = 108,
    EUI64 = 109,
    TKEY = 249,
    TSIG = 250,
    IXFR = 251,
    AXFR = 252,
    ALL = 255,
    URI = 256,
    CAA = 257,
    TA = 32768,
    DLV = 32769,
    Reserved,
}

impl DnsQType {
    #[inline(always)]
    pub fn from_id(id: u16) -> Self {
        match id {
            1..=2 | 5..=6 | 12..=13 | 15..=18 | 24..=25 | 28..=29
            | 33 | 35..=37 | 39 | 41..=53 | 55 | 59..=65
            | 108..=109 | 249..=252 | 255 | 256 | 257
            | 32768..=32769 => unsafe {
                core::mem::transmute(id)
            },
            _ => DnsQType::Reserved,
        }
    }

    #[inline(always)]
    pub fn id(&self) -> u16 {
        match self {
            DnsQType::Reserved => panic!("Reserved QType"),
            _ => *self as u16,
        }
    }
}

impl From<DnsQType> for u16 {
    #[inline(always)]
    fn from(q: DnsQType) -> Self {
        DnsQType::id(&q)
    }
}

impl From<u16> for DnsQType {
    #[inline(always)]
    fn from(n: u16) -> Self {
        DnsQType::from_id(n)
    }
}

/// The class of a DNS query.
///
/// According to [RFC 1035 Section 3.2.4](https://tools.ietf.org/rfc/rfc1035#section-3.2.4).
#[derive(Copy, Clone, Debug, PartialEq)]
#[repr(u16)]
pub enum DnsQClass {
    /// Internet
    IN = 1,
    /// CSNET
    CS = 2,
    /// CHAOS
    CH = 3,
    /// Hesiod
    HS = 4,
    Reserved,
}

impl DnsQClass {
    #[inline(always)]
    pub fn from_id(id: u16) -> Self {
        match id {
            1..=4 => unsafe { core::mem::transmute(id) },
            _ => DnsQClass::Reserved,
        }
    }

    #[inline(always)]
    pub fn id(&self) -> u16 {
        match self {
            DnsQClass::Reserved => panic!("Reserved QClass"),
            _ => *self as u16,
        }
    }
}

impl From<DnsQClass> for u16 {
    #[inline(always)]
    fn from(q: DnsQClass) -> Self {
        DnsQClass::id(&q)
    }
}

impl From<u16> for DnsQClass {
    #[inline(always)]
    fn from(n: u16) -> Self {
        DnsQClass::from_id(n)
    }
}

/mnt/h/flex-dns/src/rdata.rs

Source (jump to first uncovered line)
mod a;
mod ns;
mod cname;
mod soa;
mod ptr;
mod hinfo;
mod mx;
mod txt;
mod rp;
mod afsdb;
mod sig;
mod key;
mod aaaa;
mod loc;
mod srv;
mod naptr;
mod kx;
mod cert;
mod dname;
mod opt;
mod apl;
mod ds;
mod sshfp;
mod ipseckey;
mod rrsig;
mod nsec;
mod dnskey;
mod dhcid;
mod nsec3;
mod nsec3param;
mod tlsa;
mod smimea;
mod hip;
mod cds;
mod cdnskey;
mod openpgpkey;
mod csync;
mod zonemd;
mod svcb;
mod https;
mod eui48;
mod eui64;
mod tkey;
mod tsig;
mod ixfr;
mod axfr;
mod uri;
mod caa;
mod ta;
mod dlv;

pub use a::A;
pub use ns::Ns;
pub use cname::CName;
pub use soa::Soa;
pub use ptr::Ptr;
pub use hinfo::HInfo;
pub use mx::Mx;
pub use txt::Txt;
pub use rp::Rp;
pub use afsdb::AfsDb;
pub use sig::Sig;
pub use key::Key;
pub use aaaa::Aaaa;
pub use loc::Loc;
pub use srv::Srv;
pub use naptr::Naptr;
pub use kx::Kx;
pub use cert::Cert;
pub use dname::DName;
pub use opt::Opt;
pub use apl::Apl;
pub use ds::Ds;
pub use sshfp::SshFp;
pub use ipseckey::IpSecKey;
pub use rrsig::RRSig;
pub use nsec::Nsec;
pub use dnskey::DnsKey;
pub use dhcid::DhcId;
pub use nsec3::Nsec3;
pub use nsec3param::Nsec3Param;
pub use tlsa::Tlsa;
pub use smimea::SmimeA;
pub use hip::Hip;
pub use cds::Cds;
pub use cdnskey::CdnsKey;
pub use openpgpkey::OpenPgpKey;
pub use csync::CSync;
pub use zonemd::ZoneMd;
pub use svcb::Svcb;
pub use https::Https;
pub use eui48::EUI48;
pub use eui64::EUI64;
pub use tkey::TKey;
pub use tsig::TSig;
pub use ixfr::IXfr;
pub use axfr::AXfr;
pub use uri::Uri;
pub use caa::Caa;
pub use ta::Ta;
pub use dlv::Dlv;

use crate::{Buffer, DnsError, DnsMessage, DnsMessageError, DnsSection};
use crate::parse::{Parse, ParseData};
use crate::question::DnsQType;
use crate::write::WriteBytes;

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RData<'a> {
    buffer: &'a [u8],
    pos: usize,
    len: usize,
    type_: DnsQType,
}

impl<'a> ParseData<'a> for RData<'a> {
    #[inline(always)]
    fn parse_data(&self) -> &'a [u8] {
        self.buffer
    }
}

impl<'a> ParseData<'a> for &'_ RData<'a> {
    #[inline(always)]
    fn parse_data(&self) -> &'a [u8] {
        self.buffer
    }
}

pub(crate) trait RDataParse<'a>: Sized {
    fn parse(bytes: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError>;
}

impl<'a> RData<'a> {
    #[inline(always)]
    pub fn id(&self) -> u16 {
        self.type_.id()
    }

    pub fn parse(bytes: &'a [u8], i: &mut usize, type_: DnsQType) -> Result<Self, DnsMessageError> {
        let len = u16::parse(bytes, i)? as usize;
        let pos = *i;

        if pos + len > bytes.len() {
            return Err(DnsMessageError::DnsError(DnsError::RDataLongerThanMessage));
        }

        *i += len;

        Ok(RData { buffer: bytes, pos, len, type_ })
    }

    #[inline]
    pub fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        (self.len as u16).write(message)?;
        message.write_bytes(&self.buffer[self.pos..self.pos + self.len])
    }

    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.len)
    }

    pub fn into_parsed(self) -> Result<DnsAType<'a>, DnsMessageError> {
        let mut pos = self.pos;

        Ok(match self.type_ {
            DnsQType::A => DnsAType::A(A::parse(&self, &mut pos)?),
            DnsQType::NS => DnsAType::NS(Ns::parse(&self, &mut pos)?),
            DnsQType::CNAME => DnsAType::CName(CName::parse(&self, &mut pos)?),
            DnsQType::SOA => DnsAType::Soa(Soa::parse(&self, &mut pos)?),
            DnsQType::PTR => DnsAType::Ptr(Ptr::parse(&self, &mut pos)?),
            DnsQType::HINFO => DnsAType::HInfo(HInfo::parse(&self, &mut pos)?),
            DnsQType::MX => DnsAType::MX(Mx::parse(&self, &mut pos)?),
            DnsQType::TXT => DnsAType::Txt(Txt::parse(&self, &mut pos)?),
            DnsQType::RP => DnsAType::RP(Rp::parse(&self, &mut pos)?),
            DnsQType::AFSDB => DnsAType::AFSDB(AfsDb::parse(&self, &mut pos)?),
            DnsQType::SIG => DnsAType::SIG(Sig::parse(&self, &mut pos)?),
            DnsQType::KEY => DnsAType::KEY(Key::parse(&self, &mut pos)?),
            DnsQType::AAAA => DnsAType::AAAA(Aaaa::parse(&self, &mut pos)?),
            DnsQType::LOC => DnsAType::Loc(Loc::parse(&self, &mut pos)?),
            DnsQType::SRV => DnsAType::Srv(Srv::parse(&self, &mut pos)?),
            DnsQType::NAPTR => DnsAType::Naptr(Naptr::parse(&self, &mut pos)?),
            DnsQType::KX => DnsAType::KX(Kx::parse(&self, &mut pos)?),
            DnsQType::CERT => DnsAType::Cert(Cert::parse(&self, &mut pos)?),
            DnsQType::DNAME => DnsAType::DName(DName::parse(&self, &mut pos)?),
            DnsQType::OPT => DnsAType::OPT(Opt::parse(&self, &mut pos)?),
            DnsQType::APL => DnsAType::APL(Apl::parse(&self, &mut pos)?),
            DnsQType::DS => DnsAType::DS(Ds::parse(&self, &mut pos)?),
            DnsQType::SSHFP => DnsAType::SSHFP(SshFp::parse(&self, &mut pos)?),
            DnsQType::IPSECKEY => DnsAType::IPSECKEY(IpSecKey::parse(&self, &mut pos)?),
            DnsQType::RRSIG => DnsAType::RRSIG(RRSig::parse(&self, &mut pos)?),
            DnsQType::NSEC => DnsAType::NSEC(Nsec::parse(&self, &mut pos)?),
            DnsQType::DNSKEY => DnsAType::DNSKEY(DnsKey::parse(&self, &mut pos)?),
            DnsQType::DHCID => DnsAType::DHCID(DhcId::parse(&self, &mut pos)?),
            DnsQType::NSEC3 => DnsAType::NSEC3(Nsec3::parse(&self, &mut pos)?),
            DnsQType::NSEC3PARAM => DnsAType::NSEC3PARAM(Nsec3Param::parse(&self, &mut pos)?),
            DnsQType::TLSA => DnsAType::TLSA(Tlsa::parse(&self, &mut pos)?),
            DnsQType::SMIMEA => DnsAType::SMIMEA(SmimeA::parse(&self, &mut pos)?),
            DnsQType::HIP => DnsAType::HIP(Hip::parse(&self, &mut pos)?),
            DnsQType::CDS => DnsAType::CDS(Cds::parse(&self, &mut pos)?),
            DnsQType::CDNSKEY => DnsAType::CDNSKEY(CdnsKey::parse(&self, &mut pos)?),
            DnsQType::OPENPGPKEY => DnsAType::OPENPGPKEY(OpenPgpKey::parse(&self, &mut pos)?),
            DnsQType::CSYNC => DnsAType::CSYNC(CSync::parse(&self, &mut pos)?),
            DnsQType::ZONEMD => DnsAType::ZONEMD(ZoneMd::parse(&self, &mut pos)?),
            DnsQType::SVCB => DnsAType::SVCB(Svcb::parse(&self, &mut pos)?),
            DnsQType::HTTPS => DnsAType::HTTPS(Https::parse(&self, &mut pos)?),
            DnsQType::EUI48 => DnsAType::EUI48(EUI48::parse(&self, &mut pos)?),
            DnsQType::EUI64 => DnsAType::EUI64(EUI64::parse(&self, &mut pos)?),
            DnsQType::TKEY => DnsAType::TKEY(TKey::parse(&self, &mut pos)?),
            DnsQType::TSIG => DnsAType::TSIG(TSig::parse(&self, &mut pos)?),
            DnsQType::IXFR => DnsAType::IXFR(IXfr::parse(&self, &mut pos)?),
            DnsQType::AXFR => DnsAType::AXFR(AXfr::parse(&self, &mut pos)?),
            DnsQType::ALL => return Err(DnsMessageError::DnsError(DnsError::InvalidAnswer)),
            DnsQType::URI => DnsAType::URI(Uri::parse(&self, &mut pos)?),
            DnsQType::CAA => DnsAType::CAA(Caa::parse(&self, &mut pos)?),
            DnsQType::TA => DnsAType::TA(Ta::parse(&self, &mut pos)?),
            DnsQType::DLV => DnsAType::DLV(Dlv::parse(&self, &mut pos)?),
            DnsQType::Reserved => return Err(DnsMessageError::DnsError(DnsError::InvalidAnswer)),
        })
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum DnsAType<'a> {
    A(A),
    NS(Ns<'a>),
    CName(CName<'a>),
    Soa(Soa<'a>),
    Ptr(Ptr<'a>),
    HInfo(HInfo<'a>),
    MX(Mx<'a>),
    Txt(Txt<'a>),
    RP(Rp<'a>),
    AFSDB(AfsDb<'a>),
    SIG(Sig<'a>),
    KEY(Key<'a>),
    AAAA(Aaaa),
    Loc(Loc),
    Srv(Srv<'a>),
    Naptr(Naptr<'a>),
    KX(Kx<'a>),
    Cert(Cert<'a>),
    DName(DName<'a>),
    OPT(Opt<'a>),
    APL(Apl<'a>),
    DS(Ds<'a>),
    SSHFP(SshFp<'a>),
    IPSECKEY(IpSecKey<'a>),
    RRSIG(RRSig<'a>),
    NSEC(Nsec<'a>),
    DNSKEY(DnsKey<'a>),
    DHCID(DhcId<'a>),
    NSEC3(Nsec3<'a>),
    NSEC3PARAM(Nsec3Param<'a>),
    TLSA(Tlsa<'a>),
    SMIMEA(SmimeA<'a>),
    HIP(Hip<'a>),
    CDS(Cds<'a>),
    CDNSKEY(CdnsKey<'a>),
    OPENPGPKEY(OpenPgpKey<'a>),
    CSYNC(CSync<'a>),
    ZONEMD(ZoneMd<'a>),
    SVCB(Svcb<'a>),
    HTTPS(Https<'a>),
    EUI48(EUI48),
    EUI64(EUI64),
    TKEY(TKey<'a>),
    TSIG(TSig<'a>),
    IXFR(IXfr<'a>),
    AXFR(AXfr<'a>),
    URI(Uri<'a>),
    CAA(Caa<'a>),
    TA(Ta<'a>),
    DLV(Dlv<'a>),
    /// Unknown
    Reserved,
}

impl<'a> Into<DnsQType> for DnsAType<'a> {
    #[inline(always)]
    fn into(self) -> DnsQType {
        match self {
            DnsAType::A(_) => DnsQType::A,
            DnsAType::NS(_) => DnsQType::NS,
            DnsAType::CName(_) => DnsQType::CNAME,
            DnsAType::Soa(_) => DnsQType::SOA,
            DnsAType::Ptr(_) => DnsQType::PTR,
            DnsAType::HInfo(_) => DnsQType::HINFO,
            DnsAType::MX(_) => DnsQType::MX,
            DnsAType::Txt(_) => DnsQType::TXT,
            DnsAType::RP(_) => DnsQType::RP,
            DnsAType::AFSDB(_) => DnsQType::AFSDB,
            DnsAType::SIG(_) => DnsQType::SIG,
            DnsAType::KEY(_) => DnsQType::KEY,
            DnsAType::AAAA(_) => DnsQType::AAAA,
            DnsAType::Loc(_) => DnsQType::LOC,
            DnsAType::Srv(_) => DnsQType::SRV,
            DnsAType::Naptr(_) => DnsQType::NAPTR,
            DnsAType::KX(_) => DnsQType::KX,
            DnsAType::Cert(_) => DnsQType::CERT,
            DnsAType::DName(_) => DnsQType::DNAME,
            DnsAType::OPT(_) => DnsQType::OPT,
            DnsAType::APL(_) => DnsQType::APL,
            DnsAType::DS(_) => DnsQType::DS,
            DnsAType::SSHFP(_) => DnsQType::SSHFP,
            DnsAType::IPSECKEY(_) => DnsQType::IPSECKEY,
            DnsAType::RRSIG(_) => DnsQType::RRSIG,
            DnsAType::NSEC(_) => DnsQType::NSEC,
            DnsAType::DNSKEY(_) => DnsQType::DNSKEY,
            DnsAType::DHCID(_) => DnsQType::DHCID,
            DnsAType::NSEC3(_) => DnsQType::NSEC3,
            DnsAType::NSEC3PARAM(_) => DnsQType::NSEC3PARAM,
            DnsAType::TLSA(_) => DnsQType::TLSA,
            DnsAType::SMIMEA(_) => DnsQType::SMIMEA,
            DnsAType::HIP(_) => DnsQType::HIP,
            DnsAType::CDS(_) => DnsQType::CDS,
            DnsAType::CDNSKEY(_) => DnsQType::CDNSKEY,
            DnsAType::OPENPGPKEY(_) => DnsQType::OPENPGPKEY,
            DnsAType::CSYNC(_) => DnsQType::CSYNC,
            DnsAType::ZONEMD(_) => DnsQType::ZONEMD,
            DnsAType::SVCB(_) => DnsQType::SVCB,
            DnsAType::HTTPS(_) => DnsQType::HTTPS,
            DnsAType::EUI48(_) => DnsQType::EUI48,
            DnsAType::EUI64(_) => DnsQType::EUI64,
            DnsAType::TKEY(_) => DnsQType::TKEY,
            DnsAType::TSIG(_) => DnsQType::TSIG,
            DnsAType::IXFR(_) => DnsQType::IXFR,
            DnsAType::AXFR(_) => DnsQType::AXFR,
            DnsAType::URI(_) => DnsQType::URI,
            DnsAType::CAA(_) => DnsQType::CAA,
            DnsAType::TA(_) => DnsQType::TA,
            DnsAType::DLV(_) => DnsQType::DLV,
            DnsAType::Reserved => DnsQType::Reserved,
        }
    }
}

impl<'a> DnsAType<'a> {
    #[inline]
    pub(crate) fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        match self {
            DnsAType::A(r) => r.write(message),
            DnsAType::NS(r) => r.write(message),
            DnsAType::CName(r) => r.write(message),
            DnsAType::Soa(r) => r.write(message),
            DnsAType::Ptr(r) => r.write(message),
            DnsAType::HInfo(r) => r.write(message),
            DnsAType::MX(r) => r.write(message),
            DnsAType::Txt(r) => r.write(message),
            DnsAType::RP(r) => r.write(message),
            DnsAType::AFSDB(r) => r.write(message),
            DnsAType::SIG(r) => r.write(message),
            DnsAType::KEY(r) => r.write(message),
            DnsAType::AAAA(r) => r.write(message),
            DnsAType::Loc(r) => r.write(message),
            DnsAType::Srv(r) => r.write(message),
            DnsAType::Naptr(r) => r.write(message),
            DnsAType::KX(r) => r.write(message),
            DnsAType::Cert(r) => r.write(message),
            DnsAType::DName(r) => r.write(message),
            DnsAType::OPT(r) => r.write(message),
            DnsAType::APL(r) => r.write(message),
            DnsAType::DS(r) => r.write(message),
            DnsAType::SSHFP(r) => r.write(message),
            DnsAType::IPSECKEY(r) => r.write(message),
            DnsAType::RRSIG(r) => r.write(message),
            DnsAType::NSEC(r) => r.write(message),
            DnsAType::DNSKEY(r) => r.write(message),
            DnsAType::DHCID(r) => r.write(message),
            DnsAType::NSEC3(r) => r.write(message),
            DnsAType::NSEC3PARAM(r) => r.write(message),
            DnsAType::TLSA(r) => r.write(message),
            DnsAType::SMIMEA(r) => r.write(message),
            DnsAType::HIP(r) => r.write(message),
            DnsAType::CDS(r) => r.write(message),
            DnsAType::CDNSKEY(r) => r.write(message),
            DnsAType::OPENPGPKEY(r) => r.write(message),
            DnsAType::CSYNC(r) => r.write(message),
            DnsAType::ZONEMD(r) => r.write(message),
            DnsAType::SVCB(r) => r.write(message),
            DnsAType::HTTPS(r) => r.write(message),
            DnsAType::EUI48(r) => r.write(message),
            DnsAType::EUI64(r) => r.write(message),
            DnsAType::TKEY(r) => r.write(message),
            DnsAType::TSIG(r) => r.write(message),
            DnsAType::IXFR(r) => r.write(message),
            DnsAType::AXFR(r) => r.write(message),
            DnsAType::URI(r) => r.write(message),
            DnsAType::CAA(r) => r.write(message),
            DnsAType::TA(r) => r.write(message),
            DnsAType::DLV(r) => r.write(message),
            DnsAType::Reserved => Err(DnsMessageError::DnsError(DnsError::InvalidAnswer)),
        }
    }

    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        match self {
            DnsAType::A(r) => r.byte_len(),
            DnsAType::NS(r) => r.byte_len(),
            DnsAType::CName(r) => r.byte_len(),
            DnsAType::Soa(r) => r.byte_len(),
            DnsAType::Ptr(r) => r.byte_len(),
            DnsAType::HInfo(r) => r.byte_len(),
            DnsAType::MX(r) => r.byte_len(),
            DnsAType::Txt(r) => r.byte_len(),
            DnsAType::RP(r) => r.byte_len(),
            DnsAType::AFSDB(r) => r.byte_len(),
            DnsAType::SIG(r) => r.byte_len(),
            DnsAType::KEY(r) => r.byte_len(),
            DnsAType::AAAA(r) => r.byte_len(),
            DnsAType::Loc(r) => r.byte_len(),
            DnsAType::Srv(r) => r.byte_len(),
            DnsAType::Naptr(r) => r.byte_len(),
            DnsAType::KX(r) => r.byte_len(),
            DnsAType::Cert(r) => r.byte_len(),
            DnsAType::DName(r) => r.byte_len(),
            DnsAType::OPT(r) => r.byte_len(),
            DnsAType::APL(r) => r.byte_len(),
            DnsAType::DS(r) => r.byte_len(),
            DnsAType::SSHFP(r) => r.byte_len(),
            DnsAType::IPSECKEY(r) => r.byte_len(),
            DnsAType::RRSIG(r) => r.byte_len(),
            DnsAType::NSEC(r) => r.byte_len(),
            DnsAType::DNSKEY(r) => r.byte_len(),
            DnsAType::DHCID(r) => r.byte_len(),
            DnsAType::NSEC3(r) => r.byte_len(),
            DnsAType::NSEC3PARAM(r) => r.byte_len(),
            DnsAType::TLSA(r) => r.byte_len(),
            DnsAType::SMIMEA(r) => r.byte_len(),
            DnsAType::HIP(r) => r.byte_len(),
            DnsAType::CDS(r) => r.byte_len(),
            DnsAType::CDNSKEY(r) => r.byte_len(),
            DnsAType::OPENPGPKEY(r) => r.byte_len(),
            DnsAType::CSYNC(r) => r.byte_len(),
            DnsAType::ZONEMD(r) => r.byte_len(),
            DnsAType::SVCB(r) => r.byte_len(),
            DnsAType::HTTPS(r) => r.byte_len(),
            DnsAType::EUI48(r) => r.byte_len(),
            DnsAType::EUI64(r) => r.byte_len(),
            DnsAType::TKEY(r) => r.byte_len(),
            DnsAType::TSIG(r) => r.byte_len(),
            DnsAType::IXFR(r) => r.byte_len(),
            DnsAType::AXFR(r) => r.byte_len(),
            DnsAType::URI(r) => r.byte_len(),
            DnsAType::CAA(r) => r.byte_len(),
            DnsAType::TA(r) => r.byte_len(),
            DnsAType::DLV(r) => r.byte_len(),
            DnsAType::Reserved => Ok(0),
        }
    }

    #[inline(always)]
    pub fn id(&self) -> u16 {
        let qtype: DnsQType = (*self).into();
        qtype.id()
    }
}

#[cfg(test)]
mod testutils {
    use core::fmt::Debug;
    use arrayvec::ArrayVec;
    use crate::DNS_HEADER_SIZE;
    use super::*;

    pub(crate) fn parse_and_compare<
        'a,
        A: RDataParse<'a> + PartialEq + Debug,
    >(bytes: &'a [u8], expected: A) {
        let mut i = 0;
        let rdata = RData {
            buffer: bytes,
            pos: 0,
            len: bytes.len(),
            type_: DnsQType::ALL,
        };
        let parsed = A::parse(&rdata, &mut i).unwrap();
        assert_eq!(parsed, expected);
    }

    pub(crate) fn write_and_compare<
        const N: usize,
        A: WriteBytes + PartialEq + Debug,
    >(a: A, expected: &[u8; N])
        where
            [(); DNS_HEADER_SIZE + N]: Sized,
    {
        let mut message: DnsMessage<
            0, { DnsSection::Questions }, ArrayVec<u8, { DNS_HEADER_SIZE + N }>
        > = DnsMessage::new(ArrayVec::new()).unwrap();
        a.write(&mut message).unwrap();
        let buffer = message.complete().unwrap();
        assert_eq!(&buffer[DNS_HEADER_SIZE..], expected.as_slice());
    }

    macro_rules! parse_write_test_macro {
        (
            $byte_count:literal,
            [ $( $bytes:literal ),* $(,)? ],
            $struct_name:ident { $( $content:ident: $content_builder:expr ),* $(,)? } $(,)?
        ) => {
            parse_write_test!(
                $byte_count,
                [ $( $bytes ),* ],
                $struct_name { $( $content: $content_builder ),* },
                parse,
                write,
            );
        };
        (
            $byte_count:literal,
            [ $( $bytes:literal ),* $(,)? ],
            $struct_name:ident { $( $content:ident: $content_builder:expr ),* $(,)? },
            $parse_name:ident,
            $write_name:ident $(,)?
        ) => {
            #[test]
            fn $parse_name() {
                const BYTES: [u8; $byte_count] = [ $( $bytes ),* ];
                const STRUCT: $struct_name = $struct_name {
                    $( $content: $content_builder ),*
                };

                crate::rdata::testutils::parse_and_compare(&BYTES, STRUCT);
            }

            #[test]
            fn $write_name() {
                const BYTES: [u8; $byte_count] = [ $( $bytes ),* ];
                const STRUCT: $struct_name = $struct_name {
                    $( $content: $content_builder ),*
                };

                crate::rdata::testutils::write_and_compare(STRUCT, &BYTES);
            }
        };
    }

    pub(crate) use parse_write_test_macro as parse_write_test;
}

/mnt/h/flex-dns/src/rdata/a.rs

Source (jump to first uncovered line)
use core::net::Ipv4Addr;

use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # A host address
/// This record is used to return a ipv4 address for a host
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct A {
    /// The host ipv4 address
    pub address: Ipv4Addr,
}

impl<'a> RDataParse<'a> for A {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        Ok(Self { address: Ipv4Addr::parse(rdata, i)? })
    }
}

impl WriteBytes for A {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.address.write(message)
    }
}

impl A {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        4,
        [0x01, 0x02, 0x03, 0x04],
        A {
            address: Ipv4Addr::new(1, 2, 3, 4),
        },
    );
}

/mnt/h/flex-dns/src/rdata/aaaa.rs

Source (jump to first uncovered line)
use core::net::Ipv6Addr;

use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # IPv6 address record
/// This record is used to return a IPv6 address for a host.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Aaaa {
    /// IPv6 address
    pub address: Ipv6Addr,
}

impl<'a> RDataParse<'a> for Aaaa {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        Ok(Self { address: Ipv6Addr::parse(rdata, i)? })
    }
}

impl WriteBytes for Aaaa {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.address.write(message)
    }
}

impl Aaaa {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(16)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        16,
        [
            0x01, 0x02, 0x03, 0x04,
            0x01, 0x02, 0x03, 0x04,
            0x01, 0x02, 0x03, 0x04,
            0x01, 0x02, 0x03, 0x04,
        ],
        Aaaa {
            address: Ipv6Addr::new(
                0x0102, 0x0304,
                0x0102, 0x0304,
                0x0102, 0x0304,
                0x0102, 0x0304,
            )
        },
    );
}

/mnt/h/flex-dns/src/rdata/afsdb.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # AFS data base location
/// This record is used to locate a server that has a copy of the named AFS cell's database.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct AfsDb<'a> {
    /// The subtype of the record
    subtype: u16,
    /// The hostname of the server
    hostname: DnsName<'a>,
}

impl<'a> RDataParse<'a> for AfsDb<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let subtype = u16::parse(rdata.buffer, i)?;
        let hostname = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            subtype,
            hostname,
        })
    }
}

impl<'a> WriteBytes for AfsDb<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.subtype.write(message)?;
        self.hostname.write(message)
    }
}

impl<'a> AfsDb<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(2 + self.hostname.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        9,
        [
            0x00, 0x01, // subtype
            0x03, b'f', b'o', b'o', 0x01, b'b', // hostname
            0x00, // null terminator
        ],
        AfsDb {
            subtype: 1,
            hostname: unsafe { DnsName::from_bytes_unchecked(b"\x03foo\x01b\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/apl.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsError, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::{Parse, ParseData};
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Address prefix list record
/// This record is used to store a list of address prefixes.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Apl<'a> {
    /// The address family for the prefix.
    pub address_family: u8,
    /// The prefix length.
    pub prefix: u8,
    /// The negation flag.
    pub negation: bool,
    /// The address family specific data.
    pub data: Characters<'a>,
}

impl<'a> RDataParse<'a> for Apl<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let bytes = rdata.parse_data();
        let address_family = u8::parse(rdata.buffer, i)?;
        let prefix = u8::parse(rdata.buffer, i)?;
        let length = u8::parse(rdata.buffer, i)?;
        let negation = length & 0x80 != 0;
        let length = length & 0x7F;

        if bytes.len() < *i + length as usize {
            return Err(DnsMessageError::DnsError(DnsError::UnexpectedEndOfBuffer));
        }

        let data = Characters::new(&rdata.buffer[*i..*i + length as usize])?;

        Ok(Self {
            address_family,
            prefix,
            negation,
            data,
        })
    }
}

impl<'a> WriteBytes for Apl<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.address_family.write(message)?;
        self.prefix.write(message)?;

        let mut length = self.data.as_ref().len() as u8;
        if self.negation {
            length |= 0x80;
        }

        length.write(message)?;
        message.write_bytes(self.data.as_ref())
    }
}

impl<'a> Apl<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(3 + self.data.as_ref().len())
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        6,
        [
            0x01, // address family
            0x02, // prefix
            0x03, // length
            0x01, 0x02, 0x03, // data
        ],
        Apl {
            address_family: 0x01,
            prefix: 0x02,
            negation: false,
            data: unsafe { Characters::new_unchecked(&[0x01, 0x02, 0x03]) },
        }
    );
    parse_write_test!(
        6,
        [
            0x01, // address family
            0x02, // prefix
            0x83, // length
            0x01, 0x02, 0x03, // data
        ],
        Apl {
            address_family: 0x01,
            prefix: 0x02,
            negation: true,
            data: unsafe { Characters::new_unchecked(&[0x01, 0x02, 0x03]) },
        },
        parse_negation,
        write_negation,
    );
}

/mnt/h/flex-dns/src/rdata/axfr.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Authoritative zone transfer record (AXFR)
/// This record is used to transfer an entire zone from a primary server to a
/// secondary server.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct AXfr<'a> {
    /// The domain name of the name server that was the
    /// original or primary source of data for this zone
    pub mname: DnsName<'a>,
    /// A domain name which specifies the mailbox of the
    /// person responsible for this zone
    pub rname: DnsName<'a>,
    /// The unsigned 32 bit version number of the original copy
    /// of the zone. Zone transfers preserve this value. This
    /// value wraps and should be compared using sequence space
    /// arithmetic
    pub serial: u32,
    /// A 32 bit time interval before the zone should be
    /// refreshed
    pub refresh: u32,
    /// A 32 bit time interval that should elapse before a
    /// failed refresh should be retried
    pub retry: u32,
    /// A 32 bit time value that specifies the upper limit on
    /// the time interval that can elapse before the zone is no
    /// longer authoritative
    pub expire: u32,
    /// The unsigned 32 bit minimum TTL field that should be
    /// exported with any RR from this zone
    pub minimum: u32,
}

impl<'a> RDataParse<'a> for AXfr<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let mname = DnsName::parse(rdata.buffer, i)?;
        let rname = DnsName::parse(rdata.buffer, i)?;
        let serial = u32::parse(rdata.buffer, i)?;
        let refresh = u32::parse(rdata.buffer, i)?;
        let retry = u32::parse(rdata.buffer, i)?;
        let expire = u32::parse(rdata.buffer, i)?;
        let minimum = u32::parse(rdata.buffer, i)?;

        Ok(Self {
            mname,
            rname,
            serial,
            refresh,
            retry,
            expire,
            minimum,
        })
    }
}

impl<'a> WriteBytes for AXfr<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.mname.write(message)?;
        self.rname.write(message)?;
        self.serial.write(message)?;
        self.refresh.write(message)?;
        self.retry.write(message)?;
        self.expire.write(message)?;
        self.minimum.write(message)
    }
}

impl<'a> AXfr<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.mname.byte_len()? + self.rname.byte_len()? + 20)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        45,
        [
            0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e', 0x03, b'c', b'o', b'm', 0x00, // example.com
            0x06, b'g', b'o', b'o', b'g', b'l', b'e', 0x03, b'c', b'o', b'm', 0x00, // google.com
            0x00, 0x00, 0x00, 0x01, // Serial
            0x00, 0x00, 0x00, 0x02, // Refresh
            0x00, 0x00, 0x00, 0x03, // Retry
            0x00, 0x00, 0x00, 0x04, // Expire
            0x00, 0x00, 0x00, 0x05, // Minimum
        ],
        AXfr {
            mname: unsafe { DnsName::from_bytes_unchecked(b"\x07example\x03com\x00") },
            rname: unsafe { DnsName::from_bytes_unchecked(b"\x06google\x03com\x00") },
            serial: 1,
            refresh: 2,
            retry: 3,
            expire: 4,
            minimum: 5,
        }
    );
}

/mnt/h/flex-dns/src/rdata/caa.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Certificate authority authorization record (CAA)
/// This record is used to specify which certificate authorities (CAs) are
/// allowed to issue certificates for a domain.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Caa<'a> {
    /// The flags field is used to specify critical CAA flags.
    pub flags: u8,
    /// The tag field is used to specify the property represented by the record.
    pub tag: Characters<'a>,
    /// The value field is used to specify the value of the property.
    pub value: Characters<'a>,
}

impl<'a> RDataParse<'a> for Caa<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let flags = u8::parse(rdata, i)?;
        let tag = Characters::parse(rdata, i)?;
        let value = Characters::parse(rdata, i)?;

        Ok(Self {
            flags,
            tag,
            value,
        })
    }
}

impl<'a> WriteBytes for Caa<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.flags.write(message)?;
        self.tag.write(message)?;
        self.value.write(message)
    }
}

impl<'a> Caa<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(1 + self.tag.byte_len()? + self.value.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        23,
        [
            0x42, // flags
            0x05, // tag length
            b'i', b's', b's', b'u', b'e', // tag
            0x0f, // value length
            b'w', b'w', b'w', b'.', b'e', b'x', b'a', b'm', b'p', b'l', b'e', b't',
            b'e', b's', b't', // value
        ],
        Caa {
            flags: 0x42,
            tag: unsafe { Characters::new_unchecked(b"issue") },
            value: unsafe { Characters::new_unchecked(b"www.exampletest") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/cdnskey.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Child DNS Key (CDNSKEY) Record
/// This record is
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct CdnsKey<'a> {
    /// The flags field specifies various flags that control the security
    /// related aspects of the key.
    pub flags: u16,
    /// The protocol field specifies the protocol for which the key is used.
    pub protocol: u8,
    /// The algorithm field specifies the public key's cryptographic algorithm
    pub algorithm: u8,
    /// The public key field holds the public key material.
    pub public_key: Characters<'a>
}

impl<'a> RDataParse<'a> for CdnsKey<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let flags = u16::parse(rdata, i)?;
        let protocol = u8::parse(rdata, i)?;
        let algorithm = u8::parse(rdata, i)?;
        let public_key = Characters::parse(rdata, i)?;

        Ok(Self {
            flags,
            protocol,
            algorithm,
            public_key
        })
    }
}

impl<'a> WriteBytes for CdnsKey<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.flags.write(message)?;
        self.protocol.write(message)?;
        self.algorithm.write(message)?;
        self.public_key.write(message)
    }
}

impl<'a> CdnsKey<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.public_key.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        5,
        [
            0x01, 0x02, // flags
            0x03, // protocol
            0x04, // algorithm
            0x00, // public key
        ],
        CdnsKey {
            flags: 0x0102,
            protocol: 0x03,
            algorithm: 0x04,
            public_key: unsafe { Characters::new_unchecked(&[]) },
        },
    );
}

/mnt/h/flex-dns/src/rdata/cds.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Child Delegation Signer (CDS) Record
/// This record is used to publish the key tag, algorithm, and digest type
/// used in the DS record of a child zone.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Cds<'a> {
    /// The key tag of the key that is being published.
    pub key_tag: u16,
    /// The algorithm of the key that is being published.
    pub algorithm: u8,
    /// The digest type of the key that is being published.
    pub digest_type: u8,
    /// The digest of the key that is being published.
    pub digest: Characters<'a>,
}

impl<'a> RDataParse<'a> for Cds<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let key_tag = u16::parse(rdata, i)?;
        let algorithm = u8::parse(rdata, i)?;
        let digest_type = u8::parse(rdata, i)?;
        let digest = Characters::parse(rdata, i)?;

        Ok(Self {
            key_tag,
            algorithm,
            digest_type,
            digest,
        })
    }
}

impl<'a> WriteBytes for Cds<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.key_tag.write(message)?;
        self.algorithm.write(message)?;
        self.digest_type.write(message)?;
        self.digest.write(message)
    }
}

impl<'a> Cds<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.digest.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        5,
        [ 0x00, 0x01, 0x08, 0x01, 0x00 ],
        Cds {
            key_tag: 1,
            algorithm: 8,
            digest_type: 1,
            digest: unsafe { Characters::new_unchecked(&[]) },
        },
    );
}

/mnt/h/flex-dns/src/rdata/cert.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Certificate record
/// This record lists the certificates used by the owner of the domain
/// name to sign other records in the zone.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Cert<'a> {
    /// The type of certificate.
    pub cert_type: u16,
    /// The key tag of the certificate.
    pub key_tag: u16,
    /// The algorithm used to sign the certificate.
    pub algorithm: u8,
    /// The certificate data.
    pub certificate: Characters<'a>,
}

impl<'a> RDataParse<'a> for Cert<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let cert_type = u16::parse(rdata.buffer, i)?;
        let key_tag = u16::parse(rdata.buffer, i)?;
        let algorithm = u8::parse(rdata.buffer, i)?;
        let certificate = Characters::parse(rdata.buffer, i)?;

        Ok(Self {
            cert_type,
            key_tag,
            algorithm,
            certificate,
        })
    }
}

impl<'a> WriteBytes for Cert<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.cert_type.write(message)?;
        self.key_tag.write(message)?;
        self.algorithm.write(message)?;
        self.certificate.write(message)
    }
}

impl<'a> Cert<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(5 + self.certificate.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        6,
        [
            0x00, 0x01, // cert type
            0x02, 0x03, // key tag
            0x04, // algorithm
            0x00, // certificate length
        ],
        Cert {
            cert_type: 1,
            key_tag: 0x0203,
            algorithm: 4,
            certificate: unsafe { Characters::new_unchecked(&[]) },
        },
    );
}

/mnt/h/flex-dns/src/rdata/cname.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # The canonical name for an alias
/// This record is used to return a canonical name for an alias
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct CName<'a> {
    /// The canonical name for the alias
    name: DnsName<'a>,
}

impl<'a> RDataParse<'a> for CName<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        Ok(Self {
            name: DnsName::parse(rdata.buffer, i)?,
        })
    }
}

impl<'a> WriteBytes for CName<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.name.write(message)
    }
}

impl<'a> CName<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        self.name.byte_len()
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        14,
        [
            3, b'w', b'w', b'w',
            4, b't', b'e', b's', b't',
            3, b'c', b'o', b'm',
            0
        ],
        CName {
            name: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x04test\x03com\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/csync.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Child-to-Parent Synchronization (CSYNC) Record
/// This record type is used to publish the synchronization state of a child zone to its parent zone.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct CSync<'a> {
    /// serial is the serial number of the zone
    pub serial: u32,
    /// flags is a bitmap of flags (see [RFC 7477](https://tools.ietf.org/html/rfc7477))
    pub flags: u16,
    /// type_bit_maps is the set of RRset types present at the next owner name in the zone
    pub type_bit_maps: Characters<'a>,
}

impl<'a> RDataParse<'a> for CSync<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let serial = u32::parse(rdata, i)?;
        let flags = u16::parse(rdata, i)?;
        let type_bit_maps = Characters::parse(rdata, i)?;

        Ok(Self {
            serial,
            flags,
            type_bit_maps
        })
    }
}

impl<'a> WriteBytes for CSync<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.serial.write(message)?;
        self.flags.write(message)?;
        self.type_bit_maps.write(message)
    }
}

impl<'a> CSync<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(6 + self.type_bit_maps.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        10,
        [
            0x00, 0x01, 0x02, 0x03, // serial
            0x10, 0x01, // flags
            3, b'w', b'w', b'w', // type_bit_maps
        ],
        CSync {
            serial: 0x00010203,
            flags: 0x1001,
            type_bit_maps: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/dhcid.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Dynamic host configuration protocol record
/// This record is used to store DHCP information.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DhcId<'a> {
    /// The identifier type.
    pub type_: u16,
    /// The digest type.
    pub digest_type: u8,
    /// The digest of the DHCP information.
    pub digest: Characters<'a>,
}

impl<'a> RDataParse<'a> for DhcId<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let type_ = u16::parse(rdata, i)?;
        let digest_type = u8::parse(rdata, i)?;
        let digest = Characters::parse(rdata, i)?;

        Ok(Self {
            type_,
            digest_type,
            digest,
        })
    }
}

impl<'a> WriteBytes for DhcId<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.type_.write(message)?;
        self.digest_type.write(message)?;
        self.digest.write(message)
    }
}

impl<'a> DhcId<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(3 + self.digest.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        7,
        [
            0x00, 0x0e, // type
            0x03, // digest type
            0x03, // digest len
            b'w', b'w', b'w', // digest
        ],
        DhcId {
            type_: 14,
            digest_type: 3,
            digest: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/dlv.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # DNSSEC lookaside validation record (DLV)
/// This record is used to publish the public key of a DNSSEC lookaside validation
/// (DLV) trust anchor.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Dlv<'a> {
    /// key_tag is a mechanism for quickly identifying the signing key in a zone
    pub key_tag: u16,
    /// algorithm is the algorithm of the key
    pub algorithm: u8,
    /// digest_type is the algorithm used to construct the digest
    pub digest_type: u8,
    /// digest is the digest of the public key
    pub digest: Characters<'a>,
}

impl<'a> RDataParse<'a> for Dlv<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let key_tag = u16::parse(rdata, i)?;
        let algorithm = u8::parse(rdata, i)?;
        let digest_type = u8::parse(rdata, i)?;
        let digest = Characters::parse(rdata, i)?;

        Ok(Self {
            key_tag,
            algorithm,
            digest_type,
            digest,
        })
    }
}

impl<'a> WriteBytes for Dlv<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.key_tag.write(message)?;
        self.algorithm.write(message)?;
        self.digest_type.write(message)?;
        self.digest.write(message)
    }
}

impl<'a> Dlv<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.digest.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        8,
        [
            0x00, 0x0e, // key_tag
            0x03, // algorithm
            0x03, // digest_type
            0x03, // digest len
            b'w', b'w', b'w', // digest
        ],
        Dlv {
            key_tag: 14,
            algorithm: 3,
            digest_type: 3,
            digest: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/dname.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Delegation name record
/// This record is used to delegate a DNS zone to use the given authoritative
/// name servers.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DName<'a> {
    /// The name of the delegated domain.
    pub name: DnsName<'a>,
}

impl<'a> RDataParse<'a> for DName<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let name = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            name,
        })
    }
}

impl<'a> WriteBytes for DName<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.name.write(message)
    }
}

impl<'a> DName<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        self.name.byte_len()
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        17,
        [
            0x03, b'w', b'w', b'w',
            0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00,
        ],
        DName {
            name: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x07example\x03com\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/dnskey.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # DNS key record
/// This record is used to store public keys that are associated with a zone.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DnsKey<'a> {
    /// The flags field specifies various flags that control the security
    /// related aspects of the key.
    pub flags: u16,
    /// The protocol field specifies the protocol for which the key is used.
    pub protocol: u8,
    /// The algorithm field specifies the public key's cryptographic algorithm
    pub algorithm: u8,
    /// The public key field holds the public key material.
    pub public_key: Characters<'a>
}

impl<'a> RDataParse<'a> for DnsKey<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let flags = u16::parse(rdata, i)?;
        let protocol = u8::parse(rdata, i)?;
        let algorithm = u8::parse(rdata, i)?;
        let public_key = Characters::parse(rdata, i)?;

        Ok(DnsKey {
            flags,
            protocol,
            algorithm,
            public_key
        })
    }
}

impl<'a> WriteBytes for DnsKey<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.flags.write(message)?;
        self.protocol.write(message)?;
        self.algorithm.write(message)?;
        self.public_key.write(message)
    }
}

impl<'a> DnsKey<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.public_key.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        8,
        [
            0x0f, 0x0e, // flags
            0x5c, // protocol
            0x8a, // algorithm
            0x03, // public key length
            b'w', b'w', b'w', // public key
        ],
        DnsKey {
            flags: 0x0f0e,
            protocol: 0x5c,
            algorithm: 0x8a,
            public_key: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/ds.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Delegation signer record
/// This record is used to store a cryptographic hash of a DNSKEY record.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Ds<'a> {
    /// The key tag of the DNSKEY record.
    pub key_tag: u16,
    /// The algorithm of the DNSKEY record.
    pub algorithm: u8,
    /// The digest type of the DNSKEY record.
    pub digest_type: u8,
    /// The digest of the DNSKEY record.
    pub digest: Characters<'a>,
}

impl<'a> RDataParse<'a> for Ds<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let key_tag = u16::parse(rdata.buffer, i)?;
        let algorithm = u8::parse(rdata.buffer, i)?;
        let digest_type = u8::parse(rdata.buffer, i)?;
        let digest = Characters::parse(rdata.buffer, i)?;

        Ok(Ds {
            key_tag,
            algorithm,
            digest_type,
            digest,
        })
    }
}

impl<'a> WriteBytes for Ds<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.key_tag.write(message)?;
        self.algorithm.write(message)?;
        self.digest_type.write(message)?;
        self.digest.write(message)
    }
}

impl<'a> Ds<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.digest.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        8,
        [
            0x0c, 0x07, // key tag
            0x83, // algorithm
            0x73, // digest type
            0x03, // digest len
            b'w', b'w', b'w', // digest
        ],
        Ds {
            key_tag: 0x0c07,
            algorithm: 0x83,
            digest_type: 0x73,
            digest: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/eui48.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # MAC address record (EUI-48)
/// This record is used to translate between a 48-bit MAC address used by the
/// IEEE 802 protocol family and a fully qualified domain name.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct EUI48 {
    /// mac_address is the MAC address
    pub mac_address: [u8; 6],
}

impl<'a> RDataParse<'a> for EUI48 {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let mac_address = <[u8; 6]>::parse(rdata, i)?;

        Ok(Self {
            mac_address,
        })
    }
}

impl<'a> WriteBytes for EUI48 {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.mac_address.write(message)
    }
}

impl EUI48 {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(6)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        6,
        [
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06
        ],
        EUI48 {
            mac_address: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06],
        },
    );
}

/mnt/h/flex-dns/src/rdata/eui64.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # MAC address record (EUI-64)
/// This record is used to translate between a 64-bit MAC address used by the
/// IEEE 802 protocol family and a fully qualified domain name.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct EUI64 {
    /// mac_address is the MAC address
    pub mac_address: [u8; 8],
}

impl<'a> RDataParse<'a> for EUI64 {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let mac_address = <[u8; 8]>::parse(rdata, i)?;

        Ok(Self {
            mac_address,
        })
    }
}

impl<'a> WriteBytes for EUI64 {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.mac_address.write(message)
    }
}

impl EUI64 {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(8)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        8,
        [
            0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
            0x07, 0x08,
        ],
        EUI64 {
            mac_address: [
                0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08
            ],
        },
    );
}

/mnt/h/flex-dns/src/rdata/hinfo.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Host information
/// This record is used to return host information
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct HInfo<'a> {
    /// The CPU type
    cpu: Characters<'a>,
    /// The OS type
    os: Characters<'a>,
}

impl<'a> RDataParse<'a> for HInfo<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let cpu = Characters::parse(rdata, i)?;
        let os = Characters::parse(rdata, i)?;

        Ok(Self {
            cpu,
            os,
        })
    }
}

impl<'a> WriteBytes for HInfo<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.cpu.write(message)?;
        self.os.write(message)
    }
}

impl<'a> HInfo<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.cpu.byte_len()? + self.os.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        8,
        [
            3, b'w', b'w', b'w',
            3, b'c', b'o', b'm',
        ],
        HInfo {
            cpu: unsafe { Characters::new_unchecked(b"www") },
            os: unsafe { Characters::new_unchecked(b"com") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/hip.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Host identity protocol (HIP) Record
/// This record is used to associate a HIP public key with a domain name.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Hip<'a> {
    /// The usage field is an 8-bit value that defines the semantics of the
    /// certificate association data field.
    pub usage: u8,
    /// The selector field is an 8-bit value that defines the type of data in the
    /// certificate association data field.
    pub selector: u8,
    /// The matching type field is an 8-bit value that defines the semantics of
    /// the certificate association data field.
    pub matching_type: u8,
    /// The certificate association data field is a variable-length string of octets
    /// that contains the certificate association data.
    pub certificate_association_data: Characters<'a>,
}

impl<'a> RDataParse<'a> for Hip<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let usage = u8::parse(rdata, i)?;
        let selector = u8::parse(rdata, i)?;
        let matching_type = u8::parse(rdata, i)?;
        let certificate_association_data = Characters::parse(rdata, i)?;

        Ok(Self {
            usage,
            selector,
            matching_type,
            certificate_association_data,
        })
    }
}

impl<'a> WriteBytes for Hip<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.usage.write(message)?;
        self.selector.write(message)?;
        self.matching_type.write(message)?;
        self.certificate_association_data.write(message)
    }
}

impl<'a> Hip<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(3 + self.certificate_association_data.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        7,
        [
            0x0e, // usage
            0x63, // selector
            0x43, // matching type
            0x03, // digest len
            b'w', b'w', b'w', // digest
        ],
        Hip {
            usage: 14,
            selector: 99,
            matching_type: 67,
            certificate_association_data: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/https.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # HTTPs certificate record (HTTPS)
/// This record is used to describe the parameters of a service binding.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Https<'a> {
    /// The priority of this target host
    pub priority: u16,
    /// The relative weight for entries with the same priority
    pub weight: u16,
    /// The TCP or UDP port on which the service is to be found
    pub port: u16,
    /// The domain name of the target host
    pub target: DnsName<'a>,
    /// The parameters of the service binding
    pub parameters: Characters<'a>,
}

impl<'a> RDataParse<'a> for Https<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let priority = u16::parse(rdata, i)?;
        let weight = u16::parse(rdata, i)?;
        let port = u16::parse(rdata, i)?;
        let target = DnsName::parse(rdata, i)?;
        let parameters = Characters::parse(rdata, i)?;

        Ok(Self {
            priority,
            weight,
            port,
            target,
            parameters
        })
    }
}

impl<'a> WriteBytes for Https<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.priority.write(message)?;
        self.weight.write(message)?;
        self.port.write(message)?;
        self.target.write(message)?;
        self.parameters.write(message)
    }
}

impl<'a> Https<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(6 + self.target.byte_len()? + self.parameters.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        15,
        [
            0x00, 0x0e, // priority
            0x00, 0x0e, // weight
            0x00, 0x0e, // port
            0x03, // length of "www"
            b'w', b'w', b'w', // "www"
            0x00, // end of name
            0x03, // length of "www"
            b'w', b'w', b'w', // "www"
        ],
        Https {
            priority: 14,
            weight: 14,
            port: 14,
            target: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x00") },
            parameters: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/ipseckey.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # IPsec key record
/// This record is used to store a public key that is associated with a domain name.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct IpSecKey<'a> {
    /// The precedence of the key.
    pub precedence: u16,
    /// The gateway type.
    pub gateway_type: u8,
    /// The algorithm used for the key.
    pub algorithm: u8,
    /// The gateway data.
    pub gateway: Characters<'a>,
    /// The public key data.
    pub public_key: Characters<'a>,
}

impl<'a> RDataParse<'a> for IpSecKey<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let precedence = u16::parse(rdata.buffer, i)?;
        let gateway_type = u8::parse(rdata.buffer, i)?;
        let algorithm = u8::parse(rdata.buffer, i)?;
        let gateway = Characters::parse(rdata.buffer, i)?;
        let public_key = Characters::parse(rdata.buffer, i)?;

        Ok(Self {
            precedence,
            gateway_type,
            algorithm,
            gateway,
            public_key,
        })
    }
}

impl<'a> WriteBytes for IpSecKey<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.precedence.write(message)?;
        self.gateway_type.write(message)?;
        self.algorithm.write(message)?;
        self.gateway.write(message)?;
        self.public_key.write(message)
    }
}

impl<'a> IpSecKey<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.gateway.byte_len()? + self.public_key.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        12,
        [
            0x01, 0x02, // precedence
            0x03, // gateway type
            0x04, // algorithm
            0x03, b'w', b'w', b'w', // gateway
            0x03, b'w', b'w', b'w', // public key
        ],
        IpSecKey {
            precedence: 0x0102,
            gateway_type: 0x03,
            algorithm: 0x04,
            gateway: unsafe { Characters::new_unchecked(b"www") },
            public_key: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/ixfr.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Incremental zone transfer record (IXFR)
/// This record is used to transfer a portion of a zone from a primary server to
/// a secondary server.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct IXfr<'a> {
    /// The domain name of the name server that was the
    /// original or primary source of data for this zone
    pub mname: DnsName<'a>,
    /// A domain name which specifies the mailbox of the
    /// person responsible for this zone
    pub rname: DnsName<'a>,
    /// The unsigned 32 bit version number of the original copy
    /// of the zone. Zone transfers preserve this value. This
    /// value wraps and should be compared using sequence space
    /// arithmetic
    pub serial: u32,
    /// A 32 bit time interval before the zone should be
    /// refreshed
    pub refresh: u32,
    /// A 32 bit time interval that should elapse before a
    /// failed refresh should be retried
    pub retry: u32,
    /// A 32 bit time value that specifies the upper limit on
    /// the time interval that can elapse before the zone is no
    /// longer authoritative
    pub expire: u32,
    /// The unsigned 32 bit minimum TTL field that should be
    /// exported with any RR from this zone
    pub minimum: u32,
}

impl<'a> RDataParse<'a> for IXfr<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let mname = DnsName::parse(rdata.buffer, i)?;
        let rname = DnsName::parse(rdata.buffer, i)?;
        let serial = u32::parse(rdata.buffer, i)?;
        let refresh = u32::parse(rdata.buffer, i)?;
        let retry = u32::parse(rdata.buffer, i)?;
        let expire = u32::parse(rdata.buffer, i)?;
        let minimum = u32::parse(rdata.buffer, i)?;

        Ok(Self {
            mname,
            rname,
            serial,
            refresh,
            retry,
            expire,
            minimum,
        })
    }
}

impl<'a> WriteBytes for IXfr<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.mname.write(message)?;
        self.rname.write(message)?;
        self.serial.write(message)?;
        self.refresh.write(message)?;
        self.retry.write(message)?;
        self.expire.write(message)?;
        self.minimum.write(message)
    }
}

impl<'a> IXfr<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.mname.byte_len()? + self.rname.byte_len()? + 20)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        53,
        [
            3, b'w', b'w', b'w',
            7, b'e', b'x', b'a', b'm', b'p', b'l', b'e',
            3, b'c', b'o', b'm',
            0,
            3, b'w', b'w', b'w',
            6, b'g', b'o', b'o', b'g', b'l', b'e',
            3, b'c', b'o', b'm',
            0,
            0x00, 0x00, 0x00, 0x01,
            0x00, 0x00, 0x0E, 0x10,
            0x00, 0x00, 0x03, 0x84,
            0x00, 0x09, 0x3A, 0x80,
            0x00, 0x00, 0x03, 0x84,
        ],
        IXfr {
            mname: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x07example\x03com\x00") },
            rname: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x06google\x03com\x00") },
            serial: 1,
            refresh: 3600,
            retry: 900,
            expire: 604800,
            minimum: 900,
        },
    );
}

/mnt/h/flex-dns/src/rdata/key.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Key
/// This record is used to store a public key that can be used to verify DNSSEC signatures
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Key<'a> {
    /// The flags field is used to store flags specific to the algorithm
    pub flags: u16,
    /// The protocol field is used to store the protocol number for which this key is used
    pub protocol: u8,
    /// The algorithm field is used to store the algorithm number for this key
    pub algorithm: u8,
    /// The public key is stored as a character string
    pub public_key: Characters<'a>,
}

impl<'a> RDataParse<'a> for Key<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let flags = u16::parse(rdata, i)?;
        let protocol = u8::parse(rdata, i)?;
        let algorithm = u8::parse(rdata, i)?;
        let public_key = Characters::parse(rdata, i)?;

        Ok(Self {
            flags,
            protocol,
            algorithm,
            public_key,
        })
    }
}

impl<'a> WriteBytes for Key<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.flags.write(message)?;
        self.protocol.write(message)?;
        self.algorithm.write(message)?;
        self.public_key.write(message)
    }
}

impl<'a> Key<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.public_key.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        8,
        [
            0x00, 0x0e, // flags
            0xc4, // protocol
            0x4c, // algorithm
            0x03, // length
            b'w', b'w', b'w', // "www"
        ],
        Key {
            flags: 14,
            protocol: 196,
            algorithm: 76,
            public_key: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/kx.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Key exchange delegation record
/// This record describes a mechanism whereby authorization for one node
/// to act as a key exchange for another is delegated and made available
/// with the secure DNS protocol.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Kx<'a> {
    /// The preference given to this record among others at the same owner.
    pub preference: u16,
    /// The key exchange host name.
    pub exchange: DnsName<'a>,
}

impl<'a> RDataParse<'a> for Kx<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let preference = u16::parse(rdata.buffer, i)?;
        let exchange = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            preference,
            exchange,
        })
    }
}

impl<'a> WriteBytes for Kx<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.preference.write(message)?;
        self.exchange.write(message)
    }
}

impl<'a> Kx<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(2 + self.exchange.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        7,
        [
            0x00, 0x0e, // preference
            0x03, b'w', b'w', b'w', 0x00, // exchange
        ],
        Kx {
            preference: 14,
            exchange: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/loc.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Location information
/// This record is used to return a location for a host
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Loc {
    /// The version of the location record
    pub version: u8,
    /// The size of the location record
    pub size: u8,
    /// The horizontal precision of the location record
    pub horizontal_precision: u8,
    /// The vertical precision of the location record
    pub vertical_precision: u8,
    /// The latitude of the location record
    pub latitude: u32,
    /// The longitude of the location record
    pub longitude: u32,
    /// The altitude of the location record
    pub altitude: u32,
}

impl<'a> RDataParse<'a> for Loc {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let version = u8::parse(rdata.buffer, i)?;
        let size = u8::parse(rdata.buffer, i)?;
        let horizontal_precision = u8::parse(rdata.buffer, i)?;
        let vertical_precision = u8::parse(rdata.buffer, i)?;
        let latitude = u32::parse(rdata.buffer, i)?;
        let longitude = u32::parse(rdata.buffer, i)?;
        let altitude = u32::parse(rdata.buffer, i)?;

        Ok(Self {
            version,
            size,
            horizontal_precision,
            vertical_precision,
            latitude,
            longitude,
            altitude,
        })
    }
}

impl WriteBytes for Loc {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.version.write(message)?;
        self.size.write(message)?;
        self.horizontal_precision.write(message)?;
        self.vertical_precision.write(message)?;
        self.latitude.write(message)?;
        self.longitude.write(message)?;
        self.altitude.write(message)
    }
}

impl Loc {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(16)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        16,
        [
            0x0e, // version
            0x0d, // size
            0x0c, // horizontal precision
            0x0b, // vertical precision
            0x00, 0x00, 0x00, 0x0a, // latitude
            0x00, 0x00, 0x00, 0x0b, // longitude
            0x00, 0x00, 0x00, 0x0c, // altitude
        ],
        Loc {
            version: 0x0e,
            size: 0x0d,
            horizontal_precision: 0x0c,
            vertical_precision: 0x0b,
            latitude: 0x0a,
            longitude: 0x0b,
            altitude: 0x0c,
        },
    );
}

/mnt/h/flex-dns/src/rdata/mx.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Mail exchange
/// This record is used to specify the mail exchange for a domain name.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Mx<'a> {
    /// The preference of this mail exchange
    pub preference: u16,
    /// The domain name of the mail exchange
    pub exchange: DnsName<'a>,
}

impl<'a> RDataParse<'a> for Mx<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let preference = u16::parse(rdata.buffer, i)?;
        let exchange = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            preference,
            exchange,
        })
    }
}

impl<'a> WriteBytes for Mx<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.preference.write(message)?;
        self.exchange.write(message)
    }
}

impl<'a> Mx<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(2 + self.exchange.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        7,
        [
            0x00, 0x0e, // preference
            0x03, b'w', b'w', b'w', 0x00, // exchange
        ],
        Mx {
            preference: 14,
            exchange: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/naptr.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Naming authority pointer
/// This record is used to delegate a DNS zone to use the given authoritative name servers
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Naptr<'a> {
    /// The order in which the NAPTR records MUST be processed in order to accurately represent the ordered list of Rules.
    pub order: u16,
    /// The preference value of this NAPTR record.
    pub preference: u16,
    /// The flags field specifies various flags that control the processing of the NAPTR record.
    pub flags: Characters<'a>,
    /// The service field specifies the service(s) available down this rewrite path.
    pub service: Characters<'a>,
    /// The regexp field specifies a substitution expression that is applied to the original string held by the client in order to construct the next domain name to lookup.
    pub regexp: Characters<'a>,
    /// The replacement field specifies the next domain-name to query for NAPTR, SRV, or Address records depending on the value of the flags field.
    pub replacement: DnsName<'a>,
}

impl<'a> RDataParse<'a> for Naptr<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let order = u16::parse(rdata.buffer, i)?;
        let preference = u16::parse(rdata.buffer, i)?;
        let flags = Characters::parse(rdata.buffer, i)?;
        let service = Characters::parse(rdata.buffer, i)?;
        let regexp = Characters::parse(rdata.buffer, i)?;
        let replacement = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            order,
            preference,
            flags,
            service,
            regexp,
            replacement,
        })
    }
}

impl<'a> WriteBytes for Naptr<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.order.write(message)?;
        self.preference.write(message)?;
        self.flags.write(message)?;
        self.service.write(message)?;
        self.regexp.write(message)?;
        self.replacement.write(message)
    }
}

impl<'a> Naptr<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.flags.byte_len()? + self.service.byte_len()? + self.regexp.byte_len()? + self.replacement.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        21,
        [
            0x00, 0x0e, // order
            0x00, 0x0f, // preference
            0x03, b'a', b'b', b'c', // flags
            0x03, b'd', b'e', b'f', // service
            0x03, b'g', b'h', b'i', // regexp
            0x03, b'j', b'k', b'l', 0x00, // replacement
        ],
        Naptr {
            order: 14,
            preference: 15,
            flags: unsafe { Characters::new_unchecked(b"abc") },
            service: unsafe { Characters::new_unchecked(b"def") },
            regexp: unsafe { Characters::new_unchecked(b"ghi") },
            replacement: unsafe { DnsName::from_bytes_unchecked(b"\x03jkl\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/ns.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # An authoritative name server
/// this record is used to return a nameserver for the given domain
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Ns<'a> {
    /// The name server for the domain
    name: DnsName<'a>,
}

impl<'a> RDataParse<'a> for Ns<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let name = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            name,
        })
    }
}

impl<'a> WriteBytes for Ns<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.name.write(message)
    }
}

impl<'a> Ns<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.name.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        17,
        [
            0x03, b'w', b'w', b'w',
            0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00,
        ],
        Ns {
            name: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x07example\x03com\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/nsec.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Next secure record
/// This record is used to prove that a name does not exist in a zone.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Nsec<'a> {
    /// The next owner name in the canonical ordering of the zone.
    pub next_domain_name: DnsName<'a>,
    /// The set of RR types present at the NSEC RR's owner name.
    pub type_bit_maps: Characters<'a>,
}

impl<'a> RDataParse<'a> for Nsec<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let next_domain_name = DnsName::parse(rdata, i)?;
        let type_bit_maps = Characters::parse(rdata, i)?;

        Ok(Self {
            next_domain_name,
            type_bit_maps,
        })
    }
}

impl<'a> WriteBytes for Nsec<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.next_domain_name.write(message)?;
        self.type_bit_maps.write(message)
    }
}

impl<'a> Nsec<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.next_domain_name.byte_len()? + self.type_bit_maps.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        9,
        [
            0x03, // length of "www"
            b'w', b'w', b'w', // "www"
            0x00, // end of name
            0x03, // length of "www"
            b'w', b'w', b'w', // "www"
        ],
        Nsec {
            next_domain_name: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x00") },
            type_bit_maps: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/nsec3.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Next secure record version 3
/// This record is used to provide authenticated denial of existence for DNSSEC.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Nsec3<'a> {
    /// The hash algorithm used to hash the original owner name field.
    pub hash_algorithm: u8,
    /// The flags field.
    pub flags: u8,
    /// The number of iterations used to construct the hash.
    pub iterations: u16,
    /// The salt used to construct the hash.
    pub salt: Characters<'a>,
    /// The next hashed owner name in the canonical ordering of the zone.
    pub next_hashed_owner_name: Characters<'a>,
    /// The type bit maps field.
    pub type_bit_maps: Characters<'a>,
}

impl<'a> RDataParse<'a> for Nsec3<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let hash_algorithm = u8::parse(rdata, i)?;
        let flags = u8::parse(rdata, i)?;
        let iterations = u16::parse(rdata, i)?;
        let salt = Characters::parse(rdata, i)?;
        let next_hashed_owner_name = Characters::parse(rdata, i)?;
        let type_bit_maps = Characters::parse(rdata, i)?;

        Ok(Self {
            hash_algorithm,
            flags,
            iterations,
            salt,
            next_hashed_owner_name,
            type_bit_maps,
        })
    }
}

impl<'a> WriteBytes for Nsec3<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.hash_algorithm.write(message)?;
        self.flags.write(message)?;
        self.iterations.write(message)?;
        self.salt.write(message)?;
        self.next_hashed_owner_name.write(message)?;
        self.type_bit_maps.write(message)
    }
}

impl<'a> Nsec3<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(5 + self.salt.byte_len()? + self.next_hashed_owner_name.byte_len()? + self.type_bit_maps.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        16,
        [
            0x0e, // hash algorithm
            0x0a, // flags
            0x00, 0x0e, // iterations
            0x03, // length of salt
            b'a', b'b', b'c',
            0x03, // length of next hashed owner name
            b'd', b'e', b'f',
            0x03, // length of type bit maps
            b'w', b'w', b'w',
        ],
        Nsec3 {
            hash_algorithm: 0x0e,
            flags: 0x0a,
            iterations: 0x000e,
            salt: unsafe { Characters::new_unchecked(b"abc") },
            next_hashed_owner_name: unsafe { Characters::new_unchecked(b"def") },
            type_bit_maps: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/nsec3param.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Next secure record version 3 parameters
/// This record is used to provide parameters for the NSEC3 records.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Nsec3Param<'a> {
    /// Hash algorithm
    pub hash_algorithm: u8,
    /// Flags
    pub flags: u8,
    /// Iterations
    pub iterations: u16,
    /// Salt
    pub salt: Characters<'a>,
}

impl<'a> RDataParse<'a> for Nsec3Param<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let hash_algorithm = u8::parse(rdata, i)?;
        let flags = u8::parse(rdata, i)?;
        let iterations = u16::parse(rdata, i)?;
        let salt = Characters::parse(rdata, i)?;

        Ok(Self {
            hash_algorithm,
            flags,
            iterations,
            salt,
        })
    }
}

impl<'a> WriteBytes for Nsec3Param<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.hash_algorithm.write(message)?;
        self.flags.write(message)?;
        self.iterations.write(message)?;
        self.salt.write(message)
    }
}

impl<'a> Nsec3Param<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.salt.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        8,
        [
            0x0e, // hash algorithm
            0xae, // flags
            0x0a, 0xfe, // iterations
            0x03, b'w', b'w', b'w', // salt
        ],
        Nsec3Param {
            hash_algorithm: 0x0e,
            flags: 0xae,
            iterations: 0x0afe,
            salt: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/openpgpkey.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # OpenPGP Key Record (OPENPGPKEY)
/// This record is used as part of the DNS-Based Authentication of Named
/// Entities (DANE) protocol to associate a public key with a domain name.
/// The OPENPGPKEY record is intended to be used in conjunction with the
/// TLSA record [RFC6698].
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct OpenPgpKey<'a> {
    /// flags is a bitmap of flags (see [RFC 4880](https://tools.ietf.org/html/rfc4880))
    pub flags: u16,
    /// algorithm is the algorithm of the public key
    pub algorithm: u8,
    /// public_key is the public key
    pub public_key: Characters<'a>,
    /// fingerprint is the fingerprint of the referenced public key
    pub fingerprint: Characters<'a>,
}

impl<'a> RDataParse<'a> for OpenPgpKey<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let flags = u16::parse(rdata, i)?;
        let algorithm = u8::parse(rdata, i)?;
        let public_key = Characters::parse(rdata, i)?;
        let fingerprint = Characters::parse(rdata, i)?;

        Ok(Self {
            flags,
            algorithm,
            public_key,
            fingerprint
        })
    }
}

impl<'a> WriteBytes for OpenPgpKey<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.flags.write(message)?;
        self.algorithm.write(message)?;
        self.public_key.write(message)?;
        self.fingerprint.write(message)
    }
}

impl<'a> OpenPgpKey<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(3 + self.public_key.byte_len()? + self.fingerprint.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        11,
        [
            0x00, 0x0e, // flags
            0x0a, // algorithm
            0x03, b'w', b'w', b'w', // public key
            0x03, b'w', b'w', b'w', // fingerprint
        ],
        OpenPgpKey {
            flags: 0x000e,
            algorithm: 0x0a,
            public_key: unsafe { Characters::new_unchecked(b"www") },
            fingerprint: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/opt.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Option record
/// This record is used to store options for the DNS protocol.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Opt<'a> {
    /// The code for the option.
    pub code: u16,
    /// The data for the option.
    pub data: Characters<'a>,
}

impl<'a> RDataParse<'a> for Opt<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let code = u16::parse(rdata.buffer, i)?;
        let data = Characters::parse(rdata.buffer, i)?;

        Ok(Self {
            code,
            data,
        })
    }
}

impl<'a> WriteBytes for Opt<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.code.write(message)?;
        self.data.write(message)
    }
}

impl<'a> Opt<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(2 + self.data.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        6,
        [
            0x00, 0x0e, // code
            0x03, // length
            b'w', b'w', b'w', // data
        ],
        Opt {
            code: 14,
            data: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/ptr.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # A domain name pointer
/// This record is used to return a canonical name for an alias
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Ptr<'a> {
    /// The canonical name for the alias
    name: DnsName<'a>,
}

impl<'a> RDataParse<'a> for Ptr<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let name = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            name,
        })
    }
}

impl<'a> WriteBytes for Ptr<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.name.write(message)
    }
}

impl<'a> Ptr<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.name.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        17,
        [
            0x03, b'w', b'w', b'w',
            0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00,
        ],
        Ptr {
            name: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x07example\x03com\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/rp.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Responsible person
/// This record is used to identify the responsible person for a domain
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Rp<'a> {
    /// The mailbox name of the responsible person
    pub mbox: DnsName<'a>,
    /// The domain name of the responsible person
    pub txt: DnsName<'a>,
}

impl<'a> RDataParse<'a> for Rp<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let mbox = DnsName::parse(rdata.buffer, i)?;
        let txt = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            mbox,
            txt,
        })
    }
}

impl<'a> WriteBytes for Rp<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.mbox.write(message)?;
        self.txt.write(message)
    }
}

impl<'a> Rp<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.mbox.byte_len()? + self.txt.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        33,
        [
            0x03, b'w', b'w', b'w',
            0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00, // mbox
            0x03, b'w', b'w', b'w',
            0x06, b'g', b'o', b'o', b'g', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00, // txt
        ],
        Rp {
            mbox: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x07example\x03com\x00") },
            txt: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x06google\x03com\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/rrsig.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # DNSSEC signature record
/// This record is used to sign other records. It is used in conjunction with the
/// DnsKey record to verify the authenticity of a record.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct RRSig<'a> {
    /// The type of record that is covered by this signature.
    pub type_covered: u16,
    /// The algorithm used to create the signature.
    pub algorithm: u8,
    /// The number of seconds the signature is valid for.
    pub original_ttl: u32,
    /// The time at which the signature was created.
    pub signature_expiration: u32,
    /// The time at which the signature was last refreshed.
    pub signature_inception: u32,
    /// The key tag of the key that was used to create the signature.
    pub key_tag: u16,
    /// The name of the zone that this signature was created for.
    pub signer_name: DnsName<'a>,
    /// The signature.
    pub signature: Characters<'a>,
}

impl<'a> RDataParse<'a> for RRSig<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let type_covered = u16::parse(rdata.buffer, i)?;
        let algorithm = u8::parse(rdata.buffer, i)?;
        let original_ttl = u32::parse(rdata.buffer, i)?;
        let signature_expiration = u32::parse(rdata.buffer, i)?;
        let signature_inception = u32::parse(rdata.buffer, i)?;
        let key_tag = u16::parse(rdata.buffer, i)?;
        let signer_name = DnsName::parse(rdata.buffer, i)?;
        let signature = Characters::parse(rdata.buffer, i)?;

        Ok(Self {
            type_covered,
            algorithm,
            original_ttl,
            signature_expiration,
            signature_inception,
            key_tag,
            signer_name,
            signature,
        })
    }
}

impl<'a> WriteBytes for RRSig<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.type_covered.write(message)?;
        self.algorithm.write(message)?;
        self.original_ttl.write(message)?;
        self.signature_expiration.write(message)?;
        self.signature_inception.write(message)?;
        self.key_tag.write(message)?;
        self.signer_name.write(message)?;
        self.signature.write(message)
    }
}

impl<'a> RRSig<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(18 + self.signer_name.byte_len()? + self.signature.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        42,
        [
            0x00, 0x0e, // type covered
            0x05, // algorithm
            0x00, 0x00, 0x00, 0x0a, // original ttl
            0x00, 0x00, 0x00, 0x0b, // signature expiration
            0x00, 0x00, 0x00, 0x0c, // signature inception
            0x00, 0x0d, // key tag
            0x03, b'w', b'w', b'w',
            0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00, // signer name
            0x07, b'f', b'o', b'o', b'-', b'b', b'a', b'r', // signature
        ],
        RRSig {
            type_covered: 14,
            algorithm: 5,
            original_ttl: 10,
            signature_expiration: 11,
            signature_inception: 12,
            key_tag: 13,
            signer_name: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x07example\x03com\x00") },
            signature: unsafe { Characters::new_unchecked(b"foo-bar") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/sig.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Signature
/// This record is used to authenticate the data in a message
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Sig<'a> {
    /// The type of the record covered by this signature
    type_covered: u16,
    /// The algorithm used
    algorithm: u8,
    /// The number of labels in the original RDATA
    labels: u8,
    /// The original TTL
    original_ttl: u32,
    /// The signature expiration
    signature_expiration: u32,
    /// The signature inception
    signature_inception: u32,
    /// The key tag
    key_tag: u16,
    /// The signer's name
    signer_name: DnsName<'a>,
    /// The signature
    signature: Characters<'a>,
}

impl<'a> RDataParse<'a> for Sig<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let type_covered = u16::parse(rdata, i)?;
        let algorithm = u8::parse(rdata, i)?;
        let labels = u8::parse(rdata, i)?;
        let original_ttl = u32::parse(rdata, i)?;
        let signature_expiration = u32::parse(rdata, i)?;
        let signature_inception = u32::parse(rdata, i)?;
        let key_tag = u16::parse(rdata, i)?;
        let signer_name = DnsName::parse(rdata, i)?;
        let signature = Characters::parse(rdata, i)?;

        Ok(Self {
            type_covered,
            algorithm,
            labels,
            original_ttl,
            signature_expiration,
            signature_inception,
            key_tag,
            signer_name,
            signature,
        })
    }
}

impl<'a> WriteBytes for Sig<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.type_covered.write(message)?;
        self.algorithm.write(message)?;
        self.labels.write(message)?;
        self.original_ttl.write(message)?;
        self.signature_expiration.write(message)?;
        self.signature_inception.write(message)?;
        self.key_tag.write(message)?;
        self.signer_name.write(message)?;
        self.signature.write(message)
    }
}

impl<'a> Sig<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(18 + self.signer_name.byte_len()? + self.signature.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        43,
        [
            0x00, 0x0e, // type covered
            0x05, // algorithm
            0x06, // labels
            0x00, 0x00, 0x00, 0x0a, // original ttl
            0x00, 0x00, 0x00, 0x0b, // signature expiration
            0x00, 0x00, 0x00, 0x0c, // signature inception
            0x00, 0x0d, // key tag
            0x03, b'w', b'w', b'w',
            0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00, // signer name
            0x07, b'f', b'o', b'o', b'-', b'b', b'a', b'r', // signature
        ],
        Sig {
            type_covered: 14,
            algorithm: 5,
            labels: 6,
            original_ttl: 10,
            signature_expiration: 11,
            signature_inception: 12,
            key_tag: 13,
            signer_name: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x07example\x03com\x00") },
            signature: unsafe { Characters::new_unchecked(b"foo-bar") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/smimea.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # S/MIME cert association record (SMIMEA)
/// This record is used to store S/MIME certificate association
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct SmimeA<'a> {
    /// The usage of the certificate
    pub usage: u8,
    /// The selector of the certificate
    pub selector: u8,
    /// The matching type of the certificate
    pub matching_type: u8,
    /// The certificate data
    pub certificate: Characters<'a>,
}

impl<'a> RDataParse<'a> for SmimeA<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let usage = u8::parse(rdata, i)?;
        let selector = u8::parse(rdata, i)?;
        let matching_type = u8::parse(rdata, i)?;
        let certificate = Characters::parse(rdata, i)?;

        Ok(Self {
            usage,
            selector,
            matching_type,
            certificate,
        })
    }
}

impl<'a> WriteBytes for SmimeA<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.usage.write(message)?;
        self.selector.write(message)?;
        self.matching_type.write(message)?;
        self.certificate.write(message)
    }
}

impl<'a> SmimeA<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(3 + self.certificate.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        19,
        [
            0x0e, // usage
            0x0f, // selector
            0x10, // matching type
            0x0f, // length of certificate
            0x01, 0x02, 0x03, 0x04, 0x05,
            0x06, 0x07, 0x08, 0x09, 0x0a,
            0x0b, 0x0c, 0x0d, 0x0e, 0x0f, // certificate
        ],
        SmimeA {
            usage: 0x0e,
            selector: 0x0f,
            matching_type: 0x10,
            certificate: unsafe { Characters::new_unchecked(&[
                0x01, 0x02, 0x03, 0x04, 0x05,
                0x06, 0x07, 0x08, 0x09, 0x0a,
                0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
            ]) },
        },
    );
}

/mnt/h/flex-dns/src/rdata/soa.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Marks the start of a zone of authority
/// This record is used to mark the start of a zone of authority
/// and contains the parameters of the zone
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Soa<'a> {
    /// The domain name of the name server that was the
    /// original or primary source of data for this zone
    pub mname: DnsName<'a>,
    /// A domain name which specifies the mailbox of the
    /// person responsible for this zone
    pub rname: DnsName<'a>,
    /// The unsigned 32 bit version number of the original copy
    /// of the zone. Zone transfers preserve this value. This
    /// value wraps and should be compared using sequence space
    /// arithmetic
    pub serial: u32,
    /// A 32 bit time interval before the zone should be
    /// refreshed
    pub refresh: u32,
    /// A 32 bit time interval that should elapse before a
    /// failed refresh should be retried
    pub retry: u32,
    /// A 32 bit time value that specifies the upper limit on
    /// the time interval that can elapse before the zone is no
    /// longer authoritative
    pub expire: u32,
    /// The unsigned 32 bit minimum TTL field that should be
    /// exported with any RR from this zone
    pub minimum: u32,
}

impl<'a> RDataParse<'a> for Soa<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let mname = DnsName::parse(rdata.buffer, i)?;
        let rname = DnsName::parse(rdata.buffer, i)?;
        let serial = u32::parse(rdata.buffer, i)?;
        let refresh = u32::parse(rdata.buffer, i)?;
        let retry = u32::parse(rdata.buffer, i)?;
        let expire = u32::parse(rdata.buffer, i)?;
        let minimum = u32::parse(rdata.buffer, i)?;

        Ok(Self {
            mname,
            rname,
            serial,
            refresh,
            retry,
            expire,
            minimum,
        })
    }
}

impl<'a> WriteBytes for Soa<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.mname.write(message)?;
        self.rname.write(message)?;
        self.serial.write(message)?;
        self.refresh.write(message)?;
        self.retry.write(message)?;
        self.expire.write(message)?;
        self.minimum.write(message)
    }
}

impl<'a> Soa<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.mname.byte_len()? + self.rname.byte_len()? + 20)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        53,
        [
            0x03, b'w', b'w', b'w',
            0x07, b'e', b'x', b'a', b'm', b'p', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00, // mname
            0x03, b'w', b'w', b'w',
            0x06, b'g', b'o', b'o', b'g', b'l', b'e',
            0x03, b'c', b'o', b'm',
            0x00, // rname
            0x00, 0x00, 0x00, 0x0e, // serial
            0x00, 0x00, 0x00, 0x0f, // refresh
            0x00, 0x00, 0x00, 0x10, // retry
            0x00, 0x00, 0x00, 0x11, // expire
            0x00, 0x00, 0x00, 0x12, // minimum
        ],
        Soa {
            mname: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x07example\x03com\x00") },
            rname: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x06google\x03com\x00") },
            serial: 14,
            refresh: 15,
            retry: 16,
            expire: 17,
            minimum: 18,
        },
    );
}

/mnt/h/flex-dns/src/rdata/srv.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Service locator
/// This record is used to return a service location
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Srv<'a> {
    /// The priority of the target host
    pub priority: u16,
    /// The weight of the target host
    pub weight: u16,
    /// The port on the target host
    pub port: u16,
    /// The target host
    pub target: DnsName<'a>,
}

impl<'a> RDataParse<'a> for Srv<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let priority = u16::parse(rdata.buffer, i)?;
        let weight = u16::parse(rdata.buffer, i)?;
        let port = u16::parse(rdata.buffer, i)?;
        let target = DnsName::parse(rdata.buffer, i)?;

        Ok(Self {
            priority,
            weight,
            port,
            target,
        })
    }
}

impl<'a> WriteBytes for Srv<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.priority.write(message)?;
        self.weight.write(message)?;
        self.port.write(message)?;
        self.target.write(message)
    }
}

impl<'a> Srv<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(6 + self.target.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        11,
        [
            0x00, 0x0e, // priority
            0x00, 0x0e, // weight
            0x00, 0x0e, // port
            0x03,
            b'w', b'w', b'w',
            0x00, // target
        ],
        Srv {
            priority: 14,
            weight: 14,
            port: 14,
            target: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x00") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/sshfp.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # SSH public key fingerprint record
/// This record is used to store the fingerprint of an SSH public key.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct SshFp<'a> {
    /// The algorithm used to generate the fingerprint.
    pub algorithm: u8,
    /// The fingerprint type.
    pub fingerprint_type: u8,
    /// The fingerprint data.
    pub data: Characters<'a>,
}

impl<'a> RDataParse<'a> for SshFp<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let algorithm = u8::parse(rdata.buffer, i)?;
        let fingerprint_type = u8::parse(rdata.buffer, i)?;
        let data = Characters::parse(rdata.buffer, i)?;

        Ok(Self {
            algorithm,
            fingerprint_type,
            data,
        })
    }
}

impl<'a> WriteBytes for SshFp<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.algorithm.write(message)?;
        self.fingerprint_type.write(message)?;
        self.data.write(message)
    }
}

impl<'a> SshFp<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(2 + self.data.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        6,
        [
            0x01, // algorithm
            0x02, // fingerprint type
            0x03, // length of "www"
            b'w', b'w', b'w', // "www"
        ],
        SshFp {
            algorithm: 1,
            fingerprint_type: 2,
            data: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/svcb.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Service binding record (SVCB)
/// This record is used to describe the parameters of a service binding.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Svcb<'a> {
    /// The priority of this target host
    pub priority: u16,
    /// The relative weight for entries with the same priority
    pub weight: u16,
    /// The TCP or UDP port on which the service is to be found
    pub port: u16,
    /// The domain name of the target host
    pub target: DnsName<'a>,
    /// The parameters of the service binding
    pub parameters: Characters<'a>,
}

impl<'a> RDataParse<'a> for Svcb<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let priority = u16::parse(rdata, i)?;
        let weight = u16::parse(rdata, i)?;
        let port = u16::parse(rdata, i)?;
        let target = DnsName::parse(rdata, i)?;
        let parameters = Characters::parse(rdata, i)?;

        Ok(Self {
            priority,
            weight,
            port,
            target,
            parameters
        })
    }
}

impl<'a> WriteBytes for Svcb<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.priority.write(message)?;
        self.weight.write(message)?;
        self.port.write(message)?;
        self.target.write(message)?;
        self.parameters.write(message)
    }
}

impl<'a> Svcb<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(6 + self.target.byte_len()? + self.parameters.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        15,
        [
            0x00, 0x0e, // priority
            0x00, 0x0e, // weight
            0x00, 0x0e, // port
            0x03, // length of "www"
            b'w', b'w', b'w', // "www"
            0x00, // end of name
            0x03, // length of "www"
            b'w', b'w', b'w', // "www"
        ],
        Svcb {
            priority: 14,
            weight: 14,
            port: 14,
            target: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x00") },
            parameters: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/ta.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # DNSSEC trust authorities record (TA)
/// This record is used to publish the public key of a DNSSEC trust anchor.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Ta<'a> {
    /// trust_anchor_link is the trust anchor link
    pub trust_anchor_link: Characters<'a>,
}

impl<'a> RDataParse<'a> for Ta<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let trust_anchor_link = Characters::parse(rdata, i)?;

        Ok(Self {
            trust_anchor_link,
        })
    }
}

impl<'a> WriteBytes for Ta<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.trust_anchor_link.write(message)
    }
}

impl<'a> Ta<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.trust_anchor_link.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        4,
        [
            0x03,
            b'w', b'w', b'w', // trust_anchor_link
        ],
        Ta {
            trust_anchor_link: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/tkey.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Transaction key record (TKEY)
/// This record is used to establish a shared key between two hosts.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct TKey<'a> {
    /// The algorithm used to generate the key.
    pub algorithm: DnsName<'a>,
    /// The time the key was generated.
    pub inception: u32,
    /// The time the key will expire.
    pub expiration: u32,
    /// The mode of the key.
    pub mode: u16,
    /// The error that occurred.
    pub error: u16,
    /// The key data.
    pub key: Characters<'a>,
    /// The other data.
    pub other: Characters<'a>,
}

impl<'a> RDataParse<'a> for TKey<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let algorithm = DnsName::parse(rdata.buffer, i)?;
        let inception = u32::parse(rdata.buffer, i)?;
        let expiration = u32::parse(rdata.buffer, i)?;
        let mode = u16::parse(rdata.buffer, i)?;
        let error = u16::parse(rdata.buffer, i)?;
        let key = Characters::parse(rdata.buffer, i)?;
        let other = Characters::parse(rdata.buffer, i)?;

        Ok(Self {
            algorithm,
            inception,
            expiration,
            mode,
            error,
            key,
            other,
        })
    }
}

impl<'a> WriteBytes for TKey<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.algorithm.write(message)?;
        self.inception.write(message)?;
        self.expiration.write(message)?;
        self.mode.write(message)?;
        self.error.write(message)?;
        self.key.write(message)?;
        self.other.write(message)
    }
}

impl<'a> TKey<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.algorithm.byte_len()? + 4 + 4 + 2 + 2 + self.key.byte_len()? + self.other.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        25,
        [
            0x03, b'w', b'w', b'w', 0x00, // algorithm
            0x00, 0x00, 0x00, 0x0a, // inception
            0x00, 0x00, 0x00, 0x0b, // expiration
            0x00, 0x0c, // mode
            0x00, 0x0d, // error
            0x03, b'w', b'w', b'w', // key
            0x03, b'w', b'w', b'w', // other
        ],
        TKey {
            algorithm: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x00") },
            inception: 10,
            expiration: 11,
            mode: 12,
            error: 13,
            key: unsafe { Characters::new_unchecked(b"www") },
            other: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/tlsa.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Transport Layer Security Authentication (TLSA) Record
/// This record is used to associate a TLS server certificate or public key with
/// the domain name where the record is found, thus forming a "TLSA certificate association".
/// This record type is described in [RFC 6698](https://tools.ietf.org/html/rfc6698).
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Tlsa<'a> {
    usage: u8,
    selector: u8,
    matching_type: u8,
    certificate_association_data: Characters<'a>,
}

impl<'a> RDataParse<'a> for Tlsa<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let usage = u8::parse(rdata, i)?;
        let selector = u8::parse(rdata, i)?;
        let matching_type = u8::parse(rdata, i)?;
        let certificate_association_data = Characters::parse(rdata, i)?;

        Ok(Self {
            usage,
            selector,
            matching_type,
            certificate_association_data,
        })
    }
}

impl<'a> WriteBytes for Tlsa<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.usage.write(message)?;
        self.selector.write(message)?;
        self.matching_type.write(message)?;
        self.certificate_association_data.write(message)
    }
}

impl<'a> Tlsa<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(3 + self.certificate_association_data.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        7,
        [
            0x0a, // usage
            0x0b, // selector
            0x0c, // matching type
            0x03, // length of certificate association data
            0x77, 0x77, 0x77, // certificate association data
        ],
        Tlsa {
            usage: 10,
            selector: 11,
            matching_type: 12,
            certificate_association_data: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/tsig.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::name::DnsName;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Transaction signature record (TSIG)
/// This record is used to authenticate dynamic updates as coming from an
/// approved client, and to authenticate responses as coming from an approved
/// recursive server.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct TSig<'a> {
    /// The name of the algorithm in domain name syntax.
    pub algorithm: DnsName<'a>,
    /// The time that the signature was generated.
    pub time_signed: u64,
    /// The Fudge value is an unsigned 8-bit field that specifies the allowed
    /// time difference in seconds.
    pub fudge: u8,
    /// The MAC is a variable length octet string containing the message
    /// authentication code.
    pub mac: Characters<'a>,
    /// The original ID of the message.
    pub original_id: u16,
    /// The error field is an unsigned 16-bit field that contains the extended
    /// RCODE covering TSIG processing.
    pub error: u16,
    /// The other field is a variable length octet string that contains
    /// information that may be used by the server to complete the transaction.
    pub other: Characters<'a>,
}

impl<'a> RDataParse<'a> for TSig<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let algorithm = DnsName::parse(rdata, i)?;
        let time_signed = u64::parse(rdata, i)?;
        let fudge = u8::parse(rdata, i)?;
        let mac = Characters::parse(rdata, i)?;
        let original_id = u16::parse(rdata, i)?;
        let error = u16::parse(rdata, i)?;
        let other = Characters::parse(rdata, i)?;

        Ok(Self {
            algorithm,
            time_signed,
            fudge,
            mac,
            original_id,
            error,
            other,
        })
    }
}

impl<'a> WriteBytes for TSig<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.algorithm.write(message)?;
        self.time_signed.write(message)?;
        self.fudge.write(message)?;
        self.mac.write(message)?;
        self.original_id.write(message)?;
        self.error.write(message)?;
        self.other.write(message)
    }
}

impl<'a> TSig<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.algorithm.byte_len()? + 10 + self.mac.byte_len()? + self.other.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        26,
        [
            0x03, b'w', b'w', b'w', 0x00, // algorithm
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, // time_signed
            0x0b, // fudge
            0x03, 0x77, 0x77, 0x77, // mac
            0x00, 0x0c, // original_id
            0x00, 0x0d, // error
            0x03, 0x77, 0x77, 0x77, // other
        ],
        TSig {
            algorithm: unsafe { DnsName::from_bytes_unchecked(b"\x03www\x00") },
            time_signed: 10,
            fudge: 11,
            mac: unsafe { Characters::new_unchecked(b"www") },
            original_id: 12,
            error: 13,
            other: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/txt.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsError, DnsMessage, DnsMessageError, DnsSection};
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # The txt record
/// This record is used to hold arbitrary text data.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Txt<'a> {
    /// The text data
    data: &'a [u8],
}

#[macro_export]
macro_rules! dns_txt {
    ($value:expr $(, $values:expr)* $(,)?) => {
        {
            const TXT: [u8; { $value.len() + 1 $(+ $values.len() + 1)* }] = {
                let mut result = [0; $value.len() + 1 $(+ $values.len() + 1)*];
                result[0] = $value.len() as u8;

                let mut index = 1;
                let mut r_index = 0;
                loop {
                    if r_index == $value.len() {
                        break;
                    }

                    result[index] = $value[r_index];
                    r_index += 1;
                    index += 1;
                }

                $(
                    result[index] = $values.len() as u8;
                    index += 1;

                    let mut r_index = 0;
                    loop {
                        if r_index == $values.len() {
                            break;
                        }

                        result[index] = $values[r_index];
                        r_index += 1;
                        index += 1;
                    }
                )*

                result
            };

            unsafe { Txt::new_unchecked(&TXT) }
        }
    };
}

impl<'a> RDataParse<'a> for Txt<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let data = &rdata.buffer[*i..*i + rdata.len];
        *i += rdata.len;

        Ok(Self {
            data,
        })
    }
}

impl<'a> WriteBytes for Txt<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(self.data)
    }
}

impl<'a> Txt<'a> {
    #[inline]
    pub fn new(data: &'a [u8]) -> Result<Self, DnsMessageError> {
        for r in (TxtIterator {
            data,
            pos: 0,
        }) {
            r?;
        }

        Ok(Self {
            data,
        })
    }

    #[inline]
    pub const unsafe fn new_unchecked(data: &'a [u8]) -> Self {
        Self {
            data,
        }
    }

    #[inline(always)]
    pub fn iter(&self) -> TxtIterator<'a> {
        TxtIterator {
            data: self.data,
            pos: 0,
        }
    }

    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(self.data.len())
    }
}

#[derive(Copy, Clone, Debug)]
pub struct TxtIterator<'a> {
    data: &'a [u8],
    pos: usize,
}

impl<'a> Iterator for TxtIterator<'a> {
    type Item = Result<&'a [u8], DnsMessageError>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.pos >= self.data.len() {
            return None;
        }

        let len = self.data[self.pos] as usize;

        if len == 0 && self.pos + 1 == self.data.len() {
            return None;
        } else if len == 0 {
            return Some(Err(DnsMessageError::DnsError(DnsError::InvalidTxtRecord)));
        }

        self.pos += 1;

        let end = self.pos + len;

        if end > self.data.len() {
            return Some(Err(DnsMessageError::DnsError(DnsError::InvalidTxtRecord)));
        }

        let result = &self.data[self.pos..end];
        self.pos = end;

        Some(Ok(result))
    }
}

/mnt/h/flex-dns/src/rdata/uri.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Uniform resource identifier record (URI)
/// This record is used to publish mappings from hostnames to URIs.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct Uri<'a> {
    /// The priority of this URI record. Lower values are preferred.
    pub priority: u16,
    /// The weight of this URI record. Higher values are preferred.
    pub weight: u16,
    /// The target URI.
    pub target: Characters<'a>,
}

impl<'a> RDataParse<'a> for Uri<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let priority = u16::parse(rdata, i)?;
        let weight = u16::parse(rdata, i)?;
        let target = Characters::parse(rdata, i)?;

        Ok(Self {
            priority,
            weight,
            target,
        })
    }
}

impl<'a> WriteBytes for Uri<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.priority.write(message)?;
        self.weight.write(message)?;
        self.target.write(message)
    }
}

impl<'a> Uri<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(4 + self.target.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        8,
        [
            0x00, 0x0e, // priority
            0x00, 0x0e, // weight
            0x03, // length of "www"
            b'w', b'w', b'w', // "www"
        ],
        Uri {
            priority: 14,
            weight: 14,
            target: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/rdata/zonemd.rs

Source (jump to first uncovered line)
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};
use crate::characters::Characters;
use crate::parse::Parse;
use crate::rdata::{RData, RDataParse};
use crate::write::WriteBytes;

/// # Message digest for DNS zone record (ZONEMD)
/// This record is used to publish a message digest for a DNS zone.
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct ZoneMd<'a> {
    /// algorithm is the algorithm of the digest
    pub algorithm: u8,
    /// digest_type is the algorithm used to construct the digest
    pub digest_type: u8,
    /// digest is the digest of the zone
    pub digest: Characters<'a>,
}

impl<'a> RDataParse<'a> for ZoneMd<'a> {
    #[inline]
    fn parse(rdata: &RData<'a>, i: &mut usize) -> Result<Self, DnsMessageError> {
        let algorithm = u8::parse(rdata, i)?;
        let digest_type = u8::parse(rdata, i)?;
        let digest = Characters::parse(rdata, i)?;

        Ok(Self {
            algorithm,
            digest_type,
            digest
        })
    }
}

impl<'a> WriteBytes for ZoneMd<'a> {
    #[inline]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        self.algorithm.write(message)?;
        self.digest_type.write(message)?;
        self.digest.write(message)
    }
}

impl<'a> ZoneMd<'a> {
    #[inline(always)]
    pub(crate) fn byte_len(&self) -> Result<usize, DnsMessageError> {
        Ok(2 + self.digest.byte_len()?)
    }
}

#[cfg(test)]
mod test {
    use crate::rdata::testutils::parse_write_test;

    use super::*;

    parse_write_test!(
        6,
        [
            0x0e, // algorithm
            0x00, // digest_type
            0x03, // digest length
            b'w', b'w', b'w', // digest
        ],
        ZoneMd {
            algorithm: 14,
            digest_type: 0,
            digest: unsafe { Characters::new_unchecked(b"www") },
        },
    );
}

/mnt/h/flex-dns/src/write.rs

Source (jump to first uncovered line)
use core::net::{Ipv4Addr, Ipv6Addr};
use crate::{Buffer, DnsMessage, DnsMessageError, DnsSection};

pub(crate) trait WriteBytes {
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError>;
}

impl WriteBytes for u8 {
    #[inline(always)]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(&[*self])
    }
}

impl WriteBytes for u16 {
    #[inline(always)]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(&self.to_be_bytes())
    }
}

impl WriteBytes for u32 {
    #[inline(always)]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(&self.to_be_bytes())
    }
}

impl WriteBytes for u64 {
    #[inline(always)]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(&self.to_be_bytes())
    }
}

impl<const SIZE: usize> WriteBytes for [u8; SIZE] {
    #[inline(always)]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(self)
    }
}

impl WriteBytes for Ipv4Addr {
    #[inline(always)]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(&self.octets())
    }
}

impl WriteBytes for Ipv6Addr {
    #[inline(always)]
    fn write<
        const PTR_STORAGE: usize,
        const DNS_SECTION: DnsSection,
        B: Buffer,
    >(&self, message: &mut DnsMessage<PTR_STORAGE, DNS_SECTION, B>) -> Result<(), DnsMessageError> {
        message.write_bytes(&self.octets())
    }
}

Line	Count	Source (jump to first uncovered line)
1		use std::fmt;
2		#[cfg(feature="std")]
3		use std::any::Any;
4		#[cfg(feature="std")]
5		use std::error::Error;
6
7		/// Error value indicating insufficient capacity
8		#[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
9		pub struct CapacityError<T = ()> {
10		element: T,
11		}
12
13		impl<T> CapacityError<T> {
14		/// Create a new `CapacityError` from `element`.
15	0	pub const fn new(element: T) -> CapacityError<T> {
16	0	CapacityError {
17	0	element: element,
18	0	}
19	0	} Unexecuted instantiation: _RNvMNtCskQaAGJdWXwX_8arrayvec6errorsNtB2_13CapacityError3newCsgg978DXfVXR_13fuzz_target_1 Unexecuted instantiation: _RNvMNtCskQaAGJdWXwX_8arrayvec6errorsINtB2_13CapacityErrorjE3newCslLTLXfmDngu_8flex_dns
20
21		/// Extract the overflowing element
22		pub fn element(self) -> T {
23		self.element
24		}
25
26		/// Convert into a `CapacityError` that does not carry an element.
27		pub fn simplify(self) -> CapacityError {
28		CapacityError { element: () }
29		}
30		}
31
32		const CAPERROR: &'static str = "insufficient capacity";
33
34		#[cfg(feature="std")]
35		/// Requires `features="std"`.
36		impl<T: Any> Error for CapacityError<T> {}
37
38		impl<T> fmt::Display for CapacityError<T> {
39		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
40		write!(f, "{}", CAPERROR)
41		}
42		}
43
44		impl<T> fmt::Debug for CapacityError<T> {
45	0	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
46	0	write!(f, "{}: {}", "CapacityError", CAPERROR)
47	0	} Unexecuted instantiation: _RNvXs1_NtCskQaAGJdWXwX_8arrayvec6errorsNtB5_13CapacityErrorNtNtCs6xNykbTfrCs_4core3fmt5Debug3fmtCsgg978DXfVXR_13fuzz_target_1 Unexecuted instantiation: _RNvXs1_NtCskQaAGJdWXwX_8arrayvec6errorsINtB5_13CapacityErrorjENtNtCs6xNykbTfrCs_4core3fmt5Debug3fmtCslLTLXfmDngu_8flex_dns
48		}
49