pub use wist_artifact::digest::{parse_digest, sha256_hex_bytes};
pub use wist_artifact::naming::{
artifact_filename, content_id, is_safe_path_segment, package_id_for_sha256,
};
pub use wist_artifact::source::{
ArtifactError as PackageError, FETCH_TIMEOUT, MAX_ARTIFACT_BYTES as MAX_PACKAGE_BYTES,
read_local_source, read_source, read_source_with_client, read_source_within,
read_verified_source,
};
pub use wist_artifact::version::{normalize_version, parse_version, version_is_newer};
pub fn read_package_identity(source: &str, bytes: &[u8]) -> (String, String) {
if let Some(dir) = first_tar_entry_component(bytes) {
let identity = parse_package_name(&dir);
if !identity.0.is_empty() {
return identity;
}
}
parse_package_name(source_basename(source))
}
pub fn read_binary_package_identity(bytes: &[u8]) -> (String, String) {
let Some(dir) = first_tar_entry_component(bytes) else {
return (String::new(), String::new());
};
let (version, arch) = parse_package_name(&dir);
if version.is_empty() || arch.is_empty() {
return (String::new(), String::new());
}
(version, arch)
}
fn source_basename(source: &str) -> &str {
let without_query = source.split(['?', '#']).next().unwrap_or(source);
without_query.rsplit('/').next().unwrap_or(without_query)
}
fn first_tar_entry_component(bytes: &[u8]) -> Option<String> {
let decoder = flate2::read::GzDecoder::new(bytes);
let mut archive = tar::Archive::new(decoder);
let mut entries = archive.entries().ok()?;
let entry = entries.next()?.ok()?;
let path = entry.path().ok()?;
path.components().find_map(|component| match component {
std::path::Component::Normal(name) => name.to_str().map(str::to_string),
_ => None,
})
}
const KNOWN_TRIPLE_ARCHES: &[&str] = &[
"aarch64",
"x86_64",
"i686",
"i586",
"armv7",
"armv6",
"arm",
"riscv64",
"powerpc64",
"powerpc64le",
"s390x",
"x86_64h",
"loongarch64",
];
fn parse_package_name(name: &str) -> (String, String) {
let name = strip_archive_suffix(name);
let (version_part, arch) = match triple_start(name) {
Some(index) => (&name[..index], name[index + 1..].to_string()),
None => (name, String::new()),
};
match version_start(version_part) {
Some(index) => (version_part[index..].to_string(), arch),
None => (String::new(), String::new()),
}
}
fn triple_start(name: &str) -> Option<usize> {
for (index, _) in name.match_indices('-') {
let candidate = &name[index + 1..];
let arch_head = candidate.split('-').next().unwrap_or("");
if KNOWN_TRIPLE_ARCHES.contains(&arch_head) && version_start(&name[..index]).is_some() {
return Some(index);
}
}
None
}
fn version_start(name: &str) -> Option<usize> {
let mut offset = 0;
for segment in name.split('-') {
if looks_like_version(segment) {
return Some(offset);
}
offset += segment.len() + 1;
}
None
}
fn looks_like_version(segment: &str) -> bool {
let rest = segment.strip_prefix(['v', 'V']).unwrap_or(segment);
let mut parts = rest.split('.');
let (Some(head), Some(second)) = (parts.next(), parts.next()) else {
return false;
};
!head.is_empty()
&& head.chars().all(|ch| ch.is_ascii_digit())
&& second.chars().next().is_some_and(|ch| ch.is_ascii_digit())
}
fn strip_archive_suffix(name: &str) -> &str {
for suffix in [
".tar.gz", ".tar.bz2", ".tar.xz", ".tgz", ".tar", ".gz", ".zip", ".bin",
] {
if let Some(stripped) = name.strip_suffix(suffix) {
return stripped;
}
}
name
}
#[cfg(test)]
mod tests {
use super::*;
fn tar_gz_with_entry(entry: &str, payload: &[u8]) -> Vec<u8> {
let mut tar_bytes = Vec::new();
{
let mut builder = tar::Builder::new(&mut tar_bytes);
let mut header = tar::Header::new_gnu();
header.set_size(payload.len() as u64);
header.set_mode(0o644);
header.set_cksum();
builder
.append_data(&mut header, entry, payload)
.expect("append tar entry");
builder.finish().expect("finish tar");
}
let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
std::io::Write::write_all(&mut encoder, &tar_bytes).expect("gzip write");
encoder.finish().expect("gzip finish")
}
#[test]
fn read_package_identity_parses_binary_package_dir() {
let cases = [
(
"wist-agentd-0.1.32-aarch64-apple-darwin/wist-agentd",
("0.1.32", "aarch64-apple-darwin"),
),
(
"wist-agentd-v0.2.0-beta.1-x86_64-unknown-linux-gnu/wist-agentd",
("v0.2.0-beta.1", "x86_64-unknown-linux-gnu"),
),
(
"gops-v0.18.2-aarch64-apple-darwin/gops",
("v0.18.2", "aarch64-apple-darwin"),
),
(
"gx-v0.15.1-x86_64-unknown-linux-gnu/gx",
("v0.15.1", "x86_64-unknown-linux-gnu"),
),
];
for (entry, expected) in cases {
let bytes = tar_gz_with_entry(entry, b"bin");
assert_eq!(
read_package_identity(entry, &bytes),
(expected.0.to_string(), expected.1.to_string()),
"entry {entry}"
);
}
}
#[test]
fn read_package_identity_falls_back_to_the_source_name() {
let stack = tar_gz_with_entry("sys/sys_model.yml", b"model");
for source in [
"/opt/pkgs/wist-gateway-stack-v0.1.17.tar.gz",
"https://github.com/dayu-sec/wist/releases/download/v0.1.17/wist-gateway-stack-v0.1.17.tar.gz",
] {
assert_eq!(
read_package_identity(source, &stack),
("v0.1.17".to_string(), String::new()),
"source {source}"
);
}
assert_eq!(
read_package_identity(
"https://x/gops-v0.18.2-aarch64-apple-darwin.tar.gz?sig=1",
&stack
),
("v0.18.2".to_string(), "aarch64-apple-darwin".to_string())
);
}
#[test]
fn read_package_identity_returns_empty_for_unreadable_packages() {
let bytes = tar_gz_with_entry("sys/sys_model.yml", b"x");
for source in [
"/opt/pkgs/wist-gateway-stack-notes.tar.gz",
"/tmp/wic-rel-1728000000000000000.tar.gz",
"download-1234.bin",
] {
assert_eq!(
read_package_identity(source, &bytes),
(String::new(), String::new()),
"source {source}"
);
}
assert_eq!(
read_package_identity("/opt/pkgs/thing.tar.gz", b"not a gzip stream"),
(String::new(), String::new())
);
}
#[test]
fn binary_package_identity_requires_a_known_triple() {
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry(
"wist-agentd-1.2.3-x86_64-unknown-linux-gnu/wist-agentd",
b"bin",
)),
("1.2.3".to_string(), "x86_64-unknown-linux-gnu".to_string())
);
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry(
"wist-agentd-0.2.0-beta.1-aarch64-apple-darwin/wist-agentd",
b"bin",
)),
(
"0.2.0-beta.1".to_string(),
"aarch64-apple-darwin".to_string()
)
);
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry(
"wist-agentd-1.2.3-some-unknown-triple/wist-agentd",
b"bin",
)),
(String::new(), String::new())
);
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry(
"wist-agentd-1.2.3/wist-agentd",
b"bin"
)),
(String::new(), String::new())
);
assert_eq!(
read_binary_package_identity(&tar_gz_with_entry("sys/sys_model.yml", b"model")),
(String::new(), String::new())
);
assert_eq!(
read_binary_package_identity(b"not a gzip stream"),
(String::new(), String::new())
);
}
#[test]
fn read_package_identity_prefers_the_package_dir_over_the_source_name() {
let bytes = tar_gz_with_entry(
"wist-agentd-1.2.3-x86_64-unknown-linux-gnu/wist-agentd",
b"bin",
);
assert_eq!(
read_package_identity(
"/opt/pkgs/wist-agentd-9.9.9-aarch64-apple-darwin.tar.gz",
&bytes
),
("1.2.3".to_string(), "x86_64-unknown-linux-gnu".to_string())
);
}
#[test]
fn read_package_identity_stops_at_a_partial_dir_identity() {
let bytes = tar_gz_with_entry("gops-v0.18.2/gops", b"bin");
assert_eq!(
read_package_identity("/opt/pkgs/gops-v0.18.2-aarch64-apple-darwin.tar.gz", &bytes),
("v0.18.2".to_string(), String::new())
);
}
#[test]
fn read_package_identity_keeps_the_version_when_an_arch_word_is_only_part_of_the_name() {
let bytes = tar_gz_with_entry("sys/sys_model.yml", b"x");
for source in [
"/opt/pkgs/wist-arm-stack-1.2.3.tar.gz",
"https://x/wist-arm-stack-1.2.3.tar.gz",
] {
assert_eq!(
read_package_identity(source, &bytes),
("1.2.3".to_string(), String::new()),
"source {source}"
);
}
let bytes = tar_gz_with_entry("wist-arm-tool-1.2.3-aarch64-unknown-linux-gnu/w", b"x");
assert_eq!(
read_package_identity("/opt/pkgs/x.tar.gz", &bytes),
("1.2.3".to_string(), "aarch64-unknown-linux-gnu".to_string())
);
}
#[test]
fn read_package_identity_does_not_mistake_a_bare_number_for_a_version() {
let bytes = tar_gz_with_entry("sys/sys_model.yml", b"x");
for source in [
"/opt/pkgs/wist-stack-2024-10.tar.gz",
"/tmp/wist-stack-build1234.tar.gz",
] {
assert_eq!(
read_package_identity(source, &bytes),
(String::new(), String::new()),
"source {source}"
);
}
}
}