fix(format): list soft links as their targets, like h5py
Group::datasets()/groups() (and the Mmap/Lazy handles) listed only hard links, so a soft link to a dataset or group was missing, and dataset(name) / group(name) on a group handle could not open one. In old-style (symbol table) groups a soft link's entry has no object header address, and the listing failed outright trying to parse one. The three facade handles each had their own copy of the child-listing code; they now share group_v2::resolve_group_children, which returns hard links plus soft links resolved to their targets (relative targets from the group holding the link, via the new resolve_path_from). A dangling or cyclic soft link, an external link and a user-defined link are left out — h5py lists their names but cannot open them. Any other error met while resolving is returned, not hidden. Path resolution now walks a relative soft link's target from the group holding it instead of rebuilding the path from the root (same result, one less re-walk), and ignores "." components. Regression test: soft_links_are_listed_as_their_targets (h5py writes absolute, relative, group, dangling, cyclic and external links with libver latest and earliest; listings compared with h5py for File, MmapFile and LazyFile). Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
This commit is contained in:
osobh
@@ -255,32 +255,135 @@ pub fn resolve_path_any(
|
||||
superblock: &Superblock,
|
||||
path: &str,
|
||||
) -> Result<u64, FormatError> {
|
||||
resolve_path_following_links(file_data, superblock, path, 0)
|
||||
resolve_path_following_links(
|
||||
file_data,
|
||||
superblock,
|
||||
superblock.root_group_address,
|
||||
path,
|
||||
0,
|
||||
)
|
||||
}
|
||||
|
||||
/// Resolve `path` relative to the group at `group_address` (an absolute path
|
||||
/// starts at the root group instead), following soft links. This is how a
|
||||
/// relative soft link's target is resolved: from the group holding the link.
|
||||
pub fn resolve_path_from(
|
||||
file_data: &[u8],
|
||||
superblock: &Superblock,
|
||||
group_address: u64,
|
||||
path: &str,
|
||||
) -> Result<u64, FormatError> {
|
||||
let start = if path.starts_with('/') {
|
||||
superblock.root_group_address
|
||||
} else {
|
||||
group_address
|
||||
};
|
||||
resolve_path_following_links(file_data, superblock, start, path, 0)
|
||||
}
|
||||
|
||||
/// The children of the group at `group_address` that can be opened, as h5py
|
||||
/// lists them: hard links, and soft links resolved to the object they point
|
||||
/// at (under the soft link's own name). Links that cannot be followed are
|
||||
/// left out rather than failing the listing — a dangling or cyclic soft link
|
||||
/// (h5py lists its name but cannot open it), an external link (another
|
||||
/// file), and a user-defined link. An object header that is not a group has
|
||||
/// no children.
|
||||
///
|
||||
/// Any other error, such as a corrupt structure met while resolving a soft
|
||||
/// link, is returned.
|
||||
pub fn resolve_group_children(
|
||||
file_data: &[u8],
|
||||
superblock: &Superblock,
|
||||
group_address: u64,
|
||||
) -> Result<Vec<GroupEntry>, FormatError> {
|
||||
let os = superblock.offset_size;
|
||||
let ls = superblock.length_size;
|
||||
let header = ObjectHeader::parse(file_data, group_address as usize, os, ls)?;
|
||||
|
||||
let mut entries = Vec::new();
|
||||
let mut soft = Vec::new();
|
||||
if is_v1_group(&header) {
|
||||
let sym_msg = header
|
||||
.messages
|
||||
.iter()
|
||||
.find(|m| m.msg_type == MessageType::SymbolTable)
|
||||
.ok_or_else(|| FormatError::PathNotFound(String::from("no symbol table message")))?;
|
||||
let stm = SymbolTableMessage::parse(&sym_msg.data, os)?;
|
||||
let all = group_v1::resolve_v1_group_entries(file_data, &stm, os, ls)?;
|
||||
if all.iter().any(group_v1::is_v1_soft_link) {
|
||||
soft = group_v1::v1_soft_links(file_data, &stm, os, ls)?;
|
||||
}
|
||||
entries.extend(all.into_iter().filter(|e| !group_v1::is_v1_soft_link(e)));
|
||||
} else if is_v2_group(&header) {
|
||||
let mut visit = |link: LinkMessage| match link.link_target {
|
||||
LinkTarget::Hard {
|
||||
object_header_address,
|
||||
} => entries.push(GroupEntry {
|
||||
name: link.name,
|
||||
object_header_address,
|
||||
cache_type: 0,
|
||||
}),
|
||||
LinkTarget::Soft { target_path } => soft.push((link.name, target_path)),
|
||||
LinkTarget::External { .. } => {}
|
||||
};
|
||||
let link_info = find_link_info(&header, os)?;
|
||||
if let Some(fh_addr) = link_info.fractal_heap_address {
|
||||
for_each_dense_link(file_data, &link_info, fh_addr, os, ls, visit)?;
|
||||
} else {
|
||||
for msg in &header.messages {
|
||||
if msg.msg_type == MessageType::Link
|
||||
&& let Some(link) = parse_link(&msg.data, os)?
|
||||
{
|
||||
visit(link);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (name, target) in soft {
|
||||
match resolve_path_from(file_data, superblock, group_address, &target) {
|
||||
Ok(object_header_address) => entries.push(GroupEntry {
|
||||
name,
|
||||
object_header_address,
|
||||
cache_type: 0,
|
||||
}),
|
||||
// Dangling, cyclic, or ending in another file: not openable here.
|
||||
Err(
|
||||
FormatError::PathNotFound(_)
|
||||
| FormatError::NestingDepthExceeded
|
||||
| FormatError::ExternalLinkUnsupported { .. },
|
||||
) => {}
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
}
|
||||
Ok(entries)
|
||||
}
|
||||
|
||||
/// Soft links followed while resolving one path. Guards against link cycles
|
||||
/// (`a -> b -> a`), which are legal to create.
|
||||
const MAX_SOFT_LINK_DEPTH: u8 = 16;
|
||||
|
||||
/// Walk `path` from the group at `start`, following soft links.
|
||||
fn resolve_path_following_links(
|
||||
file_data: &[u8],
|
||||
superblock: &Superblock,
|
||||
start: u64,
|
||||
path: &str,
|
||||
depth: u8,
|
||||
) -> Result<u64, FormatError> {
|
||||
let components: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
|
||||
let components: Vec<&str> = path
|
||||
.split('/')
|
||||
.filter(|s| !s.is_empty() && *s != ".")
|
||||
.collect();
|
||||
if components.is_empty() {
|
||||
return Ok(superblock.root_group_address);
|
||||
return Ok(start);
|
||||
}
|
||||
|
||||
let os = superblock.offset_size;
|
||||
let ls = superblock.length_size;
|
||||
|
||||
let root_header =
|
||||
ObjectHeader::parse(file_data, superblock.root_group_address as usize, os, ls)?;
|
||||
|
||||
let mut current_addr = superblock.root_group_address;
|
||||
let mut current_header = root_header;
|
||||
let mut current_addr = start;
|
||||
let mut current_header = ObjectHeader::parse(file_data, start as usize, os, ls)?;
|
||||
|
||||
for (i, component) in components.iter().enumerate() {
|
||||
let entries = resolve_group_entries(file_data, ¤t_header, os, ls)?;
|
||||
@@ -304,20 +407,17 @@ fn resolve_path_following_links(
|
||||
}
|
||||
// A relative target is relative to the group holding
|
||||
// the link; then the rest of the original path.
|
||||
let mut full = String::new();
|
||||
if !target_path.starts_with('/') {
|
||||
for parent in &components[..i] {
|
||||
full.push('/');
|
||||
full.push_str(parent);
|
||||
}
|
||||
}
|
||||
full.push('/');
|
||||
full.push_str(&target_path);
|
||||
let from = if target_path.starts_with('/') {
|
||||
superblock.root_group_address
|
||||
} else {
|
||||
current_addr
|
||||
};
|
||||
let mut full = target_path;
|
||||
for rest in &components[i + 1..] {
|
||||
full.push('/');
|
||||
full.push_str(rest);
|
||||
}
|
||||
resolve_path_following_links(file_data, superblock, &full, depth + 1)
|
||||
resolve_path_following_links(file_data, superblock, from, &full, depth + 1)
|
||||
}
|
||||
Some(LinkTarget::External {
|
||||
filename,
|
||||
|
||||
Reference in New Issue
Block a user