[PATCH proxmox-backup 2/2] pbs-tape: rename `buffer` to `header`

["Max R. Carrara" <m.carrara@proxmox.com>]

... since `BlockHeader` is now a smart pointer.

Signed-off-by: Max R. Carrara <m.carrara@proxmox.com>
---
 pbs-tape/src/blocked_reader.rs | 46 +++++++++++++++++-----------------
 pbs-tape/src/blocked_writer.rs | 36 +++++++++++++-------------
 2 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/pbs-tape/src/blocked_reader.rs b/pbs-tape/src/blocked_reader.rs
index 33c5db780..9ad16c91f 100644
--- a/pbs-tape/src/blocked_reader.rs
+++ b/pbs-tape/src/blocked_reader.rs
@@ -18,7 +18,7 @@ use crate::{
 /// the end of the stream).
 pub struct BlockedReader<R> {
     reader: R,
-    buffer: BlockHeader,
+    header: BlockHeader,
     seq_nr: u32,
     found_end_marker: bool,
     incomplete: bool,
@@ -33,24 +33,24 @@ impl<R: BlockRead> BlockedReader<R> {
     /// This tries to read the first block. Please inspect the error
     /// to detect EOF and EOT.
     pub fn open(mut reader: R) -> Result<Self, BlockReadError> {
-        let mut buffer = BlockHeader::new()?;
+        let mut header = BlockHeader::new()?;
 
-        Self::read_block_frame(&mut buffer, &mut reader)?;
+        Self::read_block_frame(&mut header, &mut reader)?;
 
-        let (_size, found_end_marker) = Self::check_buffer(&buffer, 0)?;
+        let (_size, found_end_marker) = Self::check_buffer(&header, 0)?;
 
         let mut incomplete = false;
         let mut got_eod = false;
 
         if found_end_marker {
-            incomplete = buffer.flags().contains(BlockHeaderFlags::INCOMPLETE);
+            incomplete = header.flags().contains(BlockHeaderFlags::INCOMPLETE);
             Self::consume_eof_marker(&mut reader)?;
             got_eod = true;
         }
 
         Ok(Self {
             reader,
-            buffer,
+            header,
             found_end_marker,
             incomplete,
             got_eod,
@@ -60,29 +60,29 @@ impl<R: BlockRead> BlockedReader<R> {
         })
     }
 
-    fn check_buffer(buffer: &BlockHeader, seq_nr: u32) -> Result<(usize, bool), std::io::Error> {
-        if buffer.magic() != PROXMOX_TAPE_BLOCK_HEADER_MAGIC_1_0 {
+    fn check_buffer(header: &BlockHeader, seq_nr: u32) -> Result<(usize, bool), std::io::Error> {
+        if header.magic() != PROXMOX_TAPE_BLOCK_HEADER_MAGIC_1_0 {
             proxmox_lang::io_bail!(
                 "got tape block with unknown magic number - not written by PBS or incompatible LTO version"
             );
         }
 
-        if seq_nr != buffer.seq_nr() {
+        if seq_nr != header.seq_nr() {
             proxmox_lang::io_bail!(
                 "detected tape block with wrong sequence number ({} != {})",
                 seq_nr,
-                buffer.seq_nr()
+                header.seq_nr()
             )
         }
 
-        let size = buffer.size();
-        let found_end_marker = buffer.flags().contains(BlockHeaderFlags::END_OF_STREAM);
+        let size = header.size();
+        let found_end_marker = header.flags().contains(BlockHeaderFlags::END_OF_STREAM);
 
-        if size > buffer.payload().len() {
+        if size > header.payload().len() {
             proxmox_lang::io_bail!(
                 "detected tape block with wrong payload size ({} > {}",
                 size,
-                buffer.payload().len()
+                header.payload().len()
             );
         } else if size == 0 && !found_end_marker {
             proxmox_lang::io_bail!("detected tape block with zero payload size");
@@ -91,8 +91,8 @@ impl<R: BlockRead> BlockedReader<R> {
         Ok((size, found_end_marker))
     }
 
-    fn read_block_frame(buffer: &mut BlockHeader, reader: &mut R) -> Result<(), BlockReadError> {
-        let bytes = reader.read_block(buffer.as_bytes_mut())?;
+    fn read_block_frame(header: &mut BlockHeader, reader: &mut R) -> Result<(), BlockReadError> {
+        let bytes = reader.read_block(header.as_bytes_mut())?;
 
         if bytes != BlockHeader::SIZE {
             return Err(proxmox_lang::io_format_err!("got wrong block size").into());
@@ -116,11 +116,11 @@ impl<R: BlockRead> BlockedReader<R> {
     }
 
     fn read_block(&mut self, check_end_marker: bool) -> Result<usize, std::io::Error> {
-        match Self::read_block_frame(&mut self.buffer, &mut self.reader) {
+        match Self::read_block_frame(&mut self.header, &mut self.reader) {
             Ok(()) => { /* ok */ }
             Err(BlockReadError::EndOfFile) => {
                 self.got_eod = true;
-                self.read_pos = self.buffer.payload().len();
+                self.read_pos = self.header.payload().len();
                 if !self.found_end_marker && check_end_marker {
                     proxmox_lang::io_bail!("detected tape stream without end marker");
                 }
@@ -134,13 +134,13 @@ impl<R: BlockRead> BlockedReader<R> {
             }
         }
 
-        let (size, found_end_marker) = Self::check_buffer(&self.buffer, self.seq_nr)?;
+        let (size, found_end_marker) = Self::check_buffer(&self.header, self.seq_nr)?;
         self.seq_nr += 1;
 
         if found_end_marker {
             // consume EOF mark
             self.found_end_marker = true;
-            self.incomplete = self.buffer.flags().contains(BlockHeaderFlags::INCOMPLETE);
+            self.incomplete = self.header.flags().contains(BlockHeaderFlags::INCOMPLETE);
             Self::consume_eof_marker(&mut self.reader)?;
             self.got_eod = true;
         }
@@ -175,7 +175,7 @@ impl<R: BlockRead> TapeRead for BlockedReader<R> {
     // stream has no end marker.
     fn skip_data(&mut self) -> Result<usize, std::io::Error> {
         let mut bytes = 0;
-        let buffer_size = self.buffer.size();
+        let buffer_size = self.header.size();
         let rest = (buffer_size as isize) - (self.read_pos as isize);
         if rest > 0 {
             bytes = rest as usize;
@@ -195,7 +195,7 @@ impl<R: BlockRead> Read for BlockedReader<R> {
             proxmox_lang::io_bail!("detected read after error - internal error");
         }
 
-        let mut buffer_size = self.buffer.size();
+        let mut buffer_size = self.header.size();
         let mut rest = (buffer_size as isize) - (self.read_pos as isize);
 
         if rest <= 0 && !self.got_eod {
@@ -220,7 +220,7 @@ impl<R: BlockRead> Read for BlockedReader<R> {
             };
 
             let (read_start, read_end) = (self.read_pos, self.read_pos + copy_len);
-            let payload = self.buffer.payload();
+            let payload = self.header.payload();
             buffer[..copy_len].copy_from_slice(&payload[read_start..read_end]);
 
             self.read_pos += copy_len;
diff --git a/pbs-tape/src/blocked_writer.rs b/pbs-tape/src/blocked_writer.rs
index 57721ed4a..6ca621716 100644
--- a/pbs-tape/src/blocked_writer.rs
+++ b/pbs-tape/src/blocked_writer.rs
@@ -9,7 +9,7 @@ use crate::{BlockHeader, BlockHeaderFlags, BlockWrite, TapeWrite};
 /// to the underlying writer.
 pub struct BlockedWriter<W: BlockWrite> {
     writer: W,
-    buffer: BlockHeader,
+    header: BlockHeader,
     buffer_pos: usize,
     seq_nr: u32,
     logical_end_of_media: bool,
@@ -36,7 +36,7 @@ impl<W: BlockWrite> BlockedWriter<W> {
     pub fn new(writer: W) -> Self {
         Self {
             writer,
-            buffer: BlockHeader::new().expect("failed to create block header"),
+            header: BlockHeader::new().expect("failed to create block header"),
             buffer_pos: 0,
             seq_nr: 0,
             logical_end_of_media: false,
@@ -45,8 +45,8 @@ impl<W: BlockWrite> BlockedWriter<W> {
         }
     }
 
-    fn write_block(buffer: &BlockHeader, writer: &mut W) -> Result<bool, std::io::Error> {
-        writer.write_block(buffer.as_bytes())
+    fn write_block(header: &BlockHeader, writer: &mut W) -> Result<bool, std::io::Error> {
+        writer.write_block(header.as_bytes())
     }
 
     fn write_eof(&mut self) -> Result<(), std::io::Error> {
@@ -63,23 +63,23 @@ impl<W: BlockWrite> BlockedWriter<W> {
             return Ok(0);
         }
 
-        let rest = self.buffer.payload().len() - self.buffer_pos;
+        let rest = self.header.payload().len() - self.buffer_pos;
         let bytes = if data.len() < rest { data.len() } else { rest };
 
         let (write_start, write_end) = (self.buffer_pos, self.buffer_pos + bytes);
 
-        let payload = self.buffer.payload_mut();
+        let payload = self.header.payload_mut();
         payload[write_start..write_end].copy_from_slice(&data[..bytes]);
 
         let rest = rest - bytes;
 
         if rest == 0 {
-            self.buffer.set_flags(BlockHeaderFlags::empty());
-            let payload_len = self.buffer.payload().len();
-            self.buffer.set_size(payload_len);
-            self.buffer.set_seq_nr(self.seq_nr);
+            self.header.set_flags(BlockHeaderFlags::empty());
+            let payload_len = self.header.payload().len();
+            self.header.set_size(payload_len);
+            self.header.set_seq_nr(self.seq_nr);
             self.seq_nr += 1;
-            let leom = Self::write_block(&self.buffer, &mut self.writer)?;
+            let leom = Self::write_block(&self.header, &mut self.writer)?;
             if leom {
                 self.logical_end_of_media = true;
             }
@@ -113,19 +113,19 @@ impl<W: BlockWrite> TapeWrite for BlockedWriter<W> {
     /// Note: This may write an empty block just including the
     /// END_OF_STREAM flag.
     fn finish(&mut self, incomplete: bool) -> Result<bool, std::io::Error> {
-        let payload = self.buffer.payload_mut();
+        let payload = self.header.payload_mut();
         vec::clear(&mut payload[self.buffer_pos..]);
 
-        self.buffer.set_flags(BlockHeaderFlags::END_OF_STREAM);
+        self.header.set_flags(BlockHeaderFlags::END_OF_STREAM);
         if incomplete {
-            let flags = self.buffer.flags() | BlockHeaderFlags::INCOMPLETE;
-            self.buffer.set_flags(flags);
+            let flags = self.header.flags() | BlockHeaderFlags::INCOMPLETE;
+            self.header.set_flags(flags);
         }
-        self.buffer.set_size(self.buffer_pos);
-        self.buffer.set_seq_nr(self.seq_nr);
+        self.header.set_size(self.buffer_pos);
+        self.header.set_seq_nr(self.seq_nr);
         self.seq_nr += 1;
         self.bytes_written += BlockHeader::SIZE;
-        let leom = Self::write_block(&self.buffer, &mut self.writer)?;
+        let leom = Self::write_block(&self.header, &mut self.writer)?;
         self.write_eof()?;
         Ok(leom)
     }
-- 
2.47.3