Method load

src/android_library.rs:230–442

(path: &str)

    const MAX_PAGE_SIZE: usize = 65536;

    pub fn load<'a>(path: &str) -> Result<AndroidLibrary<'a>> {
        let file = Box::new(fs::read(path)?);
        let file_leak_ptr = Box::into_raw(file);
        let file_leak = unsafe { file_leak_ptr.as_ref().unwrap() };
        let elf_file = ElfFile::new(&file_leak).map_err(|err| AndroidLoaderErr::ElfParsingError(err.to_string()))?;

        let mut minimum = usize::MAX;
        let mut maximum = usize::MIN;

        let mut is_incompatible = false;
        let mut offset = 0;
        let mut overall_protection = Protection::NONE;

        for header in elf_file.program_iter() {
            if header.get_type() == Ok(Type::Load) {
                let flags = header.flags();

                let start = region::page::floor(header.virtual_addr() as *const ()) as usize;
                let end = region::page::ceil(
                    (header.virtual_addr() as usize + header.mem_size() as usize)
                        as *const (),
                ) as usize;

                if offset == 0 {
                    let mut prot = Protection::NONE.bits();
                    if flags.is_read() {
                        prot |= Protection::READ.bits();
                    }
                    if flags.is_write() {
                        prot |= Protection::WRITE.bits();
                    }
                    if flags.is_execute() {
                        prot |= Protection::EXECUTE.bits();
                    }
                    overall_protection |= Protection::from_bits_truncate(prot);
                    if overall_protection == Protection::READ_WRITE_EXECUTE {
                        offset = page::ceil(start as *const ()) as usize - start;
                    }
                }

                if !is_incompatible && page::ceil(maximum as *const ()) as usize > start {
                    is_incompatible = true;
                    warn!("library has not been made for this CPU. It may crash!");
                }

                if start < minimum {
                    minimum = start;
                }

                if end > maximum {
                    maximum = end;
                }
            }
        }

        let alloc_start = region::page::floor(minimum as *const ()) as usize;
        let alloc_end = region::page::ceil(maximum as *const ()) as usize;