Add unified flags (SegmentFlags) for ObjectSegment

crates/examples/src/bin/segments.rs

@@ -0,0 +1,61 @@
+use object::{
+    Object, ObjectSegment, SEGMENT_RWE_FLAG_EXECUTE, SEGMENT_RWE_FLAG_READ, SEGMENT_RWE_FLAG_WRITE,
+};
+use std::{env, fs, process};
+
+fn main() {
+    let mut args = env::args().skip(1);
+    if args.len() < 1 {
+        eprintln!("Usage: {} <object file path>", env::args().next().unwrap());
+        process::exit(1);
+    }
+
+    let file_path = args.next().unwrap();
+
+    let file = match fs::File::open(&file_path) {
+        Ok(file) => file,
+        Err(err) => {
+            println!("Failed to open file '{}': {}", file_path, err,);
+            return;
+        }
+    };
+    let file = match unsafe { memmap2::Mmap::map(&file) } {
+        Ok(mmap) => mmap,
+        Err(err) => {
+            println!("Failed to map file '{}': {}", file_path, err,);
+            return;
+        }
+    };
+
+    match object::File::parse(&*file) {
+        Ok(object) => print_segments(&object),
+        Err(err) => {
+            println!("Failed to parse file segments '{}': {}", file_path, err,);
+            return;
+        }
+    };
+}
+
+fn print_segments(object: &object::File) {
+    for segment in object.segments() {
+        println!("-------------------------");
+        println!(
+            "name = {}",
+            segment.name().unwrap_or_default().unwrap_or_default()
+        );
+        println!("address = 0x{:016x}", segment.address());
+        println!("size = {}", segment.size());
+        println!("file range = {:?}", segment.file_range());
+        let rwe_flag = segment.rwe_flags();
+        println!("rwe flags = {}", rwe_flag);
+        if rwe_flag & SEGMENT_RWE_FLAG_READ > 0 {
+            println!("    - Read");
+        }
+        if rwe_flag & SEGMENT_RWE_FLAG_WRITE > 0 {
+            println!("    - Write");
+        }
+        if rwe_flag & SEGMENT_RWE_FLAG_EXECUTE > 0 {
+            println!("    - Execute");
+        }
+    }
+}

src/common.rs

@@ -415,3 +415,10 @@ pub enum SymbolFlags<Section> {
         associative_section: Option<Section>,
     },
 }
+
+/// Unified segment rwe_flag of read permission
+pub const SEGMENT_RWE_FLAG_READ: u32 = 0x01;
+/// Unified segment rwe_flag of write permission
+pub const SEGMENT_RWE_FLAG_WRITE: u32 = 0x02;
+/// Unified segment rwe_flag of execute permission
+pub const SEGMENT_RWE_FLAG_EXECUTE: u32 = 0x04;

src/read/any.rs

@@ -563,6 +563,10 @@ impl<'data, 'file, R: ReadRef<'data>> ObjectSegment<'data> for Segment<'data, 'f
     fn name(&self) -> Result<Option<&str>> {
         with_inner!(self.inner, SegmentInternal, |x| x.name())
     }
+
+    fn rwe_flags(&self) -> u32 {
+        with_inner!(self.inner, SegmentInternal, |x| x.rwe_flags())
+    }
 }
 
 /// An iterator of the sections of a `File`.

src/read/coff/section.rs

@@ -8,6 +8,7 @@ use crate::read::{
     self, CompressedData, CompressedFileRange, Error, ObjectSection, ObjectSegment, ReadError,
     ReadRef, Result, SectionFlags, SectionIndex, SectionKind,
 };
+use crate::{SEGMENT_RWE_FLAG_EXECUTE, SEGMENT_RWE_FLAG_READ, SEGMENT_RWE_FLAG_WRITE};
 
 use super::{CoffFile, CoffRelocationIterator};
 
@@ -189,6 +190,22 @@ impl<'data, 'file, R: ReadRef<'data>> ObjectSegment<'data> for CoffSegment<'data
             .read_error("Non UTF-8 COFF section name")
             .map(Some)
     }
+
+    #[inline]
+    fn rwe_flags(&self) -> u32 {
+        let value = self.section.characteristics.get(LE);
+        let mut flag = 0;
+        if value & pe::IMAGE_SCN_MEM_READ > 0 {
+            flag |= SEGMENT_RWE_FLAG_READ;
+        }
+        if value & pe::IMAGE_SCN_MEM_WRITE > 0 {
+            flag |= SEGMENT_RWE_FLAG_WRITE
+        }
+        if value & pe::IMAGE_SCN_MEM_EXECUTE > 0 {
+            flag |= SEGMENT_RWE_FLAG_EXECUTE;
+        }
+        flag
+    }
 }
 
 /// An iterator over the sections of a `CoffFile`.

src/read/elf/segment.rs

@@ -5,6 +5,7 @@ use crate::elf;
 use crate::endian::{self, Endianness};
 use crate::pod::Pod;
 use crate::read::{self, Bytes, ObjectSegment, ReadError, ReadRef};
+use crate::{SEGMENT_RWE_FLAG_EXECUTE, SEGMENT_RWE_FLAG_READ, SEGMENT_RWE_FLAG_WRITE};
 
 use super::{ElfFile, FileHeader, NoteIterator};
 
@@ -128,6 +129,22 @@ where
     fn name(&self) -> read::Result<Option<&str>> {
         Ok(None)
     }
+
+    #[inline]
+    fn rwe_flags(&self) -> u32 {
+        let value = self.segment.p_flags(self.file.endian);
+        let mut flag = 0;
+        if value & elf::PF_R > 0 {
+            flag |= SEGMENT_RWE_FLAG_READ;
+        }
+        if value & elf::PF_W > 0 {
+            flag |= SEGMENT_RWE_FLAG_WRITE
+        }
+        if value & elf::PF_X > 0 {
+            flag |= SEGMENT_RWE_FLAG_EXECUTE;
+        }
+        flag
+    }
 }
 
 /// A trait for generic access to `ProgramHeader32` and `ProgramHeader64`.

src/read/macho/segment.rs

@@ -5,6 +5,7 @@ use crate::endian::{self, Endianness};
 use crate::macho;
 use crate::pod::Pod;
 use crate::read::{self, ObjectSegment, ReadError, ReadRef, Result};
+use crate::{SEGMENT_RWE_FLAG_EXECUTE, SEGMENT_RWE_FLAG_READ, SEGMENT_RWE_FLAG_WRITE};
 
 use super::{LoadCommandData, MachHeader, MachOFile, Section};
 
@@ -133,6 +134,22 @@ where
                 .read_error("Non UTF-8 Mach-O segment name")?,
         ))
     }
+
+    #[inline]
+    fn rwe_flags(&self) -> u32 {
+        let value = self.internal.segment.initprot(self.file.endian);
+        let mut flag = 0;
+        if value & macho::VM_PROT_READ > 0 {
+            flag |= SEGMENT_RWE_FLAG_READ;
+        }
+        if value & macho::VM_PROT_WRITE > 0 {
+            flag |= SEGMENT_RWE_FLAG_WRITE
+        }
+        if value & macho::VM_PROT_EXECUTE > 0 {
+            flag |= SEGMENT_RWE_FLAG_EXECUTE;
+        }
+        flag
+    }
 }
 
 #[derive(Debug, Clone, Copy)]

src/read/pe/section.rs

@@ -7,6 +7,7 @@ use crate::read::{
     self, CompressedData, CompressedFileRange, ObjectSection, ObjectSegment, ReadError, ReadRef,
     Relocation, Result, SectionFlags, SectionIndex, SectionKind,
 };
+use crate::{SEGMENT_RWE_FLAG_EXECUTE, SEGMENT_RWE_FLAG_READ, SEGMENT_RWE_FLAG_WRITE};
 
 use super::{ImageNtHeaders, PeFile, SectionTable};
 
@@ -123,6 +124,22 @@ where
                 .read_error("Non UTF-8 PE section name")?,
         ))
     }
+
+    #[inline]
+    fn rwe_flags(&self) -> u32 {
+        let value = self.section.characteristics.get(LE);
+        let mut flag = 0;
+        if value & pe::IMAGE_SCN_MEM_READ > 0 {
+            flag |= SEGMENT_RWE_FLAG_READ;
+        }
+        if value & pe::IMAGE_SCN_MEM_WRITE > 0 {
+            flag |= SEGMENT_RWE_FLAG_WRITE
+        }
+        if value & pe::IMAGE_SCN_MEM_EXECUTE > 0 {
+            flag |= SEGMENT_RWE_FLAG_EXECUTE;
+        }
+        flag
+    }
 }
 
 /// An iterator over the sections of a `PeFile32`.

src/read/traits.rs

@@ -261,6 +261,13 @@ pub trait ObjectSegment<'data>: read::private::Sealed {
     ///
     /// Returns an error if the name is not UTF-8.
     fn name(&self) -> Result<Option<&str>>;
+
+    /// Return read/write/execute flag of segment.
+    ///
+    /// Returns 0 if none of r/w/e flags exist.
+    /// Otherwise returns value of
+    /// SEGMENT_RWE_FLAG_READ | SEGMENT_RWE_FLAG_WRITE | SEGMENT_RWE_FLAG_EXECUTE
+    fn rwe_flags(&self) -> u32;
 }
 
 /// A section defined in an object file.