added error handling with thiserror crate

Author: noobexon1

Cargo.lock

@@ -6,4 +6,5 @@ edition = "2021"
 [dependencies]
 clap = { version = "4.5.4", features = ["derive"] }
 byteorder = "1.5.0"
-prettytable-rs = "0.10.0"
+prettytable-rs = "0.10.0"
+thiserror = "1.0.61"

Cargo.toml

@@ -0,0 +1,11 @@
+// error.rs
+use thiserror::Error;
+use std::io;
+
+#[derive(Error, Debug)]
+pub enum AppError {
+    #[error("IO Error")]
+    Io(#[from] io::Error),
+    #[error("Other Error: {0}")]
+    Other(String),
+}

src/error.rs

@@ -1,7 +1,7 @@
-use std::io;
 use std::io::Read;
 
 use byteorder::ReadBytesExt;
+use crate::error::AppError;
 
 #[derive(Debug)]
 pub enum MachHeader {
@@ -45,7 +45,7 @@ pub struct MachHeader32 {
 }
 
 impl MachHeader32 {
-    pub fn from_file<R: Read, E: byteorder::ByteOrder>(file: &mut R, magic: u32) -> io::Result<MachHeader> {
+    pub fn from_file<R: Read, E: byteorder::ByteOrder>(file: &mut R, magic: u32) -> Result<MachHeader, AppError> {
         let header = MachHeader32 {
             magic,
             cputype: file.read_i32::<E>()?,
@@ -73,7 +73,7 @@ pub struct MachHeader64 {
 }
 
 impl MachHeader64 {
-    pub fn from_file<R: Read, E: byteorder::ByteOrder>(file: &mut R, magic: u32) -> io::Result<MachHeader> {
+    pub fn from_file<R: Read, E: byteorder::ByteOrder>(file: &mut R, magic: u32) -> Result<MachHeader, AppError> {
         let header = MachHeader64 {
             magic,
             cputype: file.read_i32::<E>()?,

src/header.rs

@@ -1,13 +1,6 @@
 use crate::header::MachHeader;
 use crate::load_commands::{LcStr, LoadCommand, Section};
 
-// TODO: make it more generic. we shoudl make a pair of (Vec<LoadCommand>, Vec<extra_memory>).
-// TODO: we encapsulte each extra_memory with its type by making and extrra_memory an enum (what to do with it?) and then we iterate and resolve! :D
-
-// 1. create an enum for extra_memory and add all the possible options. extra_memory subtype should be a vector of u8.
-// 2. make every load command that has extra memory after it read the chunk to a new extra_memory and append it to Vec<extra_memory>
-// 3. after reading the load commands we immideatly start going over the chunks and parse them according to each type :D
-
 pub struct MachO {
     pub header: MachHeader,
     pub load_commands: (Vec<LoadCommand>, Vec<Vec<Section>>, Vec<LcStr>),

src/load_commands.rs

@@ -4,6 +4,8 @@ use std::fs::File;
 use std::path::PathBuf;
 
 use clap::Parser;
+use crate::error::AppError;
+use crate::mach_o::MachO;
 
 mod constants;
 mod header;
@@ -12,6 +14,7 @@ mod mach_o;
 mod memory_utils;
 mod parser;
 mod printer;
+mod error;
 
 /// A command-line tool written in Rust to view and explore mach-o files.
 #[derive(Parser)]
@@ -32,13 +35,19 @@ struct Args {
     load_commands: bool,
 }
 
-// TODO: createt a new mod called "error.rs" which main will send errors to in order to be handled
-fn main() {
+fn main() -> Result<(), AppError> {
     let args = Args::parse();
-    let mach_o = match File::open(&args.file.as_path()) {
-        Ok(mut file) => parser::parse(&mut file).unwrap(),
-        Err(e) => panic!("Error: Could not open input file for reading! {}", e),
-    };
+
+    if let Err(e) = run(&args) {
+        eprintln!("Error: {}", e);
+        std::process::exit(1);
+    }
+
+    Ok(())
+}
+
+fn run(args: &Args) -> Result<(), AppError> {
+    let mach_o = parse_from_file(&args.file)?;
 
     if args.interactive {
         println!("Not yet implemented!");
@@ -52,4 +61,11 @@ fn main() {
         printer::print_load_commands(&mach_o.load_commands);
     }
 
+    Ok(())
+}
+
+fn parse_from_file(path: &PathBuf) -> Result<MachO, AppError> {
+    let mut file = File::open(path)?;
+    let mach_o = parser::parse(&mut file)?;
+    Ok(mach_o)
 }

src/mach_o.rs

@@ -4,12 +4,13 @@ use std::io::{Read, Seek};
 use byteorder::{BigEndian, ByteOrder, LittleEndian, ReadBytesExt};
 
 use crate::constants::*;
+use crate::error::AppError;
 use crate::header::*;
 use crate::load_commands::*;
 use crate::mach_o::MachO;
 use crate::memory_utils::{advance_to_next_load_command, get_file_offset};
 
-pub fn parse<R: Read + Seek>(file: &mut R) -> io::Result<MachO> {
+pub fn parse<R: Read + Seek>(file: &mut R) -> Result<MachO, AppError> {
     let magic = file.read_u32::<BigEndian>()?;
     check_magic_number(magic)?;
 
@@ -33,22 +34,22 @@ pub fn parse<R: Read + Seek>(file: &mut R) -> io::Result<MachO> {
     })
 }
 
-fn check_magic_number(magic: u32) -> io::Result<()> {
+fn check_magic_number(magic: u32) -> Result<(), AppError> {
     match magic {
         MH_MAGIC | MH_MAGIC_64 | MH_CIGAM | MH_CIGAM_64 => Ok(()),
-        _ => Err(io::Error::new(io::ErrorKind::InvalidData, "Invalid Mach-O magic number"))
+        _ => Err(AppError::from(io::Error::new(io::ErrorKind::InvalidData, "Invalid Mach-O magic number")))
     }
 }
 
-fn parse_header<R: Read + Seek, E: ByteOrder>(file: &mut R, magic: u32) -> io::Result<MachHeader> {
+fn parse_header<R: Read + Seek, E: ByteOrder>(file: &mut R, magic: u32) -> Result<MachHeader, AppError> {
     match magic {
         MH_MAGIC | MH_CIGAM => MachHeader32::from_file::<R, E>(file, magic),
         MH_MAGIC_64 | MH_CIGAM_64 => MachHeader64::from_file::<R, E>(file, magic),
         _ => unreachable!(),
     }
 }
 
-fn parse_load_commands<R: Read + Seek, E: ByteOrder>(file: &mut R, header: &MachHeader) -> io::Result<(Vec<LoadCommand>, Vec<Vec<Section>>, Vec<LcStr>)> {
+fn parse_load_commands<R: Read + Seek, E: ByteOrder>(file: &mut R, header: &MachHeader) -> Result<(Vec<LoadCommand>, Vec<Vec<Section>>, Vec<LcStr>), AppError> {
     let mut load_commands: Vec<LoadCommand> = Vec::new();
     let mut sections: Vec<Vec<Section>> = Vec::new();
     let mut load_commands_strings: Vec<LcStr> = Vec::new();
@@ -70,9 +71,8 @@ fn parse_load_commands<R: Read + Seek, E: ByteOrder>(file: &mut R, header: &Mach
     Ok((load_commands, sections, load_commands_strings))
 }
 
-fn parse_command<R: Read, E: ByteOrder>(file: &mut R, load_command_prefix: &LoadCommandPrefix) -> io::Result<LoadCommand> {
+fn parse_command<R: Read, E: ByteOrder>(file: &mut R, load_command_prefix: &LoadCommandPrefix) ->Result<LoadCommand, AppError> {
     match load_command_prefix.cmd {
-        LC_SEGMENT => SegmentCommand32::from_file::<R, E>(file, load_command_prefix),
         LC_SYMTAB => SymtabCommand::from_file::<R, E>(file, load_command_prefix),
         LC_SYMSEG => SymsegCommand::from_file::<R, E>(file, load_command_prefix),
         LC_THREAD | LC_UNIXTHREAD => ThreadCommand::from_file::<E>(load_command_prefix),
@@ -88,6 +88,7 @@ fn parse_command<R: Read, E: ByteOrder>(file: &mut R, load_command_prefix: &Load
         LC_SUB_LIBRARY => SubLibraryCommand::from_file::<R, E>(file, load_command_prefix),
         LC_TWOLEVEL_HINTS => TwoLevelHintsCommand::from_file::<R, E>(file, load_command_prefix),
         LC_PREBIND_CKSUM => PrebindCksumCommand::from_file::<R, E>(file, load_command_prefix),
+        LC_SEGMENT => SegmentCommand32::from_file::<R, E>(file, load_command_prefix),
         LC_SEGMENT_64 => SegmentCommand64::from_file::<R, E>(file, load_command_prefix),
         LC_ROUTINES_64 => RoutinesCommand64::from_file::<R, E>(file, load_command_prefix),
         LC_UUID => UuidCommand::from_file::<R, E>(file, load_command_prefix),
@@ -102,23 +103,23 @@ fn parse_command<R: Read, E: ByteOrder>(file: &mut R, load_command_prefix: &Load
         LC_LINKER_OPTION => LinkerOptionCommand::from_file::<R, E>(file, load_command_prefix),
         LC_NOTE => NoteCommand::from_file::<R, E>(file, load_command_prefix),
         LC_BUILD_VERSION => BuildVersionCommand::from_file::<R, E>(file, load_command_prefix),
-        _ => Err(io::Error::new(io::ErrorKind::InvalidData, "unknown load command type!"))
+        _ => Err(AppError::from(io::Error::new(io::ErrorKind::InvalidData, "unknown load command type!")))
     }
 }
 
-fn parse_sections_for_segment<R: Read + Seek, E: ByteOrder>(file: &mut R, load_command: &LoadCommand) -> io::Result<Vec<Section>> {
+fn parse_sections_for_segment<R: Read + Seek, E: ByteOrder>(file: &mut R, load_command: &LoadCommand) -> Result<Vec<Section>, AppError> {
     let mut load_command_sections = Vec::new();
     match load_command {
         LoadCommand::SegmentCommand(command) => {
             match command {
                 SegmentCommand::SEG32(command) => {
-                    for i in 0..command.nsects {
+                    for _ in 0..command.nsects {
                         let section = Section32::from_file::<R, E>(file)?;
                         load_command_sections.push(section);
                     }
                 }
                 SegmentCommand::SEG64(command) => {
-                    for i in 0..command.nsects {
+                    for _ in 0..command.nsects {
                         let section = Section64::from_file::<R, E>(file)?;
                         load_command_sections.push(section);
                     }
@@ -130,7 +131,7 @@ fn parse_sections_for_segment<R: Read + Seek, E: ByteOrder>(file: &mut R, load_c
     Ok(load_command_sections)
 }
 
-fn parse_load_command_string<R: Read + Seek, E: ByteOrder>(file: &mut R, load_command: &LoadCommand, lc_offset: u64, cmdsize: u32) -> io::Result<LcStr> {
+fn parse_load_command_string<R: Read + Seek, E: ByteOrder>(file: &mut R, load_command: &LoadCommand, lc_offset: u64, cmdsize: u32) -> Result<LcStr, AppError> {
     let mut load_command_string = Vec::new();
     match load_command {
         LoadCommand::DylibCommand(_) |
@@ -153,6 +154,6 @@ fn parse_load_command_string<R: Read + Seek, E: ByteOrder>(file: &mut R, load_co
     Ok(load_command_string)
 }
 
-fn get_load_command_remaining_size(lc_offset: u64, lc_size: u64, file_offset: u64) -> io::Result<u64> {
+fn get_load_command_remaining_size(lc_offset: u64, lc_size: u64, file_offset: u64) -> Result<u64, AppError> {
     Ok((lc_offset + lc_size) - file_offset)
 }