Struct goblin::mach::segment::Segment

pub struct Segment<'a> {
    pub cmd: u32,
    pub cmdsize: u32,
    pub segname: [u8; 16],
    pub vmaddr: u64,
    pub vmsize: u64,
    pub fileoff: u64,
    pub filesize: u64,
    pub maxprot: u32,
    pub initprot: u32,
    pub nsects: u32,
    pub flags: u32,
    pub data: &'a [u8],
    /* private fields */
}

Generalized 32/64 bit Segment Command

Fields

cmd: u32

cmdsize: u32

segname: [u8; 16]

vmaddr: u64

vmsize: u64

fileoff: u64

filesize: u64

maxprot: u32

initprot: u32

nsects: u32

flags: u32

data: &'a [u8]

Implementations

impl<'a> Segment<'a>

pub fn new(ctx: Ctx, sections: &'a [u8]) -> Self

Create a new, blank segment, with cmd either LC_SEGMENT_64, or LC_SEGMENT, depending on ctx. NB You are responsible for providing a correctly marshalled byte array as the sections. You should not use this for anything other than writing.

pub fn name(&self) -> Result<&str>

Get the name of this segment

pub fn sections(&self) -> Result<Vec<(Section, SectionData<'a>)>>

Get the sections from this segment, erroring if any section couldn’t be retrieved

pub fn from_32( bytes: &'a [u8], segment: &SegmentCommand32, offset: usize, ctx: Ctx ) -> Result<Self, Error>

Convert the raw C 32-bit segment command to a generalized version

pub fn from_32_lossy( bytes: &'a [u8], segment: &SegmentCommand32, offset: usize, ctx: Ctx ) -> Result<Self, Error>

Convert the raw C 32-bit segment command to a generalized version

pub fn from_64( bytes: &'a [u8], segment: &SegmentCommand64, offset: usize, ctx: Ctx ) -> Result<Self, Error>

Convert the raw C 64-bit segment command to a generalized version

pub fn from_64_lossy( bytes: &'a [u8], segment: &SegmentCommand64, offset: usize, ctx: Ctx ) -> Result<Self, Error>

Convert the raw C 64-bit segment command to a generalized version

Trait Implementations

impl<'a> Debug for Segment<'a>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<Segment<'a>> for SegmentCommand32

fn from(segment: Segment<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<Segment<'a>> for SegmentCommand64

fn from(segment: Segment<'a>) -> Self

Converts to this type from the input type.

impl<'a> IntoCtx<Ctx> for Segment<'a>

fn into_ctx(self, bytes: &mut [u8], ctx: Ctx)

impl<'a, 'b> IntoIterator for &'b Segment<'a>

type Item = Result<(Section, &'a [u8]), Error>

The type of the elements being iterated over.

type IntoIter = SectionIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> SizeWith<Ctx> for Segment<'a>

fn size_with(ctx: &Ctx) -> usize

impl<'a> TryIntoCtx<Ctx> for Segment<'a>

type Error = Error

fn try_into_ctx(self, bytes: &mut [u8], ctx: Ctx) -> Result<usize, Self::Error>