qcow: replace byteorder with {to,from}_be_bytes()

Use the standard byte order conversion functions rather than the
byteorder crate.

BUG=None
TEST=./build_test
TEST=cargo build -p qcow_utils
TEST=cargo test -p qcow

Change-Id: I9ff7368cc54c539db1996f81d4220cabf7e6e301
Signed-off-by: Daniel Verkamp <dverkamp@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/1761151
Reviewed-by: Zach Reizner <zachr@chromium.org>
Tested-by: kokoro <noreply+kokoro@google.com>

4 files changed, 47 insertions, 30 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 60befe6..0a4f1aa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -394,7 +394,6 @@ dependencies = [
 name = "qcow"
 version = "0.1.0"
 dependencies = [
- "byteorder 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "data_model 0.1.0",
  "libc 0.2.44 (registry+https://github.com/rust-lang/crates.io-index)",
  "remain 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
diff --git a/qcow/Cargo.toml b/qcow/Cargo.toml
index 0c521fd..5b9d8ab 100644
--- a/qcow/Cargo.toml
+++ b/qcow/Cargo.toml
@@ -8,7 +8,6 @@ edition = "2018"
 path = "src/qcow.rs"
 
 [dependencies]
-byteorder = "*"
 libc = "*"
 remain = "*"
 sys_util = { path = "../sys_util" }
diff --git a/qcow/src/qcow.rs b/qcow/src/qcow.rs
index 73d750f..57e42fc 100644
--- a/qcow/src/qcow.rs
+++ b/qcow/src/qcow.rs
@@ -6,7 +6,6 @@ mod qcow_raw_file;
 mod refcount;
 mod vec_cache;
 
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use data_model::{VolatileMemory, VolatileSlice};
 use libc::{EINVAL, ENOSPC, ENOTSUP};
 use remain::sorted;
@@ -184,25 +183,43 @@ pub struct QcowHeader {
     pub header_size: u32,
 }
 
+// Reads the next u16 from the file.
+fn read_u16_from_file(mut f: &File) -> Result<u16> {
+    let mut value = [0u8; 2];
+    (&mut f)
+        .read_exact(&mut value)
+        .map_err(Error::ReadingHeader)?;
+    Ok(u16::from_be_bytes(value))
+}
+
+// Reads the next u32 from the file.
+fn read_u32_from_file(mut f: &File) -> Result<u32> {
+    let mut value = [0u8; 4];
+    (&mut f)
+        .read_exact(&mut value)
+        .map_err(Error::ReadingHeader)?;
+    Ok(u32::from_be_bytes(value))
+}
+
+// Reads the next u64 from the file.
+fn read_u64_from_file(mut f: &File) -> Result<u64> {
+    let mut value = [0u8; 8];
+    (&mut f)
+        .read_exact(&mut value)
+        .map_err(Error::ReadingHeader)?;
+    Ok(u64::from_be_bytes(value))
+}
+
 impl QcowHeader {
     /// Creates a QcowHeader from a reference to a file.
     pub fn new(f: &mut File) -> Result<QcowHeader> {
         f.seek(SeekFrom::Start(0)).map_err(Error::ReadingHeader)?;
-        let magic = f.read_u32::<BigEndian>().map_err(Error::ReadingHeader)?;
+
+        let magic = read_u32_from_file(f)?;
         if magic != QCOW_MAGIC {
             return Err(Error::InvalidMagic);
         }
 
-        // Reads the next u32 from the file.
-        fn read_u32_from_file(f: &mut File) -> Result<u32> {
-            f.read_u32::<BigEndian>().map_err(Error::ReadingHeader)
-        }
-
-        // Reads the next u64 from the file.
-        fn read_u64_from_file(f: &mut File) -> Result<u64> {
-            f.read_u64::<BigEndian>().map_err(Error::ReadingHeader)
-        }
-
         Ok(QcowHeader {
             magic,
             version: read_u32_from_file(f)?,
@@ -276,13 +293,13 @@ impl QcowHeader {
     pub fn write_to<F: Write + Seek>(&self, file: &mut F) -> Result<()> {
         // Writes the next u32 to the file.
         fn write_u32_to_file<F: Write>(f: &mut F, value: u32) -> Result<()> {
-            f.write_u32::<BigEndian>(value)
+            f.write_all(&value.to_be_bytes())
                 .map_err(Error::WritingHeader)
         }
 
         // Writes the next u64 to the file.
         fn write_u64_to_file<F: Write>(f: &mut F, value: u64) -> Result<()> {
-            f.write_u64::<BigEndian>(value)
+            f.write_all(&value.to_be_bytes())
                 .map_err(Error::WritingHeader)
         }
 
@@ -419,12 +436,11 @@ impl QcowFile {
         let mut refcount_rebuild_required = true;
         file.seek(SeekFrom::Start(header.refcount_table_offset))
             .map_err(Error::SeekingFile)?;
-        let first_refblock_addr = file.read_u64::<BigEndian>().map_err(Error::ReadingHeader)?;
+        let first_refblock_addr = read_u64_from_file(&file)?;
         if first_refblock_addr != 0 {
             file.seek(SeekFrom::Start(first_refblock_addr))
                 .map_err(Error::SeekingFile)?;
-            let first_cluster_refcount =
-                file.read_u16::<BigEndian>().map_err(Error::ReadingHeader)?;
+            let first_cluster_refcount = read_u16_from_file(&file)?;
             if first_cluster_refcount != 0 {
                 refcount_rebuild_required = false;
             }
@@ -1695,7 +1711,7 @@ pub fn detect_image_type(file: &File) -> Result<ImageType> {
     let mut f = file;
     let orig_seek = f.seek(SeekFrom::Current(0)).map_err(Error::SeekingFile)?;
     f.seek(SeekFrom::Start(0)).map_err(Error::SeekingFile)?;
-    let magic = f.read_u32::<BigEndian>().map_err(Error::ReadingHeader)?;
+    let magic = read_u32_from_file(f)?;
     let image_type = if magic == QCOW_MAGIC {
         ImageType::Qcow2
     } else {
diff --git a/qcow/src/qcow_raw_file.rs b/qcow/src/qcow_raw_file.rs
index a900081..99a8d71 100644
--- a/qcow/src/qcow_raw_file.rs
+++ b/qcow/src/qcow_raw_file.rs
@@ -3,10 +3,9 @@
 // found in the LICENSE file.
 
 use std::fs::File;
-use std::io::{self, BufWriter, Seek, SeekFrom};
+use std::io::{self, BufWriter, Read, Seek, SeekFrom, Write};
 use std::mem::size_of;
 
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use sys_util::WriteZeroes;
 
 /// A qcow file. Allows reading/writing clusters and appending clusters.
@@ -41,11 +40,11 @@ impl QcowRawFile {
     ) -> io::Result<Vec<u64>> {
         let mut table = vec![0; count as usize];
         self.file.seek(SeekFrom::Start(offset))?;
-        self.file.read_u64_into::<BigEndian>(&mut table)?;
-        if let Some(m) = mask {
-            for ptr in &mut table {
-                *ptr &= m;
-            }
+        let mask = mask.unwrap_or(u64::max_value());
+        for ptr in &mut table {
+            let mut value = [0u8; 8];
+            self.file.read_exact(&mut value)?;
+            *ptr = u64::from_be_bytes(value) & mask;
         }
         Ok(table)
     }
@@ -74,7 +73,7 @@ impl QcowRawFile {
             } else {
                 *addr | non_zero_flags
             };
-            buffer.write_u64::<BigEndian>(val)?;
+            buffer.write_all(&val.to_be_bytes())?;
         }
         Ok(())
     }
@@ -85,7 +84,11 @@ impl QcowRawFile {
         let count = self.cluster_size / size_of::<u16>() as u64;
         let mut table = vec![0; count as usize];
         self.file.seek(SeekFrom::Start(offset))?;
-        self.file.read_u16_into::<BigEndian>(&mut table)?;
+        for refcount in &mut table {
+            let mut value = [0u8; 2];
+            self.file.read_exact(&mut value)?;
+            *refcount = u16::from_be_bytes(value);
+        }
         Ok(table)
     }
 
@@ -94,7 +97,7 @@ impl QcowRawFile {
         self.file.seek(SeekFrom::Start(offset))?;
         let mut buffer = BufWriter::with_capacity(table.len() * size_of::<u16>(), &self.file);
         for count in table {
-            buffer.write_u16::<BigEndian>(*count)?;
+            buffer.write_all(&count.to_be_bytes())?;
         }
         Ok(())
     }