1#[derive(Debug, Clone, Copy)]
5#[non_exhaustive]
6pub enum Needle<'a> {
7 Bytes(&'a [u8]),
9 Word(u32),
11 FreeRun {
13 len: usize,
15 align: usize,
17 },
18 Masked(&'a [(u16, u16)]),
20}
21
22pub fn find(image: &[u8], needle: Needle<'_>, start: usize) -> Option<usize> {
26 match needle {
27 Needle::Bytes(pattern) => {
28 if pattern.is_empty() {
29 return None;
30 }
31 image
32 .get(start..)?
33 .windows(pattern.len())
34 .position(|bytes| bytes == pattern)
35 .map(|offset| start + offset)
36 }
37 Needle::Word(word) => find(image, Needle::Bytes(&word.to_be_bytes()), start),
38 Needle::FreeRun { len, align } => find_free_space(image, len, align, start),
39 Needle::Masked(pattern) => {
40 if pattern.is_empty() {
41 return None;
42 }
43 let len = pattern.len() * 2;
44 let end = image.len().checked_sub(len)?;
45 let start = start.checked_add(start % 2)?;
46 (start..=end).step_by(2).find(|&at| {
47 pattern.iter().enumerate().all(|(index, &(value, mask))| {
48 let word =
49 u16::from_be_bytes([image[at + index * 2], image[at + index * 2 + 1]]);
50 word & mask == value & mask
51 })
52 })
53 }
54 }
55}
56
57pub fn find_free_space(image: &[u8], len: usize, align: usize, start: usize) -> Option<usize> {
60 if len == 0 || align == 0 {
61 return None;
62 }
63 let end = image.len().checked_sub(len)?;
64 let remainder = start % align;
65 let start = start.checked_add(if remainder == 0 { 0 } else { align - remainder })?;
66 (start..=end)
67 .step_by(align)
68 .find(|&at| image[at..at + len].iter().all(|&byte| byte == 0xff))
69}
70
71pub fn read_u8(image: &[u8], at: usize) -> Option<u8> {
73 image.get(at).copied()
74}
75
76pub fn read_u16(image: &[u8], at: usize) -> Option<u16> {
78 let bytes = image.get(at..)?.get(..2)?;
79 Some(u16::from_be_bytes([bytes[0], bytes[1]]))
80}
81
82pub fn read_u32(image: &[u8], at: usize) -> Option<u32> {
84 let bytes = image.get(at..)?.get(..4)?;
85 Some(u32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
86}
87
88#[derive(Debug, Clone, Copy, PartialEq, Eq)]
90pub enum ImageError {
91 OutOfBounds,
93 NotFree,
95}
96
97pub fn write(image: &mut [u8], at: usize, bytes: &[u8]) -> Result<(), ImageError> {
100 let destination = image
101 .get_mut(at..)
102 .and_then(|rest| rest.get_mut(..bytes.len()))
103 .ok_or(ImageError::OutOfBounds)?;
104 destination.copy_from_slice(bytes);
105 Ok(())
106}
107
108pub fn insert(image: &mut [u8], at: usize, bytes: &[u8]) -> Result<usize, ImageError> {
111 let destination = image
112 .get_mut(at..)
113 .and_then(|rest| rest.get_mut(..bytes.len()))
114 .ok_or(ImageError::OutOfBounds)?;
115 if destination.iter().any(|&byte| byte != 0xff) {
116 return Err(ImageError::NotFree);
117 }
118 destination.copy_from_slice(bytes);
119 Ok(at)
120}
121
122#[derive(Debug, Clone, Copy)]
124pub struct CommandTable {
125 pub base: usize,
127 pub stride: usize,
129 pub opcode_off: usize,
131 pub flags_off: usize,
133 pub handler_off: usize,
135 pub term_flag: u8,
137 pub max_records: usize,
139}
140
141#[derive(Debug, Clone, Copy, PartialEq, Eq)]
143pub struct CommandRecord {
144 pub off: usize,
146 pub opcode: u8,
148 pub flags: u8,
150 pub handler: u32,
152}
153
154#[derive(Debug, Clone, Copy, PartialEq, Eq)]
156pub enum TableError {
157 InvalidGeometry,
159 OutOfBounds,
161 MissingTerminator,
163 NotFound,
165}
166
167impl CommandTable {
168 pub fn walk(&self, image: &[u8]) -> Result<Vec<CommandRecord>, TableError> {
170 let handler_end = self
171 .handler_off
172 .checked_add(4)
173 .ok_or(TableError::InvalidGeometry)?;
174 if self.stride == 0
175 || self.max_records == 0
176 || self.opcode_off >= self.stride
177 || self.flags_off >= self.stride
178 || handler_end > self.stride
179 || self.opcode_off == self.flags_off
180 || (self.handler_off..handler_end).contains(&self.opcode_off)
181 || (self.handler_off..handler_end).contains(&self.flags_off)
182 {
183 return Err(TableError::InvalidGeometry);
184 }
185 let mut records = Vec::new();
186 let mut at = self.base;
187 for _ in 0..self.max_records {
188 let record = image
189 .get(at..)
190 .and_then(|rest| rest.get(..self.stride))
191 .ok_or(TableError::OutOfBounds)?;
192 let flags = record[self.flags_off];
193 if flags == self.term_flag {
194 return Ok(records);
195 }
196 let pointer = &record[self.handler_off..handler_end];
197 records.push(CommandRecord {
198 off: at,
199 opcode: record[self.opcode_off],
200 flags,
201 handler: u32::from_be_bytes([pointer[0], pointer[1], pointer[2], pointer[3]]),
202 });
203 at += self.stride; }
205 Err(TableError::MissingTerminator)
206 }
207
208 pub fn find(&self, image: &[u8], opcode: u8) -> Result<CommandRecord, TableError> {
210 self.walk(image)?
211 .into_iter()
212 .find(|record| record.opcode == opcode)
213 .ok_or(TableError::NotFound)
214 }
215
216 pub fn replace(
219 &self,
220 image: &mut [u8],
221 opcode: u8,
222 handler: u32,
223 flags: Option<u8>,
224 ) -> Result<(), TableError> {
225 let record = self.find(image, opcode)?;
226 let at = record.off + self.handler_off;
227 image[at..at + 4].copy_from_slice(&handler.to_be_bytes());
228 if let Some(flags) = flags {
229 image[record.off + self.flags_off] = flags;
230 }
231 Ok(())
232 }
233}