Add dyld shared cache parsing

examples/dyldcachedump.rs

@@ -0,0 +1,50 @@
+use object::read::macho::DyldCache;
+use object::Endianness;
+use std::{env, fs, process};
+
+fn main() {
+    let arg_len = env::args().len();
+    if arg_len <= 1 {
+        eprintln!("Usage: {} <file> ...", env::args().next().unwrap());
+        process::exit(1);
+    }
+
+    for file_path in env::args().skip(1) {
+        if arg_len > 2 {
+            println!();
+            println!("{}:", file_path);
+        }
+
+        let file = match fs::File::open(&file_path) {
+            Ok(file) => file,
+            Err(err) => {
+                println!("Failed to open file '{}': {}", file_path, err,);
+                continue;
+            }
+        };
+        let file = match unsafe { memmap2::Mmap::map(&file) } {
+            Ok(mmap) => mmap,
+            Err(err) => {
+                println!("Failed to map file '{}': {}", file_path, err,);
+                continue;
+            }
+        };
+        let cache = match DyldCache::<Endianness>::parse(&*file) {
+            Ok(cache) => cache,
+            Err(err) => {
+                println!(
+                    "Failed to parse Dyld shared cache file '{}': {}",
+                    file_path, err,
+                );
+                continue;
+            }
+        };
+
+        // Print the list of image paths in this file.
+        for image in cache.images() {
+            if let Ok(path) = image.path() {
+                println!("{}", path);
+            }
+        }
+    }
+}

examples/objdump.rs

@@ -1,71 +1,107 @@
 use object::read::archive::ArchiveFile;
-use object::read::macho::{FatArch, FatHeader};
-use object::{Object, ObjectComdat, ObjectSection, ObjectSymbol};
+use object::read::macho::{DyldCache, FatArch, FatHeader};
+use object::{Endianness, Object, ObjectComdat, ObjectSection, ObjectSymbol};
 use std::{env, fs, process};
 
 fn main() {
-    let arg_len = env::args().len();
-    if arg_len <= 1 {
-        eprintln!("Usage: {} <file> ...", env::args().next().unwrap());
+    let mut args = env::args();
+    let cmd = args.next().unwrap();
+    if args.len() == 0 {
+        eprintln!("Usage: {} <file> [<member>...]", cmd);
         process::exit(1);
     }
+    let file_path = args.next().unwrap();
+    let mut member_names: Vec<_> = args.map(|name| (name, false)).collect();
 
-    for file_path in env::args().skip(1) {
-        if arg_len > 2 {
-            println!();
-            println!("{}:", file_path);
+    let file = match fs::File::open(&file_path) {
+        Ok(file) => file,
+        Err(err) => {
+            eprintln!("Failed to open file '{}': {}", file_path, err,);
+            process::exit(1);
         }
+    };
+    let file = match unsafe { memmap2::Mmap::map(&file) } {
+        Ok(mmap) => mmap,
+        Err(err) => {
+            eprintln!("Failed to map file '{}': {}", file_path, err,);
+            process::exit(1);
+        }
+    };
 
-        let file = match fs::File::open(&file_path) {
-            Ok(file) => file,
-            Err(err) => {
-                println!("Failed to open file '{}': {}", file_path, err,);
-                continue;
-            }
-        };
-        let file = match unsafe { memmap2::Mmap::map(&file) } {
-            Ok(mmap) => mmap,
-            Err(err) => {
-                println!("Failed to map file '{}': {}", file_path, err,);
-                continue;
-            }
-        };
-
-        if let Ok(archive) = ArchiveFile::parse(&*file) {
-            println!("Format: Archive (kind: {:?})", archive.kind());
-            for member in archive.members() {
-                if let Ok(member) = member {
+    if let Ok(archive) = ArchiveFile::parse(&*file) {
+        eprintln!("Format: Archive (kind: {:?})", archive.kind());
+        for member in archive.members() {
+            if let Ok(member) = member {
+                if find_member(&mut member_names, member.name()) {
                     println!();
                     println!("{}:", String::from_utf8_lossy(member.name()));
                     if let Ok(data) = member.data(&*file) {
                         dump_object(data);
                     }
                 }
             }
-        } else if let Ok(arches) = FatHeader::parse_arch32(&*file) {
-            println!("Format: Mach-O Fat 32");
-            for arch in arches {
-                println!();
-                println!("Fat Arch: {:?}", arch.architecture());
-                if let Ok(data) = arch.data(&*file) {
-                    dump_object(data);
-                }
+        }
+    } else if let Ok(arches) = FatHeader::parse_arch32(&*file) {
+        println!("Format: Mach-O Fat 32");
+        for arch in arches {
+            println!();
+            println!("Fat Arch: {:?}", arch.architecture());
+            if let Ok(data) = arch.data(&*file) {
+                dump_object(data);
             }
-        } else if let Ok(arches) = FatHeader::parse_arch64(&*file) {
-            println!("Format: Mach-O Fat 64");
-            for arch in arches {
-                println!();
-                println!("Fat Arch: {:?}", arch.architecture());
-                if let Ok(data) = arch.data(&*file) {
-                    dump_object(data);
+        }
+    } else if let Ok(arches) = FatHeader::parse_arch64(&*file) {
+        println!("Format: Mach-O Fat 64");
+        for arch in arches {
+            println!();
+            println!("Fat Arch: {:?}", arch.architecture());
+            if let Ok(data) = arch.data(&*file) {
+                dump_object(data);
+            }
+        }
+    } else if let Ok(cache) = DyldCache::<Endianness>::parse(&*file) {
+        println!("Format: dyld cache {:?}-endian", cache.endianness());
+        println!("Architecture: {:?}", cache.architecture());
+        for image in cache.images() {
+            if let Ok(path) = image.path() {
+                if find_member(&mut member_names, path.as_bytes()) {
+                    println!();
+                    println!("{}:", path);
+                    let file = match image.parse_object() {
+                        Ok(file) => file,
+                        Err(err) => {
+                            eprintln!("Failed to parse file: {}", err);
+                            continue;
+                        }
+                    };
+                    dump_parsed_object(&file);
                 }
             }
-        } else {
-            dump_object(&*file);
+        }
+    } else {
+        dump_object(&*file);
+    }
+
+    for (name, found) in member_names {
+        if !found {
+            eprintln!("Failed to find member '{}", name);
         }
     }
 }
 
+fn find_member(member_names: &mut [(String, bool)], name: &[u8]) -> bool {
+    if member_names.is_empty() {
+        return true;
+    }
+    match member_names.iter().position(|x| x.0.as_bytes() == name) {
+        Some(i) => {
+            member_names[i].1 = true;
+            true
+        }
+        None => false,
+    }
+}
+
 fn dump_object(data: &[u8]) {
     let file = match object::File::parse(data) {
         Ok(file) => file,
@@ -74,6 +110,10 @@ fn dump_object(data: &[u8]) {
             return;
         }
     };
+    dump_parsed_object(&file);
+}
+
+fn dump_parsed_object(file: &object::File) {
     println!(
         "Format: {:?} {:?}-endian {}-bit",
         file.format(),

examples/readobj.rs

@@ -192,10 +192,11 @@ fn print_object(p: &mut Printer<impl Write>, data: &[u8]) {
     match kind {
         object::FileKind::Archive => print_archive(p, data),
         object::FileKind::Coff => pe::print_coff(p, data),
+        object::FileKind::DyldCache => macho::print_dyld_cache(p, data),
         object::FileKind::Elf32 => elf::print_elf32(p, data),
         object::FileKind::Elf64 => elf::print_elf64(p, data),
-        object::FileKind::MachO32 => macho::print_macho32(p, data),
-        object::FileKind::MachO64 => macho::print_macho64(p, data),
+        object::FileKind::MachO32 => macho::print_macho32(p, data, 0),
+        object::FileKind::MachO64 => macho::print_macho64(p, data, 0),
         object::FileKind::MachOFat32 => macho::print_macho_fat32(p, data),
         object::FileKind::MachOFat64 => macho::print_macho_fat64(p, data),
         object::FileKind::Pe32 => pe::print_pe32(p, data),
@@ -205,6 +206,22 @@ fn print_object(p: &mut Printer<impl Write>, data: &[u8]) {
     }
 }
 
+fn print_object_at(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
+    let kind = match object::FileKind::parse_at(data, offset) {
+        Ok(file) => file,
+        Err(err) => {
+            println!("Failed to parse file: {}", err);
+            return;
+        }
+    };
+    match kind {
+        object::FileKind::MachO32 => macho::print_macho32(p, data, offset),
+        object::FileKind::MachO64 => macho::print_macho64(p, data, offset),
+        // TODO
+        _ => {}
+    }
+}
+
 fn print_archive(p: &mut Printer<impl Write>, data: &[u8]) {
     if let Ok(archive) = ArchiveFile::parse(data) {
         p.field("Format", format!("Archive ({:?})", archive.kind()));
@@ -3171,6 +3188,83 @@ mod macho {
     use object::read::macho::*;
     use object::BigEndian;
 
+    pub(super) fn print_dyld_cache(p: &mut Printer<impl Write>, data: &[u8]) {
+        if let Ok(header) = DyldCacheHeader::<Endianness>::parse(data) {
+            if let Ok((_, endian)) = header.parse_magic() {
+                print_dyld_cache_header(p, endian, header);
+                let mappings = header.mappings(endian, data).ok();
+                if let Some(mappings) = mappings {
+                    print_dyld_cache_mappings(p, endian, mappings);
+                }
+                if let Ok(images) = header.images(endian, data) {
+                    print_dyld_cache_images(p, endian, data, mappings, images);
+                }
+            }
+        }
+    }
+
+    pub(super) fn print_dyld_cache_header(
+        p: &mut Printer<impl Write>,
+        endian: Endianness,
+        header: &DyldCacheHeader<Endianness>,
+    ) {
+        p.group("DyldCacheHeader", |p| {
+            p.field_bytes("Magic", &header.magic);
+            p.field_hex("MappingOffset", header.mapping_offset.get(endian));
+            p.field("MappingCount", header.mapping_count.get(endian));
+            p.field_hex("ImagesOffset", header.images_offset.get(endian));
+            p.field("ImagesCount", header.images_count.get(endian));
+            p.field_hex("DyldBaseAddress", header.dyld_base_address.get(endian));
+        });
+    }
+
+    pub(super) fn print_dyld_cache_mappings(
+        p: &mut Printer<impl Write>,
+        endian: Endianness,
+        mappings: &[DyldCacheMappingInfo<Endianness>],
+    ) {
+        for mapping in mappings {
+            p.group("DyldCacheMappingInfo", |p| {
+                p.field_hex("Address", mapping.address.get(endian));
+                p.field_hex("Size", mapping.size.get(endian));
+                p.field_hex("FileOffset", mapping.file_offset.get(endian));
+                p.field_hex("MaxProt", mapping.max_prot.get(endian));
+                p.flags(mapping.max_prot.get(endian), 0, FLAGS_VM);
+                p.field_hex("InitProt", mapping.init_prot.get(endian));
+                p.flags(mapping.init_prot.get(endian), 0, FLAGS_VM);
+            });
+        }
+    }
+
+    pub(super) fn print_dyld_cache_images(
+        p: &mut Printer<impl Write>,
+        endian: Endianness,
+        data: &[u8],
+        mappings: Option<&[DyldCacheMappingInfo<Endianness>]>,
+        images: &[DyldCacheImageInfo<Endianness>],
+    ) {
+        for image in images {
+            p.group("DyldCacheImageInfo", |p| {
+                p.field_hex("Address", image.address.get(endian));
+                p.field_hex("ModTime", image.mod_time.get(endian));
+                p.field_hex("Inode", image.inode.get(endian));
+                p.field_string(
+                    "Path",
+                    image.path_file_offset.get(endian),
+                    image.path(endian, data).ok(),
+                );
+                p.field_hex("Pad", image.pad.get(endian));
+            });
+            if let Some(offset) =
+                mappings.and_then(|mappings| image.file_offset(endian, mappings).ok())
+            {
+                p.blank();
+                print_object_at(p, data, offset);
+                p.blank();
+            }
+        }
+    }
+
     pub(super) fn print_macho_fat32(p: &mut Printer<impl Write>, data: &[u8]) {
         if let Ok(arches) = FatHeader::parse_arch32(data) {
             println!("Format: Mach-O Fat 32-bit");
@@ -3221,17 +3315,17 @@ mod macho {
         });
     }
 
-    pub(super) fn print_macho32(p: &mut Printer<impl Write>, data: &[u8]) {
-        if let Ok(header) = MachHeader32::parse(data, 0) {
+    pub(super) fn print_macho32(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
+        if let Ok(header) = MachHeader32::parse(data, offset) {
             println!("Format: Mach-O 32-bit");
-            print_macho(p, header, data);
+            print_macho(p, header, data, offset);
         }
     }
 
-    pub(super) fn print_macho64(p: &mut Printer<impl Write>, data: &[u8]) {
-        if let Ok(header) = MachHeader64::parse(data, 0) {
+    pub(super) fn print_macho64(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
+        if let Ok(header) = MachHeader64::parse(data, offset) {
             println!("Format: Mach-O 64-bit");
-            print_macho(p, header, data);
+            print_macho(p, header, data, offset);
         }
     }
 
@@ -3244,11 +3338,12 @@ mod macho {
         p: &mut Printer<impl Write>,
         header: &Mach,
         data: &[u8],
+        offset: u64,
     ) {
         if let Ok(endian) = header.endian() {
             let mut state = MachState::default();
             print_mach_header(p, endian, header);
-            if let Ok(mut commands) = header.load_commands(endian, data, 0) {
+            if let Ok(mut commands) = header.load_commands(endian, data, offset) {
                 while let Ok(Some(command)) = commands.next() {
                     print_load_command(p, endian, data, header, command, &mut state);
                 }