[pve-devel] [PATCH proxmox v3 01/13] io: introduce RangeReader for bounded reads

[Filip Schauer]

Signed-off-by: Filip Schauer <f.schauer at proxmox.com>
---
Introduced in v3

 proxmox-io/src/lib.rs          |  3 ++
 proxmox-io/src/range_reader.rs | 94 ++++++++++++++++++++++++++++++++++
 2 files changed, 97 insertions(+)
 create mode 100644 proxmox-io/src/range_reader.rs

diff --git a/proxmox-io/src/lib.rs b/proxmox-io/src/lib.rs
index 1be005ff..a05b9232 100644
--- a/proxmox-io/src/lib.rs
+++ b/proxmox-io/src/lib.rs
@@ -6,6 +6,9 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
+mod range_reader;
+pub use range_reader::RangeReader;
+
 mod read;
 pub use read::ReadExt;
 
diff --git a/proxmox-io/src/range_reader.rs b/proxmox-io/src/range_reader.rs
new file mode 100644
index 00000000..307bfe27
--- /dev/null
+++ b/proxmox-io/src/range_reader.rs
@@ -0,0 +1,94 @@
+use std::io::{Read, Seek, SeekFrom};
+use std::ops::Range;
+
+pub struct RangeReader<R: Read + Seek> {
+    reader: R,
+
+    /// Range inside `R`.
+    range: Range<u64>,
+
+    /// Relative position inside `range`
+    position: u64,
+
+    /// True once the initial seek has been performed
+    ready: bool,
+}
+
+impl<R: Read + Seek> RangeReader<R> {
+    pub fn new(reader: R, range: Range<u64>) -> Self {
+        Self {
+            reader,
+            range,
+            position: 0,
+            ready: false,
+        }
+    }
+
+    pub fn into_inner(self) -> R {
+        self.reader
+    }
+
+    pub fn size(&self) -> usize {
+        (self.range.end - self.range.start) as usize
+    }
+
+    pub fn remaining(&self) -> usize {
+        self.size() - self.position as usize
+    }
+}
+
+impl<R: Read + Seek> Read for RangeReader<R> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let max_read = buf.len().min(self.remaining());
+        let limited_buf = &mut buf[..max_read];
+
+        if !self.ready {
+            self.reader
+                .seek(SeekFrom::Start(self.range.start + self.position))?;
+            self.ready = true;
+        }
+
+        let bytes_read = self.reader.read(limited_buf)?;
+        self.position += bytes_read.min(max_read) as u64;
+
+        Ok(bytes_read)
+    }
+}
+
+impl<R: Read + Seek> Seek for RangeReader<R> {
+    fn seek(&mut self, pos: SeekFrom) -> std::io::Result<u64> {
+        self.position = match pos {
+            SeekFrom::Start(position) => position.min(self.size() as u64),
+            SeekFrom::End(offset) => {
+                if offset > self.size() as i64 {
+                    return Err(std::io::Error::new(
+                        std::io::ErrorKind::InvalidInput,
+                        "Tried to seek before the beginning of the file",
+                    ));
+                }
+
+                (if offset <= 0 {
+                    self.size()
+                } else {
+                    self.size() - offset as usize
+                }) as u64
+            }
+            SeekFrom::Current(offset) => {
+                if let Some(position) = self.position.checked_add_signed(offset) {
+                    position.min(self.size() as u64)
+                } else {
+                    return Err(std::io::Error::new(
+                        std::io::ErrorKind::InvalidInput,
+                        "Tried to seek before the beginning of the file",
+                    ));
+                }
+            }
+        };
+
+        self.reader
+            .seek(SeekFrom::Start(self.range.start + self.position))?;
+        self.ready = true;
+
+        Ok(self.position)
+    }
+}
-- 
2.47.2