Crate delharc 

A library for parsing and extracting content of LHA/LZH archives.

This library is for easy parsing of LHA headers and allows to read files compressed with some of the methods used by the archive format.

This library does not provide high level methods for creating files or directories from the extracted archives.

There are many extensions to the base LHA headers, used by many different archive programs, in many different operating systems. This library only allows for parsing some properties of the archived files, such as file path names, last modification timestamps, UNIX/OS-9 permission flags and file owner IDs.

The LhaHeader exposes properties and methods to inspect the raw content of header extensions, as well as extended header data and may be explored by the user program in case extra archive properties are needed to be read.

LHA header levels: 0, 1, 2 and 3 are recognized.

Compression methods

You may include or opt out of some of the compression decoders:

[dependencies.delharc]
version = "0.8"
default-features = false
features = ["std", "lh1"] # select desired features

std, lh1, lz and pm features are enabled by default.

When using default-features = false the std feature needs to be added back along with other compression method features. Otherwise the library will be compiled in the no_std mode.

identifier	decoder	feature	description
-lh0-	PassthroughDecoder		no compression
-lh1-	Lh1Decoder	lh1	LHarc version 1, 4kB sliding window, dynamic huffman
-lh4-	Lh5Decoder		LHarc version 2, 4kB sliding window, static huffman
-lh5-	Lh5Decoder		LHarc version 2, 8kB sliding window, static huffman
-lh6-	Lh7Decoder		LHarc version 2, 32kB sliding window, static huffman
-lh7-	Lh7Decoder		LHarc version 2, 64kB sliding window, static huffman
-lhd-	unsupported		an empty directory, data should be empty and should be skipped
-lhx-	LhxDecoder	lhx	UNLHA32.DLL method, 128-512kb sliding window, static huffman
-lz4-	PassthroughDecoder		no compression
-lzs-	LzsDecoder	lz	LArc, 2kb sliding window
-lz5-	Lz5Decoder	lz	LArc, 4kb sliding window
-pm0-	PassthroughDecoder		no compression
-pm1-	Pm1Decoder	pm	PMarc, 16 Kb sliding window, built-in huffman, history list
-pm2-	Pm2Decoder	pm	PMarc, 8 Kb sliding window, static huffman, history list

Example

use std::{io, path::Path};

fn extract_to_stdout<P: AsRef<Path>>(
        archive_name: P,
        matching_path: P
    ) -> io::Result<bool>
{
    let mut lha_reader = delharc::parse_file(archive_name.as_ref())?;
    loop {
        let header = lha_reader.header();
        let filename = header.parse_pathname();

        eprintln!("Path: {:?} modified: {} ", filename, header.parse_last_modified());

        if filename.ends_with(matching_path.as_ref()) {
            if lha_reader.is_decoder_supported() {
                let stdout = io::stdout();
                let mut handle = stdout.lock();
                io::copy(&mut lha_reader, &mut handle)?;
                lha_reader.crc_check()?;
                return Ok(true)
            }
            else if header.is_directory() {
                eprintln!("skipping: an empty directory");
            }
            else {
                eprintln!("skipping: has unsupported compression method");
            }
        }

        if !lha_reader.seek_next_file()? {
            break;
        }
    }

    Ok(false)
}

No std

With std feature enabled, error::LhaError converts to std::io::Error via the From trait and stub_io::Read is implemented for all types that implement std::io::Read.

In this instance to read decompressed files, callers should access the LhaDecodeReader using std::io::Read trait methods.

Without the std feature enabled the std library is not available, but delharc still requires the alloc crate. Because the whole std::io is missing, callers should interface the LhaDecodeReader using stub_io::Read methods instead. stub_io::Read is implemented initially for &[u8] slices and Box<R: Read> and can be implemented for other types.

When compiled without std: stub_io::Read, stub_io::Take and UnexpectedEofError are re-exported directly under the crate root. UnexpectedEofError is only available in no_std mode.

use delharc::{LhaDecodeReader, LhaError, LhaResult, Read, UnexpectedEofError};
const DATA: &[u8] = include_bytes!("file.lzh");
//...
let lha_reader = LhaDecodeReader::new(DATA).unwrap();

Extending delharc

The extend feature exposes library implementation details, allowing users to access directly bitstreams, ring buffers or a huffman tree implementation, with the caveat that they may be changed more often in the future releases of delharc.

For example, LhaV2Decoder is a generic LHArc version 2 decoder, which allows creating decoders with custom sliding window sizes, using the LhaDecoderConfig trait for configuration.

The extend feature is not enabled by default.

Re-exports

pub use decode::LhaDecodeReader;

pub use header::CompressionMethod;

pub use header::LhaHeader;

pub use header::MsDosAttrs;

pub use header::Os9Attrs;

pub use header::OsType;

pub use header::Permissions;

pub use header::TimestampResult;

pub use error::LhaError;

pub use error::LhaResult;

Modules

bitstreamextend

Bit-stream tools.

crc

An implementation of CRC-16.

decode

Decoding algorithms.

error

Error objects used by delharc.

header

LHA header and related types.

ringbufextend

Ring buffer tools.

statictreeextend

Static Huffman Coding.

stub_io

Proxy I/O tools.

Functions

parse_filestd

Attempt to open a file from a filesystem in read-only mode and on success return an instance of LhaDecodeReader with the first parsed LHA file header, ready to decode the content of the first archived file.