[pbs-devel] [PATCH v2 proxmox-backup 13/20] add tools/cpio encoding module
Stefan Reiter
s.reiter at proxmox.com
Wed Mar 24 16:18:20 CET 2021
Signed-off-by: Stefan Reiter <s.reiter at proxmox.com>
---
src/tools.rs | 1 +
src/tools/cpio.rs | 73 +++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 74 insertions(+)
create mode 100644 src/tools/cpio.rs
diff --git a/src/tools.rs b/src/tools.rs
index 7e3bff7b..43fd070e 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -22,6 +22,7 @@ pub mod apt;
pub mod async_io;
pub mod borrow;
pub mod cert;
+pub mod cpio;
pub mod daemon;
pub mod disks;
pub mod format;
diff --git a/src/tools/cpio.rs b/src/tools/cpio.rs
new file mode 100644
index 00000000..8800e3ad
--- /dev/null
+++ b/src/tools/cpio.rs
@@ -0,0 +1,73 @@
+//! Provides a very basic "newc" format cpio encoder.
+//! See 'man 5 cpio' for format details, as well as:
+//! https://www.kernel.org/doc/html/latest/driver-api/early-userspace/buffer-format.html
+//! This does not provide full support for the format, only what is needed to include files in an
+//! initramfs intended for a linux kernel.
+use anyhow::{bail, Error};
+use std::ffi::{CString, CStr};
+use tokio::io::{copy, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
+
+/// Write a cpio file entry to an AsyncWrite.
+pub async fn append_file<W: AsyncWrite + Unpin, R: AsyncRead + Unpin>(
+ mut target: W,
+ content: R,
+ name: &CStr,
+ inode: u16,
+ mode: u16,
+ uid: u16,
+ gid: u16,
+ // negative mtimes are generally valid, but cpio defines all fields as unsigned
+ mtime: u64,
+ // c_filesize has 8 bytes, but man page claims that 4 GB files are the maximum, let's be safe
+ size: u32,
+) -> Result<(), Error> {
+ let name = name.to_bytes_with_nul();
+
+ target.write_all(b"070701").await?; // c_magic
+ print_cpio_hex(&mut target, inode as u64).await?; // c_ino
+ print_cpio_hex(&mut target, mode as u64).await?; // c_mode
+ print_cpio_hex(&mut target, uid as u64).await?; // c_uid
+ print_cpio_hex(&mut target, gid as u64).await?; // c_gid
+ print_cpio_hex(&mut target, 0).await?; // c_nlink
+ print_cpio_hex(&mut target, mtime as u64).await?; // c_mtime
+ print_cpio_hex(&mut target, size as u64).await?; // c_filesize
+ print_cpio_hex(&mut target, 0).await?; // c_devmajor
+ print_cpio_hex(&mut target, 0).await?; // c_devminor
+ print_cpio_hex(&mut target, 0).await?; // c_rdevmajor
+ print_cpio_hex(&mut target, 0).await?; // c_rdevminor
+ print_cpio_hex(&mut target, name.len() as u64).await?; // c_namesize
+ print_cpio_hex(&mut target, 0).await?; // c_check (ignored for newc)
+
+ target.write_all(name).await?;
+ let header_size = 6 + 8*13 + name.len();
+ let mut name_pad = header_size;
+ while name_pad & 3 != 0 {
+ target.write_u8(0).await?;
+ name_pad += 1;
+ }
+
+ let mut content = content.take(size as u64);
+ let copied = copy(&mut content, &mut target).await?;
+ if copied < size as u64 {
+ bail!("cpio: not enough data, or size to big - encoding invalid");
+ }
+ let mut data_pad = copied;
+ while data_pad & 3 != 0 {
+ target.write_u8(0).await?;
+ data_pad += 1;
+ }
+
+ Ok(())
+}
+
+/// Write the TRAILER!!! file to an AsyncWrite, signifying the end of a cpio archive. Note that you
+/// can immediately add more files after, to create a concatenated archive, the kernel for example
+/// will merge these upon loading an initramfs.
+pub async fn append_trailer<W: AsyncWrite + Unpin>(target: W) -> Result<(), Error> {
+ let name = CString::new("TRAILER!!!").unwrap();
+ append_file(target, tokio::io::empty(), &name, 0, 0, 0, 0, 0, 0).await
+}
+
+async fn print_cpio_hex<W: AsyncWrite + Unpin>(target: &mut W, value: u64) -> Result<(), Error> {
+ target.write_all(format!("{:08x}", value).as_bytes()).await.map_err(|e| e.into())
+}
--
2.20.1
More information about the pbs-devel
mailing list