basic_tar

Welcome to basic_tar 🎉

About

This crate provides some functionality to read and write basic/classic oldstyle tar archives and some extensions for io::Read and io::Write to make it easier to work with tar streams.

Note: It is not intended as an high-level allround (un-)packer but as a building block of you want to use the tar format for your own applications – for a high-level solution, take a look at tar

How to read a stream

To read a tar record from an archive stream, you need to read 1. the header for the next record 2. the payload 3. the padding bytes which pad the payload to a multiple of the block size (512 byte)

Example:

```rust use std::{ convert::TryFrom, error::Error, io::Read }; use basictar::{ ReadExt, U64Ext, Header, raw::{ self, BLOCKLEN } };

/// Reads the next record from stream fn readnext(mut stream: impl Read) -> Result<(Header, Vec), Box> { // Read the header let mut headerraw = raw::header::raw(); stream.readexact(&mut headerraw)?;

// Parse the header and get the payload lengths
let header = Header::parse(header_raw)?;
let payload_len = header.size;
let payload_total_len = payload_len.ceil_to_multiple_of(BLOCK_LEN as u64);

// Read the payload
let mut payload = vec![0; usize::try_from(payload_len)?];
stream.read_exact(&mut payload)?;

// Drain the padding and return the record
let padding_len = usize::try_from(payload_total_len - payload_len)?;
stream.try_drain(padding_len, |_| {})?;
Ok((header, payload))

} ```

How to write a stream

To write a tar record to an archive stream, you need to write 1. your header 2. your payload 3. the padding bytes to pad your payload to a multiple of the block size (512 byte)

Example:

```rust use std::{ convert::TryFrom, error::Error, io::Write }; use basictar::{ WriteExt, U64Ext, Header, raw::BLOCKLEN };

/// Writes header and payload to stream fn writenext(header: Header, payload: &[u8], mut stream: impl Write) -> Result<(), Box> { // Serialize the header and write it and the payload let headerraw = header.serialize()?; stream.writeall(&headerraw)?; stream.write_all(payload)?;

// Write the padding
let payload_len = payload.len() as u64;
let padding_len = payload_len.ceil_to_multiple_of(BLOCK_LEN as u64) - payload_len;
stream.try_fill(usize::try_from(padding_len)?, |_| {})?;

Ok(())

} ```