Crate magic_rs 

magic-rs: A Safe Rust Reimplementation of libmagic

This crate provides a high-performance, memory-safe alternative to the traditional libmagic (used by the file command). It supports file type detection, MIME type inference, and custom magic rule parsing.

Installation

Add magic-rs to your Cargo.toml:

[dependencies]
magic-rs = "0.1"  # Replace with the latest version

Or add the latest version with cargo:

cargo add magic-rs

Quick Start

Detect File Types Programmatically

use magic_rs::{MagicDb, MagicSource};
use std::fs::File;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = MagicDb::new();
    // Create a MagicSource from a file
    let rust_magic = MagicSource::open("../magic-db/src/magdir/rust")?;
    db.load(rust_magic)?;

    // Open a file and detect its type
    let mut file = File::open("src/lib.rs")?;
    let magic = db.magic_first(&mut file, None)?;

    println!(
        "File type: {} (MIME: {}, strength: {})",
        magic.message(),
        magic.mime_type(),
        magic.strength()
    );
    Ok(())
}

Get All Matching Rules

use magic_rs::{MagicDb, MagicSource};
use std::fs::File;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = MagicDb::new();
    // Create a MagicSource from a file
    let rust_magic = MagicSource::open("../magic-db/src/magdir/rust")?;
    db.load(rust_magic)?;

    // Open a file and detect its type
    let mut file = File::open("src/lib.rs")?;

    // Get all matching rules, sorted by strength
    let magics = db.magic_all(&mut file)?;

    // Must contain rust file magic and default text magic
    assert!(magics.len() > 1);

    for magic in magics {
        println!(
            "Match: {} (strength: {}, source: {})",
            magic.message(),
            magic.strength(),
            magic.source().unwrap_or("unknown")
        );
    }
    Ok(())
}

Serialize a Database to Disk

use magic_rs::{MagicDb, MagicSource};
use std::fs::File;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = MagicDb::new();
    // Create a MagicSource from a file
    let rust_magic = MagicSource::open("../magic-db/src/magdir/rust")?;
    db.load(rust_magic)?;

    // Serialize the database to a file
    let mut output = File::create("/tmp/compiled.db")?;
    db.serialize(&mut output)?;

    println!("Database saved to file");
    Ok(())
}

Deserialize a Database

use magic_rs::{MagicDb, MagicSource};
use std::fs::File;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = MagicDb::new();
    // Create a MagicSource from a file
    let rust_magic = MagicSource::open("../magic-db/src/magdir/rust")?;
    db.load(rust_magic)?;

    // Serialize the database in a vector
    let mut ser = vec![];
    db.serialize(&mut ser)?;
    println!("Database saved to vector");

    // We deserialize from slice
    let db = MagicDb::deserialize(&mut ser.as_slice())?;

    assert!(!db.rules().is_empty());

    Ok(())
}

License

This project is licensed under the GPL-3.0 License.

Contributing

Contributions are welcome! Open an issue or submit a pull request.

Acknowledgments

• Inspired by the original libmagic (part of the file command).

Structs

Magic

Represents a file magic detection result

MagicDb

Represents a database of MagicRule

MagicRule

Represents a parsed magic rule

MagicSource

A parsed source of magic rules

Enums

Error

Represents all possible errors that can occur during file type detection and processing.

Constants

DEFAULT_BIN_MIMETYPE

DEFAULT_TEXT_MIMETYPE

FILE_BYTES_MAX