use std::{
borrow::Cow,
fs, io,
ops::Range,
path::{Path, PathBuf},
};
use rustc_hash::FxHashMap;
use crate::{
elf::{
ObjectFile,
constants::{SHN_UNDEF, STB_LOCAL},
},
error::{Error, Result},
input::AlignedBytes,
};
const ARCHIVE_MAGIC: &[u8] = b"!<arch>\n";
const THIN_MAGIC: &[u8] = b"!<thin>\n";
const HEADER_SIZE: usize = 60;
const NAME_FIELD: usize = 16;
pub struct Archive<'data> {
bytes: &'data [u8],
index: FxHashMap<Cow<'data, [u8]>, u64>,
thin: bool,
dir: PathBuf,
long_names: Option<Range<usize>>,
pos: u32,
}
struct MemberHeader {
data_offset: usize,
size: usize,
next: usize,
kind: MemberKind,
}
#[derive(Clone, Copy)]
enum MemberKind {
SymIndex(bool),
LongNames,
Regular,
}
impl<'data> Archive<'data> {
pub fn is_archive(bytes: &[u8]) -> bool {
bytes.starts_with(ARCHIVE_MAGIC) || bytes.starts_with(THIN_MAGIC)
}
pub fn parse(bytes: &'data [u8], from: &Path) -> Result<Self> {
let thin = bytes.starts_with(THIN_MAGIC);
if !Self::is_archive(bytes) {
return Err(Error::Format("not an ar archive"));
}
let dir = from.parent().unwrap_or_else(|| Path::new("")).to_path_buf();
let mut index = FxHashMap::default();
let mut long_names = None;
let mut pos = ARCHIVE_MAGIC.len();
let mut indexed = false;
while let Some(hdr) = read_header(bytes, pos, thin)? {
match hdr.kind {
MemberKind::SymIndex(sym64) => {
parse_index(
bytes,
hdr.data_offset,
hdr.size,
sym64,
&mut index,
)?;
indexed = true;
}
MemberKind::LongNames => {
long_names =
Some(hdr.data_offset..hdr.data_offset + hdr.size);
}
MemberKind::Regular => {}
}
pos = hdr.next;
}
if !indexed && !thin {
scan_members(bytes, &mut index)?;
}
Ok(Self {
bytes,
index,
thin,
dir,
long_names,
pos: u32::MAX,
})
}
pub fn lookup(&self, name: &[u8]) -> Option<u64> {
self.index.get(name).copied()
}
pub const fn pos(&self) -> u32 {
self.pos
}
pub fn set_pos(&mut self, pos: u32) {
self.pos = pos;
}
pub fn member(&self, header_offset: u64) -> Result<Cow<'data, [u8]>> {
if !self.thin {
let pos = to_usize(header_offset, "archive member offset")?;
let hdr = read_header(self.bytes, pos, false)?
.ok_or(Error::Format("archive member header missing"))?;
return member_data(self.bytes, &hdr).map(Cow::Borrowed);
}
let path = self.member_path(header_offset)?;
fs::read(&path).map(Cow::Owned).map_err(|err| {
Error::Io(io::Error::new(
err.kind(),
format!("{}: {err}", path.display()),
))
})
}
pub fn member_name(&self, header_offset: u64) -> Result<String> {
if !self.thin {
let field = self.name_field(header_offset)?;
return Ok(short_name(field).map_or_else(String::new, |name| {
String::from_utf8_lossy(name).into_owned()
}));
}
self.member_path(header_offset)
.map(|path| path.display().to_string())
}
fn member_path(&self, header_offset: u64) -> Result<PathBuf> {
let field = self.name_field(header_offset)?;
let name = match long_name_offset(field) {
Some(at) => self.long_name(at)?,
None => short_name(field)
.ok_or(Error::Format("archive member name missing"))?,
};
let path = path_from_bytes(name);
if path.is_absolute() {
return Ok(path);
}
Ok(self.dir.join(path))
}
fn name_field(&self, header_offset: u64) -> Result<&[u8]> {
let pos = to_usize(header_offset, "archive member offset")?;
let end = pos
.checked_add(NAME_FIELD)
.ok_or(Error::OutOfRange("archive member offset"))?;
self.bytes
.get(pos..end)
.ok_or(Error::OutOfRange("archive member name"))
}
fn long_name(&self, at: usize) -> Result<&[u8]> {
let table = self
.long_names
.as_ref()
.ok_or(Error::Format("archive long names missing"))?;
let start = table
.start
.checked_add(at)
.ok_or(Error::OutOfRange("archive long name offset"))?;
let rest = self
.bytes
.get(start..table.end)
.ok_or(Error::OutOfRange("archive long name offset"))?;
let end = rest.iter().position(|&b| b == b'\n').unwrap_or(rest.len());
let name = &rest[..end];
Ok(name.strip_suffix(b"/").unwrap_or(name))
}
}
pub fn members(bytes: &[u8]) -> Result<Vec<&[u8]>> {
if bytes.starts_with(THIN_MAGIC) {
return Err(Error::Format(
"thin archives are not supported by the Mach-O linker",
));
}
if !bytes.starts_with(ARCHIVE_MAGIC) {
return Err(Error::Format("not an ar archive"));
}
let mut out = Vec::new();
let mut pos = ARCHIVE_MAGIC.len();
while let Some(hdr) = read_header(bytes, pos, false)? {
if matches!(hdr.kind, MemberKind::Regular) {
let field = bytes
.get(pos..pos + NAME_FIELD)
.ok_or(Error::OutOfRange("archive member name"))?;
let data = member_data(bytes, &hdr)?;
let (name, payload) = bsd_member(field, data)?;
let metadata = name.is_some_and(|name| {
name.starts_with(b"__.SYMDEF")
|| name == b"lib.rmeta"
|| name == b"lib.rmeta-link"
});
if !metadata {
out.push(payload);
}
}
pos = hdr.next;
}
Ok(out)
}
fn bsd_member<'a>(
field: &'a [u8],
data: &'a [u8],
) -> Result<(Option<&'a [u8]>, &'a [u8])> {
let raw = trim_blank(field);
let Some(digits) = raw.strip_prefix(b"#1/") else {
return Ok((short_name(field), data));
};
let name_len = std::str::from_utf8(digits)
.ok()
.and_then(|n| n.parse::<usize>().ok())
.ok_or(Error::Format("BSD archive member name length"))?;
let name = data
.get(..name_len)
.ok_or(Error::OutOfRange("BSD archive member name"))?;
let payload = data
.get(name_len..)
.ok_or(Error::OutOfRange("BSD archive member data"))?;
let end = name.iter().position(|&b| b == 0).unwrap_or(name.len());
Ok((Some(&name[..end]), payload))
}
fn scan_members(
bytes: &[u8],
index: &mut FxHashMap<Cow<'_, [u8]>, u64>,
) -> Result<()> {
let mut pos = ARCHIVE_MAGIC.len();
while let Some(hdr) = read_header(bytes, pos, false)? {
if matches!(hdr.kind, MemberKind::Regular) {
let data = member_data(bytes, &hdr)?;
let offset = u64::try_from(pos)
.map_err(|_| Error::OutOfRange("archive member offset"))?;
let owned = AlignedBytes::new(data);
if let Ok(obj) = ObjectFile::parse(owned.bytes())
&& let Ok(Some(symtab)) = obj.symbol_table()
{
for sym in symtab.iter() {
if sym.bind() == STB_LOCAL
|| sym.st_shndx.get() == SHN_UNDEF
{
continue;
}
let name = crate::symbol::version_stem(symtab.name(sym));
if !name.is_empty() {
index
.entry(Cow::Owned(name.to_vec()))
.or_insert(offset);
}
}
}
}
pos = hdr.next;
}
Ok(())
}
fn member_data<'a>(bytes: &'a [u8], hdr: &MemberHeader) -> Result<&'a [u8]> {
let end = hdr
.data_offset
.checked_add(hdr.size)
.ok_or(Error::OutOfRange("archive member data"))?;
bytes
.get(hdr.data_offset..end)
.ok_or(Error::OutOfRange("archive member data"))
}
fn read_header(
bytes: &[u8],
pos: usize,
thin: bool,
) -> Result<Option<MemberHeader>> {
let header_end = pos
.checked_add(HEADER_SIZE)
.ok_or(Error::OutOfRange("archive header offset"))?;
if header_end > bytes.len() {
return Ok(None);
}
let name_field = &bytes[pos..pos + 16];
let size = parse_decimal(&bytes[pos + 48..pos + 58])?;
let data_offset = header_end;
let kind = classify(name_field);
let next = if thin && matches!(kind, MemberKind::Regular) {
align_even(data_offset)
} else {
let data_end = data_offset
.checked_add(size)
.ok_or(Error::OutOfRange("archive member size"))?;
if data_end > bytes.len() {
return Err(Error::OutOfRange("archive member data"));
}
align_even(data_end)
};
Ok(Some(MemberHeader {
data_offset,
size,
next,
kind,
}))
}
fn short_name(field: &[u8]) -> Option<&[u8]> {
let end = field
.iter()
.position(|&b| b == b'/' || b == b' ')
.unwrap_or(field.len());
let name = &field[..end];
(!name.is_empty()).then_some(name)
}
fn long_name_offset(field: &[u8]) -> Option<usize> {
let digits = field.strip_prefix(b"/")?;
let digits = trim_blank(digits);
if digits.is_empty() || !digits.iter().all(u8::is_ascii_digit) {
return None;
}
std::str::from_utf8(digits).ok()?.parse().ok()
}
fn path_from_bytes(name: &[u8]) -> PathBuf {
use std::os::unix::ffi::OsStringExt;
PathBuf::from(std::ffi::OsString::from_vec(name.to_vec()))
}
fn parse_index<'a>(
bytes: &'a [u8],
data_offset: usize,
size: usize,
sym64: bool,
index: &mut FxHashMap<Cow<'a, [u8]>, u64>,
) -> Result<()> {
let end = data_offset
.checked_add(size)
.ok_or(Error::OutOfRange("archive index data"))?;
let data = bytes
.get(data_offset..end)
.ok_or(Error::OutOfRange("archive index data"))?;
let (cnt_size, off_size) = if sym64 { (8, 8) } else { (4, 4) };
let count =
to_usize(read_uint_be(data, 0, cnt_size)?, "archive index count")?;
let offsets_start = cnt_size;
let table_size = count
.checked_mul(off_size)
.ok_or(Error::OutOfRange("archive index table"))?;
let mut name_pos = offsets_start
.checked_add(table_size)
.ok_or(Error::OutOfRange("archive index table"))?;
let least = name_pos
.checked_add(count)
.ok_or(Error::OutOfRange("archive index table"))?;
if least > data.len() {
return Err(Error::Format("archive index count exceeds member size"));
}
for i in 0..count {
let rest = data.get(name_pos..).unwrap_or(&[]);
let name = cstr_slice(rest);
name_pos = name_pos
.checked_add(name.len())
.and_then(|p| p.checked_add(1))
.ok_or(Error::OutOfRange("archive index name"))?;
let off_pos = i
.checked_mul(off_size)
.and_then(|p| p.checked_add(offsets_start))
.ok_or(Error::OutOfRange("archive index offset"))?;
let offset = read_uint_be(data, off_pos, off_size)?;
let key = crate::symbol::version_stem(name);
index.entry(Cow::Borrowed(key)).or_insert(offset);
}
Ok(())
}
fn classify(raw: &[u8]) -> MemberKind {
let end = raw.iter().position(|&b| b == b' ').unwrap_or(raw.len());
match &raw[..end] {
b"/" => MemberKind::SymIndex(false),
b"//" => MemberKind::LongNames,
b"/SYM64/" => MemberKind::SymIndex(true),
_ => MemberKind::Regular,
}
}
fn trim_blank(field: &[u8]) -> &[u8] {
let end = field.iter().position(|&b| b == b' ').unwrap_or(field.len());
&field[..end]
}
#[allow(clippy::arithmetic_side_effects)]
fn align_even(n: usize) -> usize {
(n + 1) & !1
}
fn parse_decimal(field: &[u8]) -> Result<usize> {
let mut n = 0usize;
for &c in field {
if c == b' ' {
continue;
}
if !c.is_ascii_digit() {
return Err(Error::Format("archive member size"));
}
n = n
.checked_mul(10)
.ok_or(Error::OutOfRange("archive member size"))?
.checked_add(usize::from(c - b'0'))
.ok_or(Error::OutOfRange("archive member size"))?;
}
Ok(n)
}
fn read_uint_be(data: &[u8], pos: usize, size: usize) -> Result<u64> {
let bytes = data
.get(pos..pos + size)
.ok_or(Error::OutOfRange("archive integer"))?;
let mut v = 0u64;
for &b in bytes {
v = v
.checked_shl(8)
.ok_or(Error::OutOfRange("archive integer"))?
| u64::from(b);
}
Ok(v)
}
fn cstr_slice(data: &[u8]) -> &[u8] {
let end = data.iter().position(|&b| b == 0).unwrap_or(data.len());
&data[..end]
}
fn to_usize(value: u64, what: &'static str) -> Result<usize> {
usize::try_from(value).map_err(|_| Error::OutOfRange(what))
}