Move and rename

Author: domenukk

libafl/src/inputs/bytessub.rs

@@ -2,244 +2,17 @@
 
 use alloc::vec::{self, Vec};
 use core::{
-    cmp::{min, Ordering},
-    ops::{Bound, Range, RangeBounds},
+    cmp::Ordering,
+    ops::{Range, RangeBounds},
 };
 
 use libafl_bolts::{
-    ownedref::{OwnedMutSlice, OwnedSlice},
+    subrange::{end_index, start_index, sub_range},
     HasLen,
 };
 
 use crate::inputs::HasMutatorBytes;
 
-/// Gets the relevant concrete start index from [`RangeBounds`] (inclusive)
-fn start_index<R>(range: &R) -> usize
-where
-    R: RangeBounds<usize>,
-{
-    match range.start_bound() {
-        Bound::Unbounded => 0,
-        Bound::Included(start) => *start,
-        Bound::Excluded(start) => start + 1,
-    }
-}
-
-/// Gets the relevant concrete end index from [`RangeBounds`] (exclusive)
-fn end_index<R>(range: &R, max_len: usize) -> usize
-where
-    R: RangeBounds<usize>,
-{
-    let end = match range.end_bound() {
-        Bound::Unbounded => max_len,
-        Bound::Included(end) => end + 1,
-        Bound::Excluded(end) => *end,
-    };
-
-    min(end, max_len)
-}
-
-fn sub_range<R>(outer_range: &Range<usize>, inner_range: R) -> (Bound<usize>, Bound<usize>)
-where
-    R: RangeBounds<usize>,
-{
-    let start =
-        match (outer_range.start_bound(), inner_range.start_bound()) {
-            (Bound::Unbounded, Bound::Unbounded) => Bound::Unbounded,
-            (Bound::Excluded(bound), Bound::Unbounded)
-            | (Bound::Unbounded, Bound::Excluded(bound)) => Bound::Excluded(*bound),
-            (Bound::Included(bound), Bound::Unbounded)
-            | (Bound::Unbounded, Bound::Included(bound)) => Bound::Included(*bound),
-            (Bound::Included(own), Bound::Included(other)) => Bound::Included(own + other),
-            (Bound::Included(own), Bound::Excluded(other))
-            | (Bound::Excluded(own), Bound::Included(other)) => Bound::Excluded(own + other),
-            (Bound::Excluded(own), Bound::Excluded(other)) => Bound::Excluded(own + other + 1),
-        };
-
-    let end = match (outer_range.end_bound(), inner_range.end_bound()) {
-        (Bound::Unbounded, Bound::Unbounded) => Bound::Unbounded,
-        (Bound::Excluded(bound), Bound::Unbounded) => Bound::Excluded(*bound),
-        (Bound::Unbounded, Bound::Excluded(bound)) => Bound::Excluded(outer_range.end - *bound),
-        (Bound::Included(bound), Bound::Unbounded) => Bound::Included(*bound),
-        (Bound::Unbounded, Bound::Included(bound)) => Bound::Included(outer_range.end - *bound),
-        (Bound::Included(own), Bound::Included(other)) => {
-            Bound::Included(min(*own, outer_range.start + other))
-        }
-        (Bound::Included(own), Bound::Excluded(other)) => {
-            Bound::Included(min(*own, outer_range.start + other - 1))
-        }
-        (Bound::Excluded(own), Bound::Included(other)) => {
-            Bound::Included(min(*own - 1, outer_range.start + other))
-        }
-        (Bound::Excluded(own), Bound::Excluded(other)) => {
-            Bound::Excluded(min(*own, outer_range.start + other))
-        }
-    };
-
-    (start, end)
-}
-
-/// An immutable contiguous subslice of a byte slice.
-/// It is mostly useful to cheaply wrap a subslice of a given input.
-///
-/// A mutable version is available: [`BytesSliceMut`].
-#[derive(Debug)]
-pub struct BytesSlice<'a> {
-    /// The (complete) parent input we will work on
-    parent_slice: OwnedSlice<'a, u8>,
-    /// The range inside the parent input we will work on
-    range: Range<usize>,
-}
-
-impl<'a> HasLen for BytesSlice<'a> {
-    #[inline]
-    fn len(&self) -> usize {
-        self.range.len()
-    }
-}
-
-impl<'a> BytesSlice<'a> {
-    /// Creates a new [`BytesSlice`], a sub-slice representation of a byte array.
-    pub fn new<R>(parent_slice: OwnedSlice<'a, u8>, range: R) -> Self
-    where
-        R: RangeBounds<usize>,
-    {
-        let parent_len = parent_slice.len();
-
-        BytesSlice {
-            parent_slice,
-            range: Range {
-                start: start_index(&range),
-                end: end_index(&range, parent_len),
-            },
-        }
-    }
-
-    /// Get the sub slice as bytes.
-    #[must_use]
-    pub fn bytes(&self) -> &[u8] {
-        &self.parent_slice[self.range.clone()]
-    }
-
-    /// Creates a new [`BytesSlice`] that's a sliced view on a bytes slice.
-    pub fn with_slice<R>(parent_slice: &'a [u8], range: R) -> Self
-    where
-        R: RangeBounds<usize>,
-    {
-        Self::new(parent_slice.into(), range)
-    }
-
-    /// The parent input
-    #[must_use]
-    pub fn parent_slice(self) -> OwnedSlice<'a, u8> {
-        self.parent_slice
-    }
-
-    /// The inclusive start index in the parent buffer
-    #[must_use]
-    pub fn start_index(&self) -> usize {
-        self.range.start
-    }
-
-    /// The exclusive end index in the parent buffer
-    #[must_use]
-    pub fn end_index(&self) -> usize {
-        self.range.end
-    }
-
-    /// Creates a sub range in the current own range
-    pub fn sub_range<R>(&self, range: R) -> (Bound<usize>, Bound<usize>)
-    where
-        R: RangeBounds<usize>,
-    {
-        sub_range(&self.range, range)
-    }
-}
-
-/// A mutable contiguous subslice of a byte slice.
-/// It is mostly useful to cheaply wrap a subslice of a given input.
-///
-/// An immutable version is available: [`BytesSlice`].
-#[derive(Debug)]
-pub struct BytesSliceMut<'a> {
-    /// The (complete) parent input we will work on
-    parent_slice: OwnedMutSlice<'a, u8>,
-    /// The range inside the parent input we will work on
-    range: Range<usize>,
-}
-
-impl<'a> BytesSliceMut<'a> {
-    /// Creates a new [`BytesSliceMut`], a sub-slice representation of a byte array.
-    pub fn new<R>(parent_slice: OwnedMutSlice<'a, u8>, range: R) -> Self
-    where
-        R: RangeBounds<usize>,
-    {
-        let parent_len = parent_slice.len();
-
-        BytesSliceMut {
-            parent_slice,
-            range: Range {
-                start: start_index(&range),
-                end: end_index(&range, parent_len),
-            },
-        }
-    }
-
-    /// Get the sub slice as bytes.
-    #[must_use]
-    pub fn bytes(&self) -> &[u8] {
-        &self.parent_slice[self.range.clone()]
-    }
-
-    /// Get the sub slice as bytes.
-    #[must_use]
-    pub fn bytes_mut(&mut self) -> &mut [u8] {
-        &mut self.parent_slice[self.range.clone()]
-    }
-
-    /// Creates a new [`BytesSliceMut`] that's a view on a bytes slice.
-    /// The sub-slice can then be used to mutate parts of the original bytes.
-    pub fn with_slice<R>(parent_slice: &'a mut [u8], range: R) -> Self
-    where
-        R: RangeBounds<usize>,
-    {
-        Self::new(parent_slice.into(), range)
-    }
-
-    /// The parent input
-    #[must_use]
-    pub fn parent_slice(self) -> OwnedMutSlice<'a, u8> {
-        self.parent_slice
-    }
-
-    /// The inclusive start index in the parent buffer
-    #[must_use]
-    pub fn start_index(&self) -> usize {
-        self.range.start
-    }
-
-    /// The exclusive end index in the parent buffer
-    #[must_use]
-    pub fn end_index(&self) -> usize {
-        self.range.end
-    }
-
-    /// Creates a sub range in the current own range
-    pub fn sub_range<R>(&self, range: R) -> (Bound<usize>, Bound<usize>)
-    where
-        R: RangeBounds<usize>,
-    {
-        sub_range(&self.range, range)
-    }
-}
-
-impl<'a> HasLen for BytesSliceMut<'a> {
-    #[inline]
-    fn len(&self) -> usize {
-        self.range.len()
-    }
-}
-
 /// The [`BytesSubInput`] makes it possible to use [`crate::mutators::Mutator`]`s` that work on
 /// inputs implementing the [`HasMutatorBytes`] for a sub-range of this input.
 /// For example, we can do the following:

libafl_bolts/src/lib.rs

@@ -131,6 +131,7 @@ pub mod serdeany;
 pub mod shmem;
 #[cfg(feature = "std")]
 pub mod staterestore;
+pub mod subrange;
 // TODO: reenable once ahash works in no-alloc
 #[cfg(any(feature = "xxh3", feature = "alloc"))]
 pub mod tuples;