use std::path::Path;
use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
elf::{
ObjectFile, Sym64, SymbolTable, VersionTable,
constants::{
DT_NULL, DT_SONAME, SHN_ABS, SHN_UNDEF, SHT_DYNAMIC, STT_TLS,
VER_NDX_HIDDEN,
},
},
util::PAGE,
};
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct DepAddr {
pub dep: u32,
pub value: u64,
}
#[derive(Clone, Copy)]
pub struct DynExport {
pub size: u64,
pub sym_type: u8,
pub visibility: u8,
pub align: u64,
pub at: DepAddr,
pub placed: bool,
pub storage: bool,
}
#[derive(Default)]
pub struct DepExports<'data> {
by_name: FxHashMap<&'data [u8], DynExport>,
aliases: FxHashMap<DepAddr, Vec<&'data [u8]>>,
}
impl<'data> DepExports<'data> {
pub fn get(&self, name: &[u8]) -> Option<DynExport> {
self.by_name.get(name).copied()
}
pub fn contains(&self, name: &[u8]) -> bool {
self.by_name.contains_key(name)
}
pub fn aliases_at(&self, at: DepAddr) -> Option<&[&'data [u8]]> {
self.aliases.get(&at).map(Vec::as_slice)
}
fn insert(&mut self, name: &'data [u8], exp: DynExport) {
self.by_name.entry(name).or_insert(exp);
}
fn add_alias(&mut self, at: DepAddr, name: &'data [u8]) {
let group = self.aliases.entry(at).or_default();
if group.contains(&name) {
return;
}
group.push(name);
}
fn absorb(&mut self, other: Self, dep: u32) {
for (name, mut exp) in other.by_name {
exp.at.dep = dep;
self.by_name.entry(name).or_insert(exp);
}
for (mut at, names) in other.aliases {
at.dep = dep;
self.aliases.insert(at, names);
}
}
}
#[derive(Default)]
pub struct DepUndefs<'data> {
names: FxHashSet<&'data [u8]>,
}
impl<'data> DepUndefs<'data> {
pub fn contains(&self, name: &[u8]) -> bool {
self.names.contains(name)
}
fn insert(&mut self, name: &'data [u8]) {
if !name.is_empty() {
self.names.insert(name);
}
}
fn absorb(&mut self, other: Self) {
self.names.extend(other.names);
}
}
#[derive(Clone)]
pub struct DepVersion {
pub soname: Vec<u8>,
pub name: Vec<u8>,
pub hash: u32,
}
#[derive(Default)]
pub struct DepVersions<'data> {
by_name: FxHashMap<&'data [u8], DepVersion>,
}
impl<'data> DepVersions<'data> {
pub fn get(&self, name: &[u8]) -> Option<&DepVersion> {
self.by_name.get(name)
}
fn insert(
&mut self,
name: &'data [u8],
soname: &[u8],
version: &[u8],
hash: u32,
) {
self.by_name.entry(name).or_insert_with(|| DepVersion {
soname: soname.to_vec(),
name: version.to_vec(),
hash,
});
}
fn absorb(&mut self, other: Self) {
for (name, v) in other.by_name {
self.by_name.entry(name).or_insert(v);
}
}
}
#[derive(Default)]
pub struct DepTables<'data> {
exports: DepExports<'data>,
versions: DepVersions<'data>,
undefs: DepUndefs<'data>,
}
impl<'data> DepTables<'data> {
pub fn read(bytes: &'data [u8], soname: &[u8]) -> Self {
let mut tables = Self::default();
if let Ok(obj) = ObjectFile::parse(bytes)
&& let Ok(Some(dynsym)) = obj.dynamic_symbols()
{
let rows = dynsym.syms.len();
tables.exports.by_name.reserve(rows);
tables.versions.by_name.reserve(rows);
let vt = obj.version_table().unwrap_or_default();
read_dep_exports(
&dynsym,
&vt,
&mut tables.exports,
&mut tables.undefs,
);
read_dep_versions(&dynsym, &vt, soname, &mut tables.versions);
}
tables
}
pub fn merge_into(
self,
exports: &mut DepExports<'data>,
versions: &mut DepVersions<'data>,
undefs: &mut DepUndefs<'data>,
dep: u32,
) {
exports.absorb(self.exports, dep);
versions.absorb(self.versions);
undefs.absorb(self.undefs);
}
}
fn read_dep_exports<'data>(
dynsym: &SymbolTable<'data>,
vt: &VersionTable<'_>,
out: &mut DepExports<'data>,
undefs: &mut DepUndefs<'data>,
) {
let mut defaults: FxHashSet<&'data [u8]> = FxHashSet::default();
default_defined(dynsym, vt, &mut defaults);
let mut shared: FxHashMap<u64, u32> = FxHashMap::default();
for (i, sym) in dynsym.iter().enumerate() {
let name = dynsym.name(sym);
let placed =
has_storage(sym) && sym.st_size.get() != 0 && !name.is_empty();
if placed && !superseded(vt, i, name, &defaults) {
let n = shared.entry(sym.st_value.get()).or_insert(0);
*n = n.saturating_add(1);
}
}
for (i, sym) in dynsym.iter().enumerate() {
if sym.st_shndx.get() == SHN_UNDEF {
undefs.insert(dynsym.name(sym));
continue;
}
let name = dynsym.name(sym);
if name.is_empty() || superseded(vt, i, name, &defaults) {
continue;
}
let at = DepAddr {
dep: 0,
value: sym.st_value.get(),
};
let storage = has_storage(sym);
let placed = storage && sym.st_size.get() != 0;
out.insert(
name,
DynExport {
size: sym.st_size.get(),
sym_type: sym.type_(),
visibility: sym.visibility(),
align: export_align(at.value),
at,
placed,
storage,
},
);
if placed && shared.get(&at.value).copied().unwrap_or(0) > 1 {
out.add_alias(at, name);
}
}
}
fn default_defined<'data>(
dynsym: &SymbolTable<'data>,
vt: &VersionTable<'_>,
out: &mut FxHashSet<&'data [u8]>,
) {
for (i, sym) in dynsym.iter().enumerate() {
if sym.st_shndx.get() == SHN_UNDEF
|| vt.version_of(i) & VER_NDX_HIDDEN != 0
{
continue;
}
let name = dynsym.name(sym);
if !name.is_empty() {
out.insert(name);
}
}
}
fn superseded(
vt: &VersionTable<'_>,
i: usize,
name: &[u8],
defaults: &FxHashSet<&[u8]>,
) -> bool {
vt.version_of(i) & VER_NDX_HIDDEN != 0 && defaults.contains(name)
}
fn has_storage(sym: &Sym64) -> bool {
let shndx = sym.st_shndx.get();
shndx != SHN_UNDEF && shndx != SHN_ABS && sym.type_() != STT_TLS
}
fn read_dep_versions<'data>(
dynsym: &SymbolTable<'data>,
vt: &VersionTable<'_>,
soname: &[u8],
out: &mut DepVersions<'data>,
) {
use crate::elf::constants::VER_NDX_GLOBAL;
if vt.defs.is_empty() {
return;
}
let mut by_idx: FxHashMap<u16, (&[u8], u32)> = FxHashMap::default();
for d in &vt.defs {
if let Some(name) = d.names.first() {
by_idx.insert(d.index, (*name, d.hash));
}
}
let mut hidden: Vec<(&'data [u8], u16)> = Vec::new();
for (i, sym) in dynsym.iter().enumerate() {
if sym.st_shndx.get() == SHN_UNDEF {
continue;
}
let name = dynsym.name(sym);
if name.is_empty() {
continue;
}
let raw = vt.version_of(i);
let vidx = raw & !VER_NDX_HIDDEN;
if vidx <= VER_NDX_GLOBAL {
continue;
}
if raw & VER_NDX_HIDDEN != 0 {
hidden.push((name, vidx));
continue;
}
if let Some((vname, vhash)) = by_idx.get(&vidx).copied() {
out.insert(name, soname, vname, vhash);
}
}
for (name, vidx) in hidden {
if out.get(name).is_some() {
continue;
}
if let Some((vname, vhash)) = by_idx.get(&vidx).copied() {
out.insert(name, soname, vname, vhash);
}
}
}
fn export_align(value: u64) -> u64 {
if value == 0 {
return 1;
}
let zeros = value.trailing_zeros();
let align = 1u64.checked_shl(zeros).unwrap_or(0);
align.clamp(1, PAGE)
}
pub fn shared_soname(path: &Path, bytes: &[u8], from_l: bool) -> Vec<u8> {
if let Ok(obj) = ObjectFile::parse(bytes)
&& let Some(name) = read_soname(&obj)
{
return name;
}
let named = if from_l {
path.file_name().map_or(path, Path::new)
} else {
path
};
path_bytes(named)
}
#[cfg(unix)]
fn path_bytes(path: &Path) -> Vec<u8> {
use std::os::unix::ffi::OsStrExt;
path.as_os_str().as_bytes().to_vec()
}
#[cfg(not(unix))]
fn path_bytes(path: &Path) -> Vec<u8> {
path.to_string_lossy().into_owned().into_bytes()
}
fn read_soname(obj: &ObjectFile<'_>) -> Option<Vec<u8>> {
let dyn_shdr = obj
.sections()
.iter()
.find(|s| s.sh_type.get() == SHT_DYNAMIC)?;
let dyn_bytes = obj.section_data(dyn_shdr).ok()?;
let strtab = obj.sections().get(dyn_shdr.sh_link.get() as usize)?;
let strtab_bytes = obj.section_data(strtab).ok()?;
for chunk in dyn_bytes.chunks(16) {
if chunk.len() < 16 {
break;
}
let tag = i64::from_le_bytes(chunk[..8].try_into().ok()?);
if tag == DT_NULL {
break;
}
if tag == DT_SONAME {
let val = u64::from_le_bytes(chunk[8..16].try_into().ok()?);
let off = usize::try_from(val).ok()?;
let rest = strtab_bytes.get(off..)?;
let end = rest.iter().position(|&b| b == 0).unwrap_or(rest.len());
return Some(rest.get(..end)?.to_vec());
}
}
None
}