1#![cfg_attr(test, allow(clippy::unwrap_used, clippy::expect_used))]
19
20pub mod decmpfs;
21#[cfg(feature = "vfs")]
22pub mod vfs;
23
24pub const VOLUME_HEADER_OFFSET: usize = 1024;
26pub(crate) const SIG_HFS_PLUS: u16 = 0x482B;
28pub(crate) const SIG_HFSX: u16 = 0x4858;
30
31#[derive(Debug, Clone, Copy, PartialEq, Eq)]
33pub enum HfsKind {
34 HfsPlus,
36 Hfsx,
38}
39
40#[derive(Debug, Clone, Copy, PartialEq, Eq)]
42pub struct HfsVolume {
43 pub kind: HfsKind,
44 pub version: u16,
46 pub file_count: u32,
48 pub folder_count: u32,
50 pub block_size: u32,
52 pub total_blocks: u32,
54 pub free_blocks: u32,
56}
57
58impl HfsVolume {
59 #[must_use]
61 pub fn volume_size(&self) -> u64 {
62 u64::from(self.block_size) * u64::from(self.total_blocks)
63 }
64}
65
66#[must_use]
70pub fn parse(volume: &[u8]) -> Option<HfsVolume> {
71 let h = VOLUME_HEADER_OFFSET;
72 if volume.len() < h + 52 {
73 return None;
74 }
75 let hdr = &volume[h..];
76 let kind = match be16(&hdr[0..2]) {
77 SIG_HFS_PLUS => HfsKind::HfsPlus,
78 SIG_HFSX => HfsKind::Hfsx,
79 _ => return None,
80 };
81 Some(HfsVolume {
82 kind,
83 version: be16(&hdr[2..4]),
84 file_count: be32(&hdr[32..36]),
85 folder_count: be32(&hdr[36..40]),
86 block_size: be32(&hdr[40..44]),
87 total_blocks: be32(&hdr[44..48]),
88 free_blocks: be32(&hdr[48..52]),
89 })
90}
91
92const ROOT_FOLDER_CNID: u32 = 2;
94const RECORD_FOLDER: i16 = 1;
96const RECORD_FILE: i16 = 2;
97pub const MAX_LEAF_NODES: u32 = 65536;
99
100#[derive(Debug, Clone, PartialEq, Eq)]
102pub struct HfsEntry {
103 pub name: String,
105 pub is_dir: bool,
107 pub cnid: u32,
109}
110
111pub struct CatalogLoc {
113 pub cat_base: usize,
114 pub node_size: usize,
115 pub first_leaf: u32,
116 pub block_size: usize,
117}
118
119pub(crate) const EXTENTS_FORK_OFFSET: usize = 192;
123pub(crate) const CATALOG_FORK_OFFSET: usize = 272;
125pub(crate) const ATTRIBUTES_FORK_OFFSET: usize = 352;
129
130pub fn locate_catalog(volume: &[u8]) -> Option<CatalogLoc> {
132 locate_btree(volume, CATALOG_FORK_OFFSET)
133}
134
135pub(crate) fn locate_attributes(volume: &[u8]) -> Option<CatalogLoc> {
138 locate_btree(volume, ATTRIBUTES_FORK_OFFSET)
139}
140
141pub fn locate_extents(volume: &[u8]) -> Option<CatalogLoc> {
143 locate_btree(volume, EXTENTS_FORK_OFFSET)
144}
145
146pub(crate) fn locate_btree(volume: &[u8], fork_offset_in_header: usize) -> Option<CatalogLoc> {
150 let h = VOLUME_HEADER_OFFSET;
151 let fork = h.checked_add(fork_offset_in_header)?;
152 if volume.len() < fork + 20 {
153 return None;
154 }
155 match be16(&volume[h..h + 2]) {
156 SIG_HFS_PLUS | SIG_HFSX => {}
157 _ => return None,
158 }
159 let block_size = be32(&volume[h + 40..h + 44]) as usize;
160 if block_size == 0 {
161 return None;
162 }
163 if be32(&volume[fork + 12..fork + 16]) == 0 {
166 return None;
167 }
168 let start_block = be32(&volume[fork + 16..fork + 20]) as usize;
170 let cat_base = start_block.checked_mul(block_size)?;
171 let hdr = cat_base.checked_add(14)?;
173 if volume.len() < hdr + 20 {
174 return None;
175 }
176 let first_leaf = be32(&volume[hdr + 10..hdr + 14]);
177 let node_size = be16(&volume[hdr + 18..hdr + 20]) as usize;
178 if node_size < 14 {
179 return None;
180 }
181 Some(CatalogLoc {
182 cat_base,
183 node_size,
184 first_leaf,
185 block_size,
186 })
187}
188
189pub fn for_each_record(volume: &[u8], loc: &CatalogLoc, mut f: impl FnMut(&[u8])) {
195 let _ = walk_leaves(volume, loc, false, |rec| {
196 f(rec);
197 Ok(())
198 });
199}
200
201fn walk_leaves(
209 volume: &[u8],
210 loc: &CatalogLoc,
211 strict: bool,
212 mut f: impl FnMut(&[u8]) -> Result<(), HfsXattrError>,
213) -> Result<(), HfsXattrError> {
214 let mut node = loc.first_leaf;
215 let mut walked = 0u32;
216 while node != 0 {
217 if walked >= MAX_LEAF_NODES {
218 return Err(HfsXattrError::LeafChain {
219 node,
220 detail: format!(
221 "the fLink chain runs past {MAX_LEAF_NODES} leaf nodes, so it loops or is corrupt"
222 ),
223 });
224 }
225 walked += 1;
226 let Some(nd) = (node as usize)
227 .checked_mul(loc.node_size)
228 .and_then(|x| x.checked_add(loc.cat_base))
229 .and_then(|off| volume.get(off..off.checked_add(loc.node_size)?))
230 else {
231 return Err(HfsXattrError::LeafChain {
232 node,
233 detail: format!(
234 "node {node} ({}-byte nodes from byte {}) lies outside the {}-byte volume",
235 loc.node_size,
236 loc.cat_base,
237 volume.len()
238 ),
239 });
240 };
241 let f_link = be32(&nd[0..4]);
242 let num_records = be16(&nd[10..12]) as usize;
243 for i in 0..num_records {
244 let Some(slot) = loc.node_size.checked_sub(2 * (i + 1)) else {
246 if strict {
247 return Err(HfsXattrError::LeafChain {
248 node,
249 detail: format!(
250 "node {node} declares {num_records} records, more offsets than a {}-byte node holds",
251 loc.node_size
252 ),
253 });
254 }
255 break;
256 };
257 let rec = be16(&nd[slot..slot + 2]) as usize;
258 if rec + 8 <= loc.node_size {
259 f(&nd[rec..])?;
260 } else if strict {
261 return Err(HfsXattrError::LeafChain {
262 node,
263 detail: format!(
264 "record {i} of node {node} starts at byte {rec}, past the {}-byte node",
265 loc.node_size
266 ),
267 });
268 }
269 }
270 node = f_link;
271 }
272 Ok(())
273}
274
275#[must_use]
277pub fn list_root(volume: &[u8]) -> Option<Vec<HfsEntry>> {
278 list_dir(volume, ROOT_FOLDER_CNID)
279}
280
281#[must_use]
290pub fn list_dir(volume: &[u8], parent_cnid: u32) -> Option<Vec<HfsEntry>> {
291 let loc = locate_catalog(volume)?;
292 let mut entries = Vec::new();
293 for_each_record(volume, &loc, |rec| {
294 if let Some((parent, entry)) = record_entry(rec) {
295 if parent == parent_cnid {
296 entries.push(entry);
297 }
298 }
299 });
300 Some(entries)
301}
302
303#[must_use]
317pub fn read_file(volume: &[u8], cnid: u32) -> Option<Vec<u8>> {
318 let loc = locate_catalog(volume)?;
319 let mut forks: Option<(Fork, Fork)> = None;
320 for_each_record(volume, &loc, |rec| {
321 if forks.is_none() {
322 forks = file_forks(rec, cnid);
323 }
324 });
325 let (data_fork, resource_fork) = forks?;
326
327 if let Some(xattr) = decmpfs_xattr(volume, cnid) {
328 let resource = if resource_fork.logical > 0 {
329 fork_bytes(volume, loc.block_size, &resource_fork)
330 } else {
331 None
332 };
333 return decmpfs::decompress(&xattr, resource.as_deref()).ok();
336 }
337
338 fork_bytes(volume, loc.block_size, &data_fork)
339}
340
341#[derive(Debug, Clone, Copy, PartialEq, Eq)]
345pub struct HfsStat {
346 pub cnid: u32,
348 pub is_dir: bool,
350 pub size: u64,
352 pub created: u32,
354 pub modified: u32,
356 pub accessed: u32,
358}
359
360#[must_use]
368pub fn stat(volume: &[u8], cnid: u32) -> Option<HfsStat> {
369 let loc = locate_catalog(volume)?;
370 let mut found = None;
371 for_each_record(volume, &loc, |rec| {
372 if found.is_none() {
373 found = record_stat(rec, cnid);
374 }
375 });
376 found
377}
378
379fn record_stat(rec: &[u8], cnid: u32) -> Option<HfsStat> {
385 if rec.len() < 8 {
386 return None;
387 }
388 let key_len = be16(&rec[0..2]) as usize;
389 let data = 2 + key_len;
390 if data + 32 > rec.len() {
392 return None;
393 }
394 let is_dir = match i16::from_be_bytes([rec[data], rec[data + 1]]) {
395 RECORD_FOLDER => true,
396 RECORD_FILE => false,
397 _ => return None, };
399 if be32(&rec[data + 8..data + 12]) != cnid {
400 return None;
401 }
402 let created = be32(&rec[data + 16..data + 20]);
403 let modified = be32(&rec[data + 20..data + 24]);
404 let accessed = be32(&rec[data + 28..data + 32]);
405 let size = if is_dir {
408 0
409 } else if data + 96 <= rec.len() {
410 u64::from_be_bytes(rec[data + 88..data + 96].try_into().ok()?)
411 } else {
412 0
413 };
414 Some(HfsStat {
415 cnid,
416 is_dir,
417 size,
418 created,
419 modified,
420 accessed,
421 })
422}
423
424fn record_entry(rec: &[u8]) -> Option<(u32, HfsEntry)> {
426 if rec.len() < 8 {
427 return None;
428 }
429 let key_len = be16(&rec[0..2]) as usize;
430 let parent_id = be32(&rec[2..6]);
431 let name_len = be16(&rec[6..8]) as usize;
432 let name_end = 8 + name_len * 2;
433 if name_end > rec.len() {
434 return None;
435 }
436 let name = decode_utf16(&rec[8..name_end]);
437 let data = 2 + key_len;
438 if data + 12 > rec.len() {
439 return None;
440 }
441 let is_dir = match i16::from_be_bytes([rec[data], rec[data + 1]]) {
442 RECORD_FOLDER => true,
443 RECORD_FILE => false,
444 _ => return None, };
446 let cnid = be32(&rec[data + 8..data + 12]);
448 Some((parent_id, HfsEntry { name, is_dir, cnid }))
449}
450
451struct Fork {
453 logical: u64,
454 extents: Vec<(u32, u32)>,
455}
456
457const DECMPFS_XATTR_NAME: &str = "com.apple.decmpfs";
459const ATTR_INLINE_DATA: u32 = 0x10;
462
463fn file_forks(rec: &[u8], cnid: u32) -> Option<(Fork, Fork)> {
467 if rec.len() < 8 {
468 return None;
469 }
470 let key_len = be16(&rec[0..2]) as usize;
471 let data = 2 + key_len;
472 if data + 168 > rec.len() {
473 return None;
474 }
475 if i16::from_be_bytes([rec[data], rec[data + 1]]) != RECORD_FILE {
476 return None;
477 }
478 if be32(&rec[data + 8..data + 12]) != cnid {
479 return None;
480 }
481 let data_fork = parse_fork(&rec[data + 88..])?;
482 let resource_fork = if data + 248 <= rec.len() {
485 parse_fork(&rec[data + 168..])?
486 } else {
487 Fork {
488 logical: 0,
489 extents: Vec::new(),
490 }
491 };
492 Some((data_fork, resource_fork))
493}
494
495fn parse_fork(fork: &[u8]) -> Option<Fork> {
497 if fork.len() < 80 {
498 return None;
499 }
500 let logical = u64::from_be_bytes(fork[0..8].try_into().ok()?);
501 let mut extents = Vec::new();
502 for i in 0..8 {
503 let e = 16 + i * 8;
504 let start = be32(&fork[e..e + 4]);
505 let count = be32(&fork[e + 4..e + 8]);
506 if count != 0 {
507 extents.push((start, count));
508 }
509 }
510 Some(Fork { logical, extents })
511}
512
513fn fork_bytes(volume: &[u8], block_size: usize, fork: &Fork) -> Option<Vec<u8>> {
515 let logical = fork.logical as usize;
516 let mut data = Vec::with_capacity(logical.min(1 << 20));
517 for &(start, count) in &fork.extents {
518 if data.len() >= logical {
519 break;
520 }
521 let begin = (start as usize).checked_mul(block_size)?;
522 let len = (count as usize).checked_mul(block_size)?;
523 let end = begin.checked_add(len)?.min(volume.len());
524 if begin >= volume.len() {
525 break;
526 }
527 data.extend_from_slice(&volume[begin..end]);
528 }
529 data.truncate(logical);
530 Some(data)
531}
532
533pub fn decmpfs_xattr(volume: &[u8], cnid: u32) -> Option<Vec<u8>> {
537 let loc = locate_attributes(volume)?;
538 let mut found = None;
539 for_each_record(volume, &loc, |rec| {
540 if found.is_none() {
541 found = attr_inline_value(rec, cnid, DECMPFS_XATTR_NAME);
542 }
543 });
544 found
545}
546
547fn attr_inline_value(rec: &[u8], cnid: u32, want_name: &str) -> Option<Vec<u8>> {
552 if rec.len() < 14 {
553 return None;
554 }
555 let key_len = be16(&rec[0..2]) as usize;
556 if be32(&rec[4..8]) != cnid {
557 return None;
558 }
559 let name_len = be16(&rec[12..14]) as usize;
560 let name_end = 14usize.checked_add(name_len.checked_mul(2)?)?;
561 if name_end > rec.len() {
562 return None;
563 }
564 if decode_utf16(&rec[14..name_end]) != want_name {
565 return None;
566 }
567 let body = 2 + key_len;
568 if body + 16 > rec.len() {
569 return None;
570 }
571 if be32(&rec[body..body + 4]) != ATTR_INLINE_DATA {
572 return None;
573 }
574 let attr_size = be32(&rec[body + 12..body + 16]) as usize;
575 let end = body.checked_add(16)?.checked_add(attr_size)?;
576 if end > rec.len() {
577 return None;
578 }
579 Some(rec[body + 16..end].to_vec())
580}
581
582const ATTR_FORK_DATA: u32 = 0x20;
586
587#[derive(Debug, Clone, PartialEq, Eq)]
593pub enum HfsXattrValue {
594 Inline(Vec<u8>),
596 Fork {
599 logical: u64,
601 },
602}
603
604impl HfsXattrValue {
605 #[must_use]
607 pub fn len(&self) -> u64 {
608 match self {
609 Self::Inline(b) => b.len() as u64,
610 Self::Fork { logical } => *logical,
611 }
612 }
613
614 #[must_use]
617 pub fn is_empty(&self) -> bool {
618 self.len() == 0
619 }
620}
621
622#[derive(Debug, Clone, PartialEq, Eq)]
624pub struct HfsXattr {
625 pub name: String,
627 pub value: HfsXattrValue,
629}
630
631#[derive(Debug, Clone, PartialEq, Eq)]
637#[non_exhaustive]
638pub enum HfsXattrError {
639 AttributesBtree {
642 detail: String,
644 },
645 LeafChain {
647 node: u32,
649 detail: String,
651 },
652 Record {
654 name: Option<String>,
656 detail: String,
658 bytes: Vec<u8>,
660 },
661}
662
663impl std::fmt::Display for HfsXattrError {
664 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
665 match self {
666 Self::AttributesBtree { detail } => write!(f, "attributes B-tree unreadable: {detail}"),
667 Self::LeafChain { node, detail } => {
668 write!(
669 f,
670 "attributes B-tree leaf chain broken at node {node}: {detail}"
671 )
672 }
673 Self::Record {
674 name,
675 detail,
676 bytes,
677 } => {
678 let hex = bytes.iter().fold(String::new(), |mut s, b| {
679 let _ = std::fmt::Write::write_fmt(&mut s, format_args!("{b:02x}"));
680 s
681 });
682 match name {
683 Some(n) => write!(f, "attribute {n}: {detail} (record starts {hex})"),
684 None => write!(f, "attribute record: {detail} (record starts {hex})"),
685 }
686 }
687 }
688 }
689}
690
691impl std::error::Error for HfsXattrError {}
692
693fn record_prefix(rec: &[u8]) -> Vec<u8> {
695 rec[..rec.len().min(32)].to_vec()
696}
697
698fn attributes_btree(volume: &[u8]) -> Result<Option<CatalogLoc>, HfsXattrError> {
701 let fork = VOLUME_HEADER_OFFSET + ATTRIBUTES_FORK_OFFSET;
702 let Some(total_blocks) = volume.get(fork + 12..fork + 16) else {
703 return Err(HfsXattrError::AttributesBtree {
704 detail: format!(
705 "the {}-byte volume ends before the attributes fork record at byte {fork}",
706 volume.len()
707 ),
708 });
709 };
710 if be32(total_blocks) == 0 {
711 return Ok(None);
712 }
713 locate_attributes(volume)
714 .map(Some)
715 .ok_or_else(|| HfsXattrError::AttributesBtree {
716 detail: format!(
717 "the volume header declares {} attributes-file blocks, but the B-tree header is unusable (bad signature, block size, location or node size)",
718 be32(total_blocks)
719 ),
720 })
721}
722
723pub fn list_xattrs(volume: &[u8], cnid: u32) -> Result<Vec<HfsXattr>, HfsXattrError> {
739 let Some(loc) = attributes_btree(volume)? else {
740 return Ok(Vec::new());
741 };
742 let mut out = Vec::new();
743 walk_leaves(volume, &loc, true, |rec| {
744 if let Some(x) = parse_attr_record(rec, cnid)? {
745 out.push(x);
746 }
747 Ok(())
748 })?;
749 Ok(out)
750}
751
752pub fn read_xattr(volume: &[u8], cnid: u32, name: &str) -> Result<Option<Vec<u8>>, HfsXattrError> {
763 let Some(loc) = attributes_btree(volume)? else {
764 return Ok(None);
765 };
766 let block_size = loc.block_size;
770 let mut found = None;
771 walk_leaves(volume, &loc, true, |rec| {
772 if found.is_some() {
773 return Ok(());
774 }
775 let Some(key) = attr_key(rec, cnid)? else {
778 return Ok(());
779 };
780 if key.name != name || key.start_block != 0 {
781 return Ok(());
782 }
783 let body = key.body;
784 found = Some(match be32(&rec[body..body + 4]) {
785 ATTR_INLINE_DATA => inline_value(rec, &key)?,
786 ATTR_FORK_DATA => {
787 let fork = fork_record(rec, &key)?;
788 let bytes = fork_bytes(volume, block_size, &fork).unwrap_or_default();
789 if (bytes.len() as u64) < fork.logical {
790 return Err(HfsXattrError::Record {
791 name: Some(key.name),
792 detail: format!(
793 "its extents yield {} of its {} bytes; the rest is in kHFSPlusAttrExtents records or past the volume end, and this reader does not assemble it",
794 bytes.len(),
795 fork.logical
796 ),
797 bytes: record_prefix(rec),
798 });
799 }
800 bytes
801 }
802 other => return Err(unknown_record_type(rec, key, other)),
803 });
804 Ok(())
805 })?;
806 Ok(found)
807}
808
809struct AttrKey {
811 name: String,
812 body: usize,
814 start_block: u32,
817}
818
819fn attr_key(rec: &[u8], cnid: u32) -> Result<Option<AttrKey>, HfsXattrError> {
825 let damaged = |name: Option<String>, detail: String| HfsXattrError::Record {
826 name,
827 detail,
828 bytes: record_prefix(rec),
829 };
830 if rec.len() < 14 {
831 return Err(damaged(
832 None,
833 format!(
834 "a {}-byte record is too short for its 14-byte key header",
835 rec.len()
836 ),
837 ));
838 }
839 let key_len = be16(&rec[0..2]) as usize;
840 if be32(&rec[4..8]) != cnid {
841 return Ok(None);
842 }
843 let start_block = be32(&rec[8..12]);
844 let name_len = be16(&rec[12..14]) as usize;
845 let name_end = 14 + name_len * 2;
846 let Some(name_bytes) = rec.get(14..name_end) else {
847 return Err(damaged(
848 None,
849 format!(
850 "its {name_len}-character name runs past the {}-byte record",
851 rec.len()
852 ),
853 ));
854 };
855 let name = decode_utf16(name_bytes);
856 let body = 2 + key_len;
857 if body + 4 > rec.len() {
859 return Err(damaged(
860 Some(name),
861 format!(
862 "keyLength {key_len} puts the record body past the {}-byte record",
863 rec.len()
864 ),
865 ));
866 }
867 Ok(Some(AttrKey {
868 name,
869 body,
870 start_block,
871 }))
872}
873
874fn inline_value(rec: &[u8], key: &AttrKey) -> Result<Vec<u8>, HfsXattrError> {
876 let body = key.body;
877 let size = rec.get(body + 12..body + 16).map(|b| be32(b) as usize);
878 match size.and_then(|n| rec.get(body + 16..body + 16 + n)) {
879 Some(v) => Ok(v.to_vec()),
880 None => Err(HfsXattrError::Record {
881 name: Some(key.name.clone()),
882 detail: match size {
883 Some(n) => format!(
884 "its inline attrSize {n} runs past the {}-byte record",
885 rec.len()
886 ),
887 None => format!(
888 "the {}-byte record ends inside its inline-data header",
889 rec.len()
890 ),
891 },
892 bytes: record_prefix(rec),
893 }),
894 }
895}
896
897fn fork_record(rec: &[u8], key: &AttrKey) -> Result<Fork, HfsXattrError> {
899 rec.get(key.body + 8..)
900 .and_then(parse_fork)
901 .ok_or_else(|| HfsXattrError::Record {
902 name: Some(key.name.clone()),
903 detail: format!(
904 "the {}-byte record ends inside its 80-byte fork data",
905 rec.len()
906 ),
907 bytes: record_prefix(rec),
908 })
909}
910
911fn unknown_record_type(rec: &[u8], key: AttrKey, record_type: u32) -> HfsXattrError {
914 HfsXattrError::Record {
915 name: Some(key.name),
916 detail: format!("record type 0x{record_type:08x} is not one this reader decodes"),
917 bytes: record_prefix(rec),
918 }
919}
920
921fn parse_attr_record(rec: &[u8], cnid: u32) -> Result<Option<HfsXattr>, HfsXattrError> {
924 let Some(key) = attr_key(rec, cnid)? else {
925 return Ok(None);
926 };
927 if key.start_block != 0 {
929 return Ok(None);
930 }
931 let body = key.body;
932 let value = match be32(&rec[body..body + 4]) {
933 ATTR_INLINE_DATA => HfsXattrValue::Inline(inline_value(rec, &key)?),
934 ATTR_FORK_DATA => HfsXattrValue::Fork {
935 logical: fork_record(rec, &key)?.logical,
936 },
937 other => return Err(unknown_record_type(rec, key, other)),
938 };
939 Ok(Some(HfsXattr {
940 name: key.name,
941 value,
942 }))
943}
944
945pub fn decode_utf16(bytes: &[u8]) -> String {
947 let units: Vec<u16> = bytes
948 .chunks_exact(2)
949 .map(|c| u16::from_be_bytes([c[0], c[1]]))
950 .collect();
951 String::from_utf16_lossy(&units)
952}
953
954pub fn be16(b: &[u8]) -> u16 {
955 u16::from_be_bytes([b[0], b[1]])
956}
957pub fn be32(b: &[u8]) -> u32 {
958 u32::from_be_bytes([b[0], b[1], b[2], b[3]])
959}
960
961#[derive(Debug, Clone, PartialEq, Eq)]
963pub struct HfsPathEntry {
964 pub path: String,
966 pub is_dir: bool,
968 pub cnid: u32,
970}
971
972#[must_use]
978pub fn walk(volume: &[u8]) -> Option<Vec<HfsPathEntry>> {
979 list_dir(volume, ROOT_FOLDER_CNID)?;
981 let mut out = Vec::new();
982 let mut visited = std::collections::HashSet::new();
983 visited.insert(ROOT_FOLDER_CNID);
984 let mut stack = vec![(ROOT_FOLDER_CNID, String::new())];
985 while let Some((parent, prefix)) = stack.pop() {
986 let Some(entries) = list_dir(volume, parent) else {
987 continue;
988 };
989 for e in entries {
990 let path = if prefix.is_empty() {
991 e.name.clone()
992 } else {
993 format!("{prefix}/{}", e.name)
994 };
995 if e.is_dir && visited.insert(e.cnid) {
996 stack.push((e.cnid, path.clone()));
997 }
998 out.push(HfsPathEntry {
999 path,
1000 is_dir: e.is_dir,
1001 cnid: e.cnid,
1002 });
1003 }
1004 }
1005 Some(out)
1006}
1007
1008#[cfg(test)]
1009mod xattr_record_tests {
1010 use super::{parse_attr_record, walk_leaves, CatalogLoc, HfsXattrError};
1013
1014 fn key_then(record_type: u32, total_len: usize) -> Vec<u8> {
1017 let mut r = vec![0u8; total_len];
1018 r[0..2].copy_from_slice(&14u16.to_be_bytes());
1019 r[4..8].copy_from_slice(&7u32.to_be_bytes());
1020 r[12..14].copy_from_slice(&1u16.to_be_bytes());
1021 r[14..16].copy_from_slice(&u16::from(b'a').to_be_bytes());
1022 r[16..20].copy_from_slice(&record_type.to_be_bytes());
1023 r
1024 }
1025
1026 #[test]
1027 fn an_inline_record_ending_inside_its_header_is_an_error() {
1028 let err = parse_attr_record(&key_then(0x10, 20), 7).unwrap_err();
1029 assert!(
1030 err.to_string()
1031 .contains("ends inside its inline-data header"),
1032 "{err}"
1033 );
1034 }
1035
1036 #[test]
1037 fn a_fork_record_ending_inside_its_fork_data_is_an_error() {
1038 let err = parse_attr_record(&key_then(0x20, 40), 7).unwrap_err();
1039 assert!(err.to_string().contains("80-byte fork data"), "{err}");
1040 }
1041
1042 #[test]
1045 fn a_continuation_record_is_not_listed_as_its_own_attribute() {
1046 let mut r = key_then(0x30, 40);
1047 r[8..12].copy_from_slice(&5u32.to_be_bytes());
1048 assert_eq!(parse_attr_record(&r, 7), Ok(None));
1049 }
1050
1051 #[test]
1053 fn an_attribute_with_an_empty_value_is_listed_and_reports_empty() {
1054 let mut r = key_then(0x10, 40); r[28..32].copy_from_slice(&0u32.to_be_bytes());
1056 let x = parse_attr_record(&r, 7).unwrap().unwrap();
1057 assert_eq!(x.name, "a");
1058 assert!(x.value.is_empty());
1059 assert!(!super::HfsXattrValue::Fork { logical: 1 }.is_empty());
1060 }
1061
1062 #[test]
1063 fn a_record_of_another_file_is_not_this_files_business() {
1064 assert_eq!(parse_attr_record(&key_then(0x99, 20), 8), Ok(None));
1065 }
1066
1067 #[test]
1071 fn a_strict_walk_reports_a_record_count_the_node_cannot_hold() {
1072 let mut vol = vec![0u8; 128];
1073 vol[64 + 10..64 + 12].copy_from_slice(&40u16.to_be_bytes());
1074 let loc = CatalogLoc {
1075 cat_base: 0,
1076 node_size: 64,
1077 first_leaf: 1,
1078 block_size: 512,
1079 };
1080 let err = walk_leaves(&vol, &loc, true, |_| Ok(())).unwrap_err();
1081 assert!(
1082 matches!(&err, HfsXattrError::LeafChain { node: 1, detail } if detail.contains("declares 40 records")),
1083 "{err:?}"
1084 );
1085 let mut seen = 0;
1087 super::for_each_record(&vol, &loc, |_| seen += 1);
1088 assert_eq!(seen, 32, "every slot that fits is still visited");
1089 }
1090}