Skip to content

Commit 668640f

Browse files
domenukkdomenukk
committed
less err
1 parent f5a40b9 commit 668640f

File tree

16 files changed

+81
-68
lines changed

16 files changed

+81
-68
lines changed

‎crates/libafl/src/events/multi_machine.rs‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -228,9 +228,10 @@ where
228228
compressor: GzipCompressor::new(),
229229
}));
230230

231-
let rt = Arc::new(
232-
Runtime::new().map_err(|_| Error::unknown("Tokio runtime spawning failed"))?,
233-
);
231+
let rt =
232+
Arc::new(Runtime::new().map_err(|err| {
233+
Error::unknown(format!("Tokio runtime spawning failed: {err})"))
234+
})?);
234235

235236
TcpMultiMachineState::init::<I>(&state.clone(), &rt.clone())?;
236237

‎crates/libafl/src/inputs/encoded.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -162,8 +162,8 @@ impl Default for NaiveTokenizer {
162162
impl Tokenizer for NaiveTokenizer {
163163
fn tokenize(&self, bytes: &[u8]) -> Result<Vec<String>, Error> {
164164
let mut tokens = vec![];
165-
let string =
166-
from_utf8(bytes).map_err(|_| Error::illegal_argument("Invalid UTF-8".to_owned()))?;
165+
let string = from_utf8(bytes)
166+
.map_err(|err| Error::illegal_argument(format!("Invalid UTF-8: {err:?}")))?;
167167
let string = self.comment_re.replace_all(string, "").to_string();
168168
let mut str_prev = 0;
169169
for str_match in self.string_re.find_iter(&string) {

‎crates/libafl/src/lib.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,7 @@ mod tests {
180180
for i in 0..1000 {
181181
fuzzer
182182
.fuzz_one(&mut stages, &mut executor, &mut state, &mut event_manager)
183-
.unwrap_or_else(|_| panic!("Error in iter {i}"));
183+
.unwrap_or_else(|err| panic!("Error in iter {i}: {err:?}"));
184184
if cfg!(miri) {
185185
break;
186186
}

‎crates/libafl_frida/src/lib.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -542,7 +542,7 @@ mod tests {
542542
log::info!("Starting fuzzing!");
543543
fuzzer
544544
.fuzz_one(&mut stages, &mut executor, &mut state, &mut event_manager)
545-
.unwrap_or_else(|_| panic!("Error in fuzz_one"));
545+
.unwrap_or_else(|err| panic!("Error in fuzz_one: {err:?}"));
546546

547547
log::info!("Done fuzzing! Got {} solutions", state.solutions().count());
548548
if let Some(expected_error) = expected_error {
@@ -604,7 +604,7 @@ mod tests {
604604
);
605605

606606
GUM.set(Gum::obtain())
607-
.unwrap_or_else(|_| panic!("Failed to initialize Gum"));
607+
.unwrap_or_else(|err| panic!("Failed to initialize Gum: {err:?}"));
608608
let simulated_args = vec![
609609
"libafl_frida_test",
610610
"-A",

‎crates/libafl_intelpt/src/linux.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -70,10 +70,10 @@ static NR_ADDR_FILTERS: LazyLock<Result<u32, String>> = LazyLock::new(|| {
7070
static PERF_EVENT_TYPE: LazyLock<Result<u32, String>> = LazyLock::new(|| {
7171
let path = format!("{PT_EVENT_PATH}/type");
7272
let s = fs::read_to_string(&path)
73-
.map_err(|_| format!("Failed to read Intel PT perf event type from {path}"))?;
73+
.map_err(|err| format!("Failed to read Intel PT perf event type from {path}: {err:?}"))?;
7474
s.trim()
7575
.parse::<u32>()
76-
.map_err(|_| format!("Failed to parse Intel PT perf event type in {path}"))
76+
.map_err(|err| format!("Failed to parse Intel PT perf event type in {path}: {err:?}"))
7777
});
7878

7979
/// Intel PT mode of operation with KVM

‎crates/libafl_libfuzzer/runtime/src/lib.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -679,8 +679,8 @@ pub unsafe extern "C" fn LLVMFuzzerRunDriver(
679679
{
680680
// we've been requested to just run some inputs. Do so.
681681
for input in options.dirs() {
682-
let input = BytesInput::from_file(input).unwrap_or_else(|_| {
683-
panic!("Couldn't load input {}", input.to_string_lossy().as_ref())
682+
let input = BytesInput::from_file(input).unwrap_or_else(|err| {
683+
panic!("Couldn't load input {}: {err:?}", input.to_string_lossy().as_ref())
684684
});
685685
unsafe {
686686
libafl_targets::libfuzzer::libfuzzer_test_one_input(

‎crates/libafl_nyx/src/cmplog.rs‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -127,13 +127,13 @@ impl RedqueenEvent {
127127
let rhs_s = captures.get(5).ok_or("Missing RHS field")?.as_str();
128128
let imm = captures.get(6).is_some_and(|_x| true);
129129

130-
let addr =
131-
u64::from_str_radix(addr_s, 16).map_err(|_| format!("Invalid address: '{addr_s}'"))?;
130+
let addr = u64::from_str_radix(addr_s, 16)
131+
.map_err(|err| format!("Invalid address: '{addr_s}': {err:?}"))?;
132132
let bp_type = RedqueenBpType::new(type_s)
133133
.map_err(|e| format!("Invalid redqueen type: '{type_s}' - {e}"))?;
134134
let size = size_s
135135
.parse::<usize>()
136-
.map_err(|_| format!("Invalid size: '{size_s}'"))?;
136+
.map_err(|err| format!("Invalid size: '{size_s}: {err:?}'"))?;
137137
let lhs = hex_to_bytes(lhs_s).ok_or("Decoding LHS failed")?;
138138
let rhs = hex_to_bytes(rhs_s).ok_or("Decoding RHS failed")?;
139139

@@ -190,38 +190,38 @@ impl TryInto<CmpValues> for RedqueenEvent {
190190
u16::from_be_bytes(
191191
self.rhs
192192
.try_into()
193-
.map_err(|_| "Invalid RHS length for U16")?,
193+
.map_err(|err| "Invalid RHS length for U16: {err:?}")?,
194194
),
195195
u16::from_be_bytes(
196196
self.lhs
197197
.try_into()
198-
.map_err(|_| "Invalid LHS length for U16")?,
198+
.map_err(|err| "Invalid LHS length for U16: {err:?}")?,
199199
),
200200
self.imm,
201201
))),
202202
32 => Ok(CmpValues::U32((
203203
u32::from_be_bytes(
204204
self.rhs
205205
.try_into()
206-
.map_err(|_| "Invalid RHS length for U32")?,
206+
.map_err(|err| "Invalid RHS length for U32: {err:?}")?,
207207
),
208208
u32::from_be_bytes(
209209
self.lhs
210210
.try_into()
211-
.map_err(|_| "Invalid LHS length for U32")?,
211+
.map_err(|err| "Invalid LHS length for U32: {err:?}")?,
212212
),
213213
self.imm,
214214
))),
215215
64 => Ok(CmpValues::U64((
216216
u64::from_be_bytes(
217217
self.rhs
218218
.try_into()
219-
.map_err(|_| "Invalid RHS length for U64")?,
219+
.map_err(|err| "Invalid RHS length for U64: {err:?}")?,
220220
),
221221
u64::from_be_bytes(
222222
self.lhs
223223
.try_into()
224-
.map_err(|_| "Invalid LHS length for U64")?,
224+
.map_err(|err| "Invalid LHS length for U64: {err:?}")?,
225225
),
226226
self.imm,
227227
))),

‎crates/libafl_nyx/src/executor.rs‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -74,8 +74,12 @@ where
7474
.map_err(|e| Error::illegal_state(format!("Failed to clear Nyx stdout: {e}")))?;
7575
self.helper.nyx_stdout.rewind()?;
7676

77-
let size = u32::try_from(buffer.len())
78-
.map_err(|_| Error::unsupported("Inputs larger than 4GB are not supported"))?;
77+
let size = u32::try_from(buffer.len()).map_err(|err| {
78+
Error::unsupported(format!(
79+
"Inputs larger than 4GB are not supported. Tried {} bytes ({err:?})",
80+
buffer.len()
81+
))
82+
})?;
7983

8084
// `QemuProcess::set_hprintf_fd` assumes ownership of the passed file descriptor, so we
8185
// duplicate `self.helper.nyx_stdout`'s fd here to prevent it from being closed by

‎crates/libafl_qemu/libafl_qemu_build/src/build.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ pub struct BuildResult {
2020

2121
fn build_dep_check(tools: &[&str]) {
2222
for tool in tools {
23-
which(tool).unwrap_or_else(|_| panic!("Build tool {tool} not found"));
23+
which(tool).unwrap_or_else(|err| panic!("Build tool {tool} not found: {err:?}"));
2424
}
2525
}
2626

‎crates/libafl_qemu/libafl_qemu_build/src/lib.rs‎

Lines changed: 35 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -268,40 +268,41 @@ pub fn store_generated_content_if_different(
268268
let mut must_rewrite_file = true;
269269

270270
// Check if equivalent file already exists without relying on filesystem timestamp.
271-
let mut file_to_check =
272-
if let Ok(mut wrapper_file) = File::options().read(true).write(true).open(file_to_update) {
273-
let existing_file_content = content_file_to_update.unwrap_or_else(|| {
274-
let mut content = Vec::with_capacity(fresh_content.len());
275-
wrapper_file.read_to_end(content.as_mut()).unwrap();
276-
content
277-
});
278-
279-
if !force_regeneration {
280-
let mut existing_wrapper_hasher = hash_map::DefaultHasher::new();
281-
existing_wrapper_hasher.write(existing_file_content.as_ref());
282-
283-
let mut wrapper_h_hasher = hash_map::DefaultHasher::new();
284-
wrapper_h_hasher.write(fresh_content);
285-
286-
// Check if wrappers are the same
287-
if existing_wrapper_hasher.finish() == wrapper_h_hasher.finish() {
288-
must_rewrite_file = false;
289-
}
290-
}
291-
292-
// Reset file cursor if it's going to be rewritten
293-
if must_rewrite_file {
294-
wrapper_file.set_len(0).expect("Could not set file len");
295-
wrapper_file
296-
.seek(SeekFrom::Start(0))
297-
.expect("Could not seek file to beginning");
271+
let mut file_to_check = if let Ok(mut wrapper_file) =
272+
File::options().read(true).write(true).open(file_to_update)
273+
{
274+
let existing_file_content = content_file_to_update.unwrap_or_else(|| {
275+
let mut content = Vec::with_capacity(fresh_content.len());
276+
wrapper_file.read_to_end(content.as_mut()).unwrap();
277+
content
278+
});
279+
280+
if !force_regeneration {
281+
let mut existing_wrapper_hasher = hash_map::DefaultHasher::new();
282+
existing_wrapper_hasher.write(existing_file_content.as_ref());
283+
284+
let mut wrapper_h_hasher = hash_map::DefaultHasher::new();
285+
wrapper_h_hasher.write(fresh_content);
286+
287+
// Check if wrappers are the same
288+
if existing_wrapper_hasher.finish() == wrapper_h_hasher.finish() {
289+
must_rewrite_file = false;
298290
}
291+
}
299292

293+
// Reset file cursor if it's going to be rewritten
294+
if must_rewrite_file {
295+
wrapper_file.set_len(0).expect("Could not set file len");
300296
wrapper_file
301-
} else {
302-
File::create(file_to_update)
303-
.unwrap_or_else(|_| panic!("Could not create {}", file_to_update.display()))
304-
};
297+
.seek(SeekFrom::Start(0))
298+
.expect("Could not seek file to beginning");
299+
}
300+
301+
wrapper_file
302+
} else {
303+
File::create(file_to_update)
304+
.unwrap_or_else(|err| panic!("Could not create {}: {err:?}", file_to_update.display()))
305+
};
305306

306307
if must_rewrite_file {
307308
println!(
@@ -315,7 +316,9 @@ pub fn store_generated_content_if_different(
315316

316317
file_to_check
317318
.write_all(fresh_content)
318-
.unwrap_or_else(|_| panic!("Unable to write in {}", file_to_update.display()));
319+
.unwrap_or_else(|err| {
320+
panic!("Unable to write in {}: {err:?}", file_to_update.display())
321+
});
319322
}
320323
}
321324

0 commit comments

Comments
 (0)