Enum EvaluationError 

#[non_exhaustive]
pub enum EvaluationError {
    BufferOverrun {
        offset: usize,
    },
    InvalidOffset {
        offset: i64,
    },
    UnsupportedType {
        type_name: String,
    },
    RecursionLimitExceeded {
        depth: u32,
    },
    StringLengthExceeded {
        length: usize,
        max_length: usize,
    },
    InvalidStringEncoding {
        offset: usize,
    },
    Timeout {
        timeout_ms: u64,
    },
    TypeReadError(TypeReadError),
    InvalidValueTransform {
        reason: String,
    },
    UnknownName {
        name: String,
    },
    InternalError {
        message: String,
    },
    IndirectWithoutEnvironment,
}

Errors that can occur during rule evaluation.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

BufferOverrun

Buffer overrun during file reading.

Fields

offset: usize

The offset where the buffer overrun occurred

InvalidOffset

Invalid offset calculation.

Fields

offset: i64

The invalid offset value

UnsupportedType

Unsupported type during evaluation.

Fields

type_name: String

The name of the unsupported type

RecursionLimitExceeded

Recursion limit exceeded during evaluation.

Fields

depth: u32

The recursion depth that was exceeded

StringLengthExceeded

String length limit exceeded.

Fields

length: usize

The actual string length

max_length: usize

The maximum allowed length

InvalidStringEncoding

Invalid string encoding.

Fields

offset: usize

The offset where the invalid encoding was found

Timeout

Evaluation timeout exceeded.

Fields

timeout_ms: u64

The timeout duration in milliseconds

TypeReadError(TypeReadError)

Type reading error during evaluation.

InvalidValueTransform

A pre-comparison ValueTransform (type+N, type/N, etc.) failed to apply: division/modulo by zero, integer overflow, or any other arithmetic failure produced by apply_value_transform. This is a recoverable per-rule failure (the engine’s graceful-skip path drops the rule and continues), not a programming bug – a magic-file author who writes lequad*1000000 against a buffer where the read value overflows triggers this and the rest of the rule set still runs.

Examples

use libmagic_rs::error::EvaluationError;

let error = EvaluationError::InvalidValueTransform {
    reason: "Mul(2) overflow on 18446744073709551615".to_string(),
};
assert!(matches!(error, EvaluationError::InvalidValueTransform { .. }));

Fields

reason: String

Free-form description of the operation, operand, and value that triggered the failure.

UnknownName

A use directive referenced a name not present in the name table.

The evaluator currently handles this condition with a warn! log plus Ok(vec![]) for backward compatibility with magic files that invoke subroutines defined in another magic file. This variant is reserved for consumers that opt in to strict-mode evaluation where an unknown-name reference should abort the run.

Examples

use libmagic_rs::error::EvaluationError;

let error = EvaluationError::UnknownName {
    name: "missing_sub".to_string(),
};
assert!(matches!(error, EvaluationError::UnknownName { .. }));

Fields

name: String

The name that could not be resolved in the name table.

InternalError

Internal error indicating a bug in the evaluation logic.

Fields

message: String

Description of the internal error

IndirectWithoutEnvironment

An indirect directive was evaluated without a rule environment attached to the crate::evaluator::EvaluationContext.

MetaType::Indirect re-evaluates the entire root rule list at the resolved offset. Without a [crate::evaluator::RuleEnvironment] (the shared root rules + name table) the engine has nothing to re-enter, so the directive is a no-op. This variant is reserved for consumers that opt in to strict-mode evaluation where the misconfiguration should abort the run; the default engine path logs at debug! and returns Ok(vec![]) for backward compatibility with low-level programmatic callers (tests, fuzz harnesses) that intentionally run without a MagicDatabase-attached environment, mirroring the Use-without-env contract.

Examples

use libmagic_rs::error::EvaluationError;

let error = EvaluationError::indirect_without_environment();
assert!(matches!(error, EvaluationError::IndirectWithoutEnvironment));

Implementations

impl EvaluationError

pub fn buffer_overrun(offset: usize) -> Self

Create a new BufferOverrun error.

pub fn invalid_offset(offset: i64) -> Self

Create a new InvalidOffset error.

pub fn unsupported_type(type_name: impl Into<String>) -> Self

Create a new UnsupportedType error.

pub fn recursion_limit_exceeded(depth: u32) -> Self

Create a new RecursionLimitExceeded error.

pub fn string_length_exceeded(length: usize, max_length: usize) -> Self

Create a new StringLengthExceeded error.

pub fn invalid_string_encoding(offset: usize) -> Self

Create a new InvalidStringEncoding error.

pub fn timeout(timeout_ms: u64) -> Self

Create a new Timeout error.

pub fn internal_error(message: impl Into<String>) -> Self

Create a new InternalError error.

pub const fn indirect_without_environment() -> Self

Create a new IndirectWithoutEnvironment error.

Trait Implementations

impl Debug for EvaluationError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for EvaluationError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for EvaluationError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<EvaluationError> for LibmagicError

fn from(source: EvaluationError) -> Self

Converts to this type from the input type.

impl From<TypeReadError> for EvaluationError

fn from(source: TypeReadError) -> Self

Converts to this type from the input type.