unegg 0.1.2

EGG archive extractor
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

use std::fmt;

#[derive(Debug)]
pub enum EggError {
    NotEggFile,
    CorruptedFile,
    CantOpenFile(std::io::Error),
    CantOpenDestFile(std::io::Error),
    InvalidFileCrc { expected: u32, got: u32 },
    UnknownCompressionMethod(u8),
    UnsupportedEncryption(u8),
    PasswordNotSet,
    InvalidPassword,
    AuthenticationFailed,
    PathTraversal(String),
    Bzip2Failed(String),
    InflateFailed(String),
    LzmaFailed(String),
    AzoFailed(String),
    Io(std::io::Error),
}

pub type EggResult<T> = Result<T, EggError>;

impl fmt::Display for EggError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::NotEggFile => write!(f, "not an EGG file"),
            Self::CorruptedFile => write!(f, "corrupted file"),
            Self::CantOpenFile(e) => write!(f, "can't open file: {e}"),
            Self::CantOpenDestFile(e) => write!(f, "can't open destination file: {e}"),
            Self::InvalidFileCrc { expected, got } => {
                write!(f, "CRC mismatch: expected {expected:08x}, got {got:08x}")
            }
            Self::UnknownCompressionMethod(m) => {
                write!(f, "unknown compression method: {m}")
            }
            Self::UnsupportedEncryption(m) => {
                write!(f, "unsupported encryption method: {m}")
            }
            Self::PasswordNotSet => write!(f, "password not set"),
            Self::InvalidPassword => write!(f, "invalid password"),
            Self::AuthenticationFailed => write!(f, "authentication failed (HMAC mismatch)"),
            Self::PathTraversal(p) => write!(f, "path traversal: {p}"),
            Self::Bzip2Failed(e) => write!(f, "bzip2 failed: {e}"),
            Self::InflateFailed(e) => write!(f, "inflate failed: {e}"),
            Self::LzmaFailed(e) => write!(f, "LZMA failed: {e}"),
            Self::AzoFailed(e) => write!(f, "AZO failed: {e}"),
            Self::Io(e) => write!(f, "I/O error: {e}"),
        }
    }
}

impl std::error::Error for EggError {}

impl From<std::io::Error> for EggError {
    fn from(e: std::io::Error) -> Self {
        Self::Io(e)
    }
}