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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

/*!
Errors and Results.
*/

use std::{fmt, result, str};

#[cfg(feature = "std")]
use std::error;

/// Errors while parsing the PE binary.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
#[cfg_attr(feature = "serde", derive(::serde::Serialize))]
pub enum Error {
	/// Null address.
	Null,
	/// Out of bounds.
	///
	/// Catch-all for bounds check errors.
	Bounds,
	/// Data is not available.
	///
	/// Can happen when referencing data in `PeFile` instances.
	///
	/// Sections can be shorter than stored on disk, the remaining bytes will default to zeroes when loaded by the system.
	/// Since these zeroes would just be a waste of space, they are not present in the binaries on disk.
	/// This error happens when attempting to get a reference to such zero filled data.
	ZeroFill,
	/// Data is not available.
	///
	/// Can happen when referencing data in `PeView` instances.
	///
	/// Sections can have excess in their raw data which won't be mapped when loaded by the system.
	/// This error happens when attempting to get a reference to such unmapped raw data.
	/// Sometimes this kind of excess is called an overlay.
	Unmapped,
	/// Address is misaligned.
	Misaligned,
	/// Expected magic number does not match.
	BadMagic,
	/// Trying to load a PE32 file with a PE32+ parser or vice versa.
	PeMagic,
	/// Sanity check failed.
	///
	/// Some value was so far outside its typical range, while not technically incorrect, probably indicating something went wrong.
	/// If this error is encountered legitimately, create an issue or file a PR to relax the artificial restrictions.
	Insanity,
	/// Invalid data.
	///
	/// Structured data was found which simply isn't valid.
	/// Catch-all for errors which don't fall under other errors.
	Invalid,
	/// Overflow error.
	///
	/// Catch-all for overflow and underflow errors.
	Overflow,
	/// Encoding error.
	///
	/// Catch-all for string related errors such as lacking a nul terminator.
	Encoding,
	/// Aliasing error.
	///
	/// Request cannot be fulfilled because it would alias with an existing borrow.
	Aliasing,
}

impl From<str::Utf8Error> for Error {
	fn from(_err: str::Utf8Error) -> Error {
		Error::Encoding
	}
}

impl Error {
	/// Returns if the error variant is Null.
	///
	/// Useful in match guards where `Null` should be handled as a non-error case.
	///
	/// ```
	/// fn with_default(result: pelite::Result<i32>) -> pelite::Result<i32> {
	/// 	let i = match result {
	/// 		Ok(i) => i,
	/// 		// Avoids a more verbose comparison with pelite::Error::Null
	/// 		Err(err) if err.is_null() => 0,
	/// 		Err(err) => return Err(err),
	/// 	};
	/// 	Ok(i)
	/// }
	///
	/// assert_eq!(with_default(Err(pelite::Error::Null)), Ok(0));
	/// ```
	pub fn is_null(self) -> bool {
		self == Error::Null
	}

	/// Returns a simple string representation of the error.
	pub fn to_str(self) -> &'static str {
		match self {
			Error::Null => "null address reference",
			Error::Bounds => "bounds check failed",
			Error::ZeroFill => "zero filled data reference",
			Error::Unmapped => "overlay data reference",
			Error::Misaligned => "address misaligned",
			Error::BadMagic => "unknown magic number",
			Error::PeMagic => "try again with correct parser",
			Error::Insanity => "data insanity",
			Error::Invalid => "invalid data",
			Error::Overflow => "overflow error",
			Error::Encoding => "encoding error",
			Error::Aliasing => "aliasing error",
		}
	}
}

impl fmt::Display for Error {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		f.write_str(self.to_str())
	}
}

#[cfg(feature = "std")]
impl error::Error for Error {
	fn description(&self) -> &str {
		self.to_str()
	}
}

/// Specialized `Result` type for PE errors.
pub type Result<T> = result::Result<T, Error>;