1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// Other Unix (e.g. Linux) platforms use ELF as an object file format
// and typically implement an API called `dl_iterate_phdr` to load
// native libraries.

use super::mystd::borrow::ToOwned;
use super::mystd::env;
use super::mystd::ffi::{CStr, OsStr};
use super::mystd::os::unix::prelude::*;
use super::{Library, LibrarySegment, OsString, Vec};
use core::slice;

pub(super) fn native_libraries() -> Vec<Library> {
    let mut ret = Vec::new();
    unsafe {
        libc::dl_iterate_phdr(Some(callback), core::ptr::addr_of_mut!(ret).cast());
    }
    return ret;
}

fn infer_current_exe(base_addr: usize) -> OsString {
    cfg_if::cfg_if! {
        if #[cfg(not(target_os = "hurd"))] {
                if let Ok(entries) = super::parse_running_mmaps::parse_maps() {
                let opt_path = entries
                    .iter()
                    .find(|e| e.ip_matches(base_addr) && e.pathname().len() > 0)
                    .map(|e| e.pathname())
                    .cloned();
                if let Some(path) = opt_path {
                    return path;
                }
            }
        }
    }
    env::current_exe().map(|e| e.into()).unwrap_or_default()
}

// `info` should be a valid pointers.
// `vec` should be a valid pointer to a `std::Vec`.
unsafe extern "C" fn callback(
    info: *mut libc::dl_phdr_info,
    _size: libc::size_t,
    vec: *mut libc::c_void,
) -> libc::c_int {
    let info = &*info;
    let libs = &mut *vec.cast::<Vec<Library>>();
    let is_main_prog = info.dlpi_name.is_null() || *info.dlpi_name == 0;
    let name = if is_main_prog {
        // The man page for dl_iterate_phdr says that the first object visited by
        // callback is the main program; so the first time we encounter a
        // nameless entry, we can assume its the main program and try to infer its path.
        // After that, we cannot continue that assumption, and we use an empty string.
        if libs.is_empty() {
            infer_current_exe(info.dlpi_addr as usize)
        } else {
            OsString::new()
        }
    } else {
        let bytes = CStr::from_ptr(info.dlpi_name).to_bytes();
        OsStr::from_bytes(bytes).to_owned()
    };
    let headers = slice::from_raw_parts(info.dlpi_phdr, info.dlpi_phnum as usize);
    libs.push(Library {
        name,
        segments: headers
            .iter()
            .map(|header| LibrarySegment {
                len: (*header).p_memsz as usize,
                stated_virtual_memory_address: (*header).p_vaddr as usize,
            })
            .collect(),
        bias: info.dlpi_addr as usize,
    });
    0
}