use alloc::borrow::Cow;
use alloc::collections::VecDeque;
use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;
use crate::error::{Error, Result};
use crate::format::{
ArchiveFormat, Detection, Entry, EntryDataSink, EntryReader, EntrySink, EntryWriter, SliceData,
};
use crate::io::Sink;
use crate::meta::{EntryKind, EntryMeta, PaxMap};
const SECTOR: usize = 2048;
const SECTOR_U16: u16 = 2048;
const VD_START_SECTOR: usize = 16;
const STD_ID_OFFSET: usize = VD_START_SECTOR * SECTOR + 1;
const VD_PRIMARY: u8 = 1;
const VD_SUPPLEMENTARY: u8 = 2;
const VD_TERMINATOR: u8 = 255;
const FLAG_DIRECTORY: u8 = 0x02;
const DIR_REC_BASE: usize = 33;
const PT_REC_BASE: usize = 8;
const MAX_DEPTH: usize = 64;
const MAX_RECORDS: usize = 1 << 20;
const MAX_VDS: usize = 64;
#[derive(Debug, Clone, Copy, Default)]
pub struct Iso9660;
impl ArchiveFormat for Iso9660 {
const NAME: &'static str = "iso9660";
fn sniff(prefix: &[u8]) -> Detection {
match prefix.get(STD_ID_OFFSET..STD_ID_OFFSET + 5) {
None => Detection::NeedMore,
Some(b"CD001") => Detection::Match,
Some(_) => Detection::NoMatch,
}
}
}
#[derive(Debug, Clone)]
struct IsoRec {
path: Vec<u8>,
kind: EntryKind,
mode: u32,
size: u32,
lba: u32,
}
#[derive(Debug)]
pub struct IsoReader<'a> {
data: &'a [u8],
entries: Vec<IsoRec>,
index: usize,
parsed: bool,
payload: SliceData<'a>,
}
impl<'a> IsoReader<'a> {
#[must_use]
pub fn new(data: &'a [u8]) -> Self {
Self {
data,
entries: Vec::new(),
index: 0,
parsed: false,
payload: SliceData::default(),
}
}
fn parse(&mut self) -> Result<()> {
let mut pvd_root: Option<(u32, u32)> = None;
let mut joliet_root: Option<(u32, u32)> = None;
for i in 0..MAX_VDS {
let base = (VD_START_SECTOR + i)
.checked_mul(SECTOR)
.ok_or(Error::Malformed("iso: sector offset overflow"))?;
let vd = self
.data
.get(base..base + SECTOR)
.ok_or(Error::Malformed("iso: truncated volume descriptor"))?;
if &vd[1..6] != b"CD001" {
return Err(Error::Malformed("iso: bad standard identifier"));
}
match vd[0] {
VD_PRIMARY => {
let bs = read_u16_le(vd, 128)
.ok_or(Error::Malformed("iso: truncated block size"))?;
if usize::from(bs) != SECTOR {
return Err(Error::Unsupported("iso: logical block size is not 2048"));
}
pvd_root = Some(root_from_vd(vd)?);
},
VD_SUPPLEMENTARY => {
if is_joliet_escape(&vd[88..120]) {
joliet_root = Some(root_from_vd(vd)?);
}
},
VD_TERMINATOR => break,
_ => {},
}
}
let (root_lba, root_size, joliet) = match (joliet_root, pvd_root) {
(Some((l, s)), _) => (l, s, true),
(None, Some((l, s))) => (l, s, false),
_ => return Err(Error::Malformed("iso: no primary volume descriptor")),
};
self.walk(root_lba, root_size, joliet)
}
fn walk(&mut self, root_lba: u32, root_size: u32, joliet: bool) -> Result<()> {
let mut stack: Vec<(u32, u32, Vec<u8>, usize)> = vec![(root_lba, root_size, Vec::new(), 0)];
let mut records_seen = 0usize;
while let Some((lba, size, prefix, depth)) = stack.pop() {
if depth > MAX_DEPTH {
return Err(Error::LimitExceeded("iso: directory nesting too deep"));
}
let base = (lba as usize)
.checked_mul(SECTOR)
.ok_or(Error::Malformed("iso: directory lba overflow"))?;
let end = base
.checked_add(size as usize)
.ok_or(Error::Malformed("iso: directory extent overflow"))?;
let extent = self
.data
.get(base..end)
.ok_or(Error::Malformed("iso: truncated directory extent"))?;
let mut pos = 0usize;
while pos < extent.len() {
records_seen += 1;
if records_seen > MAX_RECORDS {
return Err(Error::LimitExceeded("iso: too many directory records"));
}
let rlen = extent[pos] as usize;
if rlen == 0 {
let next = (pos / SECTOR + 1) * SECTOR;
if next <= pos {
break;
}
pos = next;
continue;
}
if rlen < DIR_REC_BASE + 1 || pos + rlen > extent.len() {
return Err(Error::Malformed("iso: bad directory record length"));
}
let rec = &extent[pos..pos + rlen];
let child_lba =
read_u32_le(rec, 2).ok_or(Error::Malformed("iso: bad record lba"))?;
let child_size =
read_u32_le(rec, 10).ok_or(Error::Malformed("iso: bad record size"))?;
let flags = rec[25];
let ilen = rec[32] as usize;
if DIR_REC_BASE + ilen > rlen {
return Err(Error::Malformed("iso: identifier exceeds record"));
}
let ident = &rec[DIR_REC_BASE..DIR_REC_BASE + ilen];
pos += rlen;
if ilen == 1 && (ident[0] == 0 || ident[0] == 1) {
continue;
}
let is_dir = flags & FLAG_DIRECTORY != 0;
let name = decode_name(ident, joliet, is_dir);
let mut path = prefix.clone();
path.extend_from_slice(&name);
if is_dir {
let mut dir_path = path.clone();
dir_path.push(b'/');
self.entries.push(IsoRec {
path: dir_path,
kind: EntryKind::Dir,
mode: 0o755,
size: 0,
lba: 0,
});
let mut child_prefix = path;
child_prefix.push(b'/');
stack.push((child_lba, child_size, child_prefix, depth + 1));
} else {
self.entries.push(IsoRec {
path,
kind: EntryKind::File,
mode: 0o644,
size: child_size,
lba: child_lba,
});
}
}
}
Ok(())
}
}
impl<'a> EntryReader for IsoReader<'a> {
type Data = SliceData<'a>;
fn next_entry(&mut self) -> Result<Option<Entry<'_, SliceData<'a>>>> {
if !self.parsed {
self.parse()?;
self.parsed = true;
}
if self.index >= self.entries.len() {
return Ok(None);
}
let rec = self.entries[self.index].clone();
self.index += 1;
let (start, len) = if rec.kind == EntryKind::File {
let start = (rec.lba as usize)
.checked_mul(SECTOR)
.ok_or(Error::Malformed("iso: file lba overflow"))?;
let len = rec.size as usize;
let end = start
.checked_add(len)
.ok_or(Error::Malformed("iso: file extent overflow"))?;
if end > self.data.len() {
return Err(Error::Malformed("iso: file extent out of range"));
}
(start, len)
} else {
(0, 0)
};
self.payload = SliceData::new(self.data, start, len);
let meta = EntryMeta {
kind: rec.kind,
path: Cow::Owned(rec.path),
mode: rec.mode,
uid: 0,
gid: 0,
mtime: None,
size: u64::from(rec.size),
link_target: None,
pax: PaxMap::new(),
};
Ok(Some(Entry::new(meta, &mut self.payload)))
}
}
fn root_from_vd(vd: &[u8]) -> Result<(u32, u32)> {
let lba = read_u32_le(vd, 156 + 2).ok_or(Error::Malformed("iso: bad root lba"))?;
let size = read_u32_le(vd, 156 + 10).ok_or(Error::Malformed("iso: bad root size"))?;
Ok((lba, size))
}
fn is_joliet_escape(esc: &[u8]) -> bool {
esc.windows(3)
.any(|w| w[0] == 0x25 && w[1] == 0x2F && matches!(w[2], 0x40 | 0x43 | 0x45))
}
fn decode_name(ident: &[u8], joliet: bool, is_dir: bool) -> Vec<u8> {
if joliet {
strip_version(utf16be_to_bytes(ident))
} else {
let mut v = strip_version(ident.to_vec());
if !is_dir && v.last() == Some(&b'.') {
v.pop();
}
v
}
}
fn strip_version(mut v: Vec<u8>) -> Vec<u8> {
if let Some(p) = v.iter().position(|&b| b == b';') {
v.truncate(p);
}
v
}
fn utf16be_to_bytes(raw: &[u8]) -> Vec<u8> {
let units = raw
.chunks_exact(2)
.map(|c| u16::from_be_bytes([c[0], c[1]]));
let s: String = char::decode_utf16(units)
.map(|r| r.unwrap_or('\u{FFFD}'))
.collect();
s.into_bytes()
}
fn read_u32_le(b: &[u8], off: usize) -> Option<u32> {
let s = b.get(off..off + 4)?;
Some(u32::from_le_bytes([s[0], s[1], s[2], s[3]]))
}
fn read_u16_le(b: &[u8], off: usize) -> Option<u16> {
let s = b.get(off..off + 2)?;
Some(u16::from_le_bytes([s[0], s[1]]))
}
#[derive(Debug)]
struct Node {
name: Vec<u8>,
is_dir: bool,
content: Vec<u8>,
children: Vec<usize>,
parent_idx: usize,
dir_number: u16,
parent_number: u16,
iso_lba: u32,
iso_size: u32,
joliet_lba: u32,
joliet_size: u32,
file_lba: u32,
file_size: u32,
}
impl Node {
fn new(name: Vec<u8>, is_dir: bool, content: Vec<u8>, parent_idx: usize) -> Self {
Self {
name,
is_dir,
content,
children: Vec::new(),
parent_idx,
dir_number: 0,
parent_number: 0,
iso_lba: 0,
iso_size: 0,
joliet_lba: 0,
joliet_size: 0,
file_lba: 0,
file_size: 0,
}
}
}
#[derive(Debug)]
struct PendingEntry {
path: Vec<u8>,
kind: EntryKind,
content: Vec<u8>,
}
#[derive(Debug)]
pub struct IsoWriter<W: Sink> {
sink: W,
nodes: Vec<Node>,
pending: Option<PendingEntry>,
}
impl<W: Sink> IsoWriter<W> {
pub fn new(sink: W) -> Self {
Self {
sink,
nodes: vec![Node::new(Vec::new(), true, Vec::new(), 0)],
pending: None,
}
}
pub fn into_inner(self) -> W {
self.sink
}
fn close_entry(&mut self) -> Result<()> {
let Some(p) = self.pending.take() else {
return Err(Error::InvalidState("iso: no open entry"));
};
let is_dir = matches!(p.kind, EntryKind::Dir);
self.insert(&p.path, is_dir, p.content);
Ok(())
}
fn insert(&mut self, path: &[u8], is_dir: bool, content: Vec<u8>) {
let comps: Vec<&[u8]> = path
.split(|&b| b == b'/')
.filter(|c| !c.is_empty())
.collect();
let Some((leaf, dirs)) = comps.split_last() else {
return; };
let mut cur = 0usize;
for comp in dirs {
cur = self.child_dir(cur, comp);
}
if let Some(ci) = self.find_child(cur, leaf) {
if is_dir {
self.nodes[ci].is_dir = true;
} else {
self.nodes[ci].is_dir = false;
self.nodes[ci].content = content;
}
} else {
let node = Node::new(
leaf.to_vec(),
is_dir,
if is_dir { Vec::new() } else { content },
cur,
);
let idx = self.nodes.len();
self.nodes.push(node);
self.nodes[cur].children.push(idx);
}
}
fn find_child(&self, parent: usize, name: &[u8]) -> Option<usize> {
self.nodes[parent]
.children
.iter()
.copied()
.find(|&c| self.nodes[c].name == name)
}
fn child_dir(&mut self, parent: usize, name: &[u8]) -> usize {
if let Some(ci) = self.find_child(parent, name) {
self.nodes[ci].is_dir = true;
return ci;
}
let node = Node::new(name.to_vec(), true, Vec::new(), parent);
let idx = self.nodes.len();
self.nodes.push(node);
self.nodes[parent].children.push(idx);
idx
}
fn extent_of(&self, di: usize, joliet: bool) -> (u32, u32) {
let n = &self.nodes[di];
if joliet {
(n.joliet_lba, n.joliet_size)
} else {
(n.iso_lba, n.iso_size)
}
}
fn child_ident(&self, ci: usize, joliet: bool) -> Vec<u8> {
let n = &self.nodes[ci];
if joliet {
joliet_name(&n.name)
} else if n.is_dir {
mangle(&n.name)
} else {
let mut v = mangle(&n.name);
v.extend_from_slice(b";1");
v
}
}
fn dir_ident(&self, di: usize, joliet: bool) -> Vec<u8> {
if di == 0 {
return vec![0u8];
}
if joliet {
joliet_name(&self.nodes[di].name)
} else {
mangle(&self.nodes[di].name)
}
}
fn build_dir_records(&self, di: usize, joliet: bool) -> Vec<Vec<u8>> {
let mut recs = Vec::new();
let (self_lba, self_size) = self.extent_of(di, joliet);
recs.push(dir_record(&[0u8], self_lba, self_size, true));
let (p_lba, p_size) = self.extent_of(self.nodes[di].parent_idx, joliet);
recs.push(dir_record(&[1u8], p_lba, p_size, true));
for ci in self.sorted_children(di) {
let ident = self.child_ident(ci, joliet);
if self.nodes[ci].is_dir {
let (lba, size) = self.extent_of(ci, joliet);
recs.push(dir_record(&ident, lba, size, true));
} else {
recs.push(dir_record(
&ident,
self.nodes[ci].file_lba,
self.nodes[ci].file_size,
false,
));
}
}
recs
}
fn sorted_children(&self, di: usize) -> Vec<usize> {
let mut kids = self.nodes[di].children.clone();
kids.sort_by(|&a, &b| self.nodes[a].name.cmp(&self.nodes[b].name));
kids
}
fn build_path_table(&self, order: &[usize], joliet: bool, big_endian: bool) -> Vec<u8> {
let mut out = Vec::new();
for &di in order {
let ident = self.dir_ident(di, joliet);
let (lba, _) = self.extent_of(di, joliet);
let parent = self.nodes[di].parent_number;
out.push(u8::try_from(ident.len()).unwrap_or(u8::MAX));
out.push(0); if big_endian {
out.extend_from_slice(&lba.to_be_bytes());
out.extend_from_slice(&parent.to_be_bytes());
} else {
out.extend_from_slice(&lba.to_le_bytes());
out.extend_from_slice(&parent.to_le_bytes());
}
out.extend_from_slice(&ident);
if ident.len() % 2 == 1 {
out.push(0);
}
}
out
}
#[allow(clippy::too_many_lines, clippy::similar_names)]
fn assemble(&mut self) -> Result<()> {
let order = self.order_directories()?;
self.validate_identifiers(&order)?;
let files = self.collect_files()?;
for &di in &order {
let iso = layout_len(&self.build_dir_records(di, false));
let jol = layout_len(&self.build_dir_records(di, true));
self.nodes[di].iso_size = u32::try_from(iso)
.map_err(|_| Error::LimitExceeded("iso: directory extent too large"))?;
self.nodes[di].joliet_size = u32::try_from(jol)
.map_err(|_| Error::LimitExceeded("iso: directory extent too large"))?;
}
let iso_pt_size = self.path_table_size(&order, false);
let joliet_pt_size = self.path_table_size(&order, true);
let mut lba: u32 = u32::try_from(VD_START_SECTOR + 3)
.map_err(|_| Error::LimitExceeded("iso: image too large"))?;
let iso_l_pt = lba;
lba = advance(lba, iso_pt_size)?;
let iso_m_pt = lba;
lba = advance(lba, iso_pt_size)?;
let joliet_l_pt = lba;
lba = advance(lba, joliet_pt_size)?;
let joliet_m_pt = lba;
lba = advance(lba, joliet_pt_size)?;
for &di in &order {
self.nodes[di].iso_lba = lba;
lba = advance(lba, self.nodes[di].iso_size as usize)?;
}
for &di in &order {
self.nodes[di].joliet_lba = lba;
lba = advance(lba, self.nodes[di].joliet_size as usize)?;
}
for &fi in &files {
self.nodes[fi].file_lba = lba;
lba = advance(lba, self.nodes[fi].file_size as usize)?;
}
let total_sectors = lba;
let total_bytes = (total_sectors as usize)
.checked_mul(SECTOR)
.ok_or(Error::LimitExceeded("iso: image too large"))?;
let mut out = vec![0u8; total_bytes];
let (root_iso_lba, root_iso_size) = self.extent_of(0, false);
let (root_jol_lba, root_jol_size) = self.extent_of(0, true);
write_vd(
&mut out,
VD_START_SECTOR,
VD_PRIMARY,
false,
root_iso_lba,
root_iso_size,
iso_pt_size,
iso_l_pt,
iso_m_pt,
total_sectors,
);
write_vd(
&mut out,
VD_START_SECTOR + 1,
VD_SUPPLEMENTARY,
true,
root_jol_lba,
root_jol_size,
joliet_pt_size,
joliet_l_pt,
joliet_m_pt,
total_sectors,
);
write_terminator(&mut out, VD_START_SECTOR + 2);
write_at(
&mut out,
iso_l_pt,
&self.build_path_table(&order, false, false),
);
write_at(
&mut out,
iso_m_pt,
&self.build_path_table(&order, false, true),
);
write_at(
&mut out,
joliet_l_pt,
&self.build_path_table(&order, true, false),
);
write_at(
&mut out,
joliet_m_pt,
&self.build_path_table(&order, true, true),
);
for &di in &order {
let iso_recs = self.build_dir_records(di, false);
write_extent(&mut out, self.nodes[di].iso_lba, &iso_recs);
let jol_recs = self.build_dir_records(di, true);
write_extent(&mut out, self.nodes[di].joliet_lba, &jol_recs);
}
for &fi in &files {
let base = self.nodes[fi].file_lba as usize * SECTOR;
let content = &self.nodes[fi].content;
out[base..base + content.len()].copy_from_slice(content);
}
self.sink.write_all(&out)
}
fn order_directories(&mut self) -> Result<Vec<usize>> {
self.nodes[0].dir_number = 1;
self.nodes[0].parent_number = 1;
let mut order = Vec::new();
let mut queue = VecDeque::new();
queue.push_back(0usize);
let mut next_number: u16 = 2;
while let Some(di) = queue.pop_front() {
order.push(di);
let mut child_dirs: Vec<usize> = self.nodes[di]
.children
.iter()
.copied()
.filter(|&c| self.nodes[c].is_dir)
.collect();
child_dirs.sort_by(|&a, &b| self.nodes[a].name.cmp(&self.nodes[b].name));
let parent_number = self.nodes[di].dir_number;
for c in child_dirs {
self.nodes[c].dir_number = next_number;
self.nodes[c].parent_number = parent_number;
next_number = next_number
.checked_add(1)
.ok_or(Error::LimitExceeded("iso: too many directories"))?;
queue.push_back(c);
}
}
Ok(order)
}
fn collect_files(&mut self) -> Result<Vec<usize>> {
let mut files = Vec::new();
for idx in 0..self.nodes.len() {
if !self.nodes[idx].is_dir {
let len = self.nodes[idx].content.len();
self.nodes[idx].file_size = u32::try_from(len)
.map_err(|_| Error::Unsupported("iso: file exceeds 4 GiB"))?;
files.push(idx);
}
}
Ok(files)
}
fn validate_identifiers(&self, order: &[usize]) -> Result<()> {
for &di in order {
for joliet in [false, true] {
let ident = self.dir_ident(di, joliet);
if ident.len() > 255 {
return Err(Error::Unsupported("iso: directory name too long"));
}
if joliet && joliet_ident_has_forbidden(&ident) {
return Err(Error::Unsupported(
"iso: forbidden character in Joliet name",
));
}
for ci in &self.nodes[di].children {
let child = self.child_ident(*ci, joliet);
if child.len() > 255 {
return Err(Error::Unsupported("iso: entry name too long"));
}
if joliet && joliet_ident_has_forbidden(&child) {
return Err(Error::Unsupported(
"iso: forbidden character in Joliet name",
));
}
}
}
}
Ok(())
}
fn path_table_size(&self, order: &[usize], joliet: bool) -> usize {
order
.iter()
.map(|&di| pt_rec_len(self.dir_ident(di, joliet).len()))
.sum()
}
}
impl<W: Sink> EntryWriter for IsoWriter<W> {
type Sink = Self;
fn start_entry(&mut self, meta: &EntryMeta<'_>) -> Result<EntrySink<'_, Self>> {
if self.pending.is_some() {
return Err(Error::InvalidState("iso: previous entry not closed"));
}
if !matches!(meta.kind, EntryKind::File | EntryKind::Dir) {
return Err(Error::Unsupported(
"iso: only files and directories are supported",
));
}
self.pending = Some(PendingEntry {
path: meta.path.to_vec(),
kind: meta.kind,
content: Vec::new(),
});
Ok(EntrySink::new(self))
}
fn finish(&mut self) -> Result<()> {
if self.pending.is_some() {
return Err(Error::InvalidState("iso: entry open at finish"));
}
self.assemble()
}
}
impl<W: Sink> EntryDataSink for IsoWriter<W> {
fn write_chunk(&mut self, data: &[u8]) -> Result<()> {
if let Some(p) = &mut self.pending {
p.content.extend_from_slice(data);
Ok(())
} else {
Err(Error::InvalidState("iso: write without an open entry"))
}
}
fn close(&mut self) -> Result<()> {
self.close_entry()
}
}
fn sectors(bytes: usize) -> u32 {
u32::try_from(bytes.div_ceil(SECTOR)).unwrap_or(u32::MAX)
}
fn advance(lba: u32, bytes: usize) -> Result<u32> {
lba.checked_add(sectors(bytes))
.ok_or(Error::LimitExceeded("iso: image too large"))
}
fn dir_rec_len(ident_len: usize) -> usize {
let base = DIR_REC_BASE + ident_len;
base + (base & 1)
}
fn pt_rec_len(ident_len: usize) -> usize {
let base = PT_REC_BASE + ident_len;
base + (base & 1)
}
fn dir_record(ident: &[u8], lba: u32, size: u32, is_dir: bool) -> Vec<u8> {
let ilen = ident.len();
let rlen = dir_rec_len(ilen);
let mut r = vec![0u8; rlen];
r[0] = u8::try_from(rlen).unwrap_or(u8::MAX);
r[1] = 0; r[2..10].copy_from_slice(&both_endian_u32(lba));
r[10..18].copy_from_slice(&both_endian_u32(size));
r[18..25].copy_from_slice(&RECORDING_TIME);
r[25] = if is_dir { FLAG_DIRECTORY } else { 0 };
r[26] = 0; r[27] = 0; r[28..32].copy_from_slice(&both_endian_u16(1)); r[32] = u8::try_from(ilen).unwrap_or(u8::MAX);
r[DIR_REC_BASE..DIR_REC_BASE + ilen].copy_from_slice(ident);
r
}
const RECORDING_TIME: [u8; 7] = [120, 1, 1, 0, 0, 0, 0];
fn layout_len(recs: &[Vec<u8>]) -> usize {
let mut pos = 0usize;
for r in recs {
let off = pos % SECTOR;
if off + r.len() > SECTOR {
pos += SECTOR - off;
}
pos += r.len();
}
pos.div_ceil(SECTOR).max(1) * SECTOR
}
fn write_extent(out: &mut [u8], lba: u32, recs: &[Vec<u8>]) {
let base = lba as usize * SECTOR;
let mut pos = 0usize;
for r in recs {
let off = pos % SECTOR;
if off + r.len() > SECTOR {
pos += SECTOR - off;
}
out[base + pos..base + pos + r.len()].copy_from_slice(r);
pos += r.len();
}
}
fn write_at(out: &mut [u8], lba: u32, bytes: &[u8]) {
let base = lba as usize * SECTOR;
out[base..base + bytes.len()].copy_from_slice(bytes);
}
#[allow(clippy::too_many_arguments)]
fn write_vd(
out: &mut [u8],
sector_index: usize,
vtype: u8,
joliet: bool,
root_lba: u32,
root_size: u32,
pt_size: usize,
l_pt: u32,
m_pt: u32,
total_sectors: u32,
) {
let base = sector_index * SECTOR;
let vd = &mut out[base..base + SECTOR];
vd[0] = vtype;
vd[1..6].copy_from_slice(b"CD001");
vd[6] = 1;
if joliet {
vd[88] = 0x25;
vd[89] = 0x2F;
vd[90] = 0x45; } else {
for b in &mut vd[8..40] {
*b = b' ';
}
for b in &mut vd[40..72] {
*b = b' ';
}
}
let pt = u32::try_from(pt_size).unwrap_or(u32::MAX);
vd[80..88].copy_from_slice(&both_endian_u32(total_sectors)); vd[120..124].copy_from_slice(&both_endian_u16(1)); vd[124..128].copy_from_slice(&both_endian_u16(1)); vd[128..132].copy_from_slice(&both_endian_u16(SECTOR_U16)); vd[132..140].copy_from_slice(&both_endian_u32(pt)); vd[140..144].copy_from_slice(&l_pt.to_le_bytes()); vd[148..152].copy_from_slice(&m_pt.to_be_bytes()); let root = dir_record(&[0u8], root_lba, root_size, true);
vd[156..190].copy_from_slice(&root);
if !joliet {
for b in &mut vd[190..813] {
*b = b' ';
}
}
vd[881] = 1; }
fn write_terminator(out: &mut [u8], sector_index: usize) {
let base = sector_index * SECTOR;
let vd = &mut out[base..base + SECTOR];
vd[0] = VD_TERMINATOR;
vd[1..6].copy_from_slice(b"CD001");
vd[6] = 1;
}
fn both_endian_u32(v: u32) -> [u8; 8] {
let l = v.to_le_bytes();
let b = v.to_be_bytes();
[l[0], l[1], l[2], l[3], b[0], b[1], b[2], b[3]]
}
fn both_endian_u16(v: u16) -> [u8; 4] {
let l = v.to_le_bytes();
let b = v.to_be_bytes();
[l[0], l[1], b[0], b[1]]
}
fn mangle(name: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(name.len());
for &b in name {
let c = if b.is_ascii_lowercase() {
b - 32
} else if b.is_ascii_uppercase() || b.is_ascii_digit() || b == b'_' || b == b'.' {
b
} else {
b'_'
};
out.push(c);
}
if out.is_empty() {
out.push(b'_');
}
out
}
fn is_joliet_forbidden(b: u8) -> bool {
matches!(b, b'*' | b'/' | b':' | b';' | b'?' | b'\\') || b < 0x20
}
fn joliet_ident_has_forbidden(ident: &[u8]) -> bool {
ident
.chunks_exact(2)
.any(|u| u[0] == 0x00 && is_joliet_forbidden(u[1]))
}
fn joliet_name(name: &[u8]) -> Vec<u8> {
let mut sanitized = Vec::with_capacity(name.len());
for &b in name {
sanitized.push(if is_joliet_forbidden(b) { b'_' } else { b });
}
let mut out = Vec::new();
push_utf16be(&sanitized, &mut out);
out
}
fn push_utf16be(name: &[u8], out: &mut Vec<u8>) {
let mut input = name;
loop {
match core::str::from_utf8(input) {
Ok(s) => {
encode_utf16be(s, out);
break;
},
Err(e) => {
let valid = e.valid_up_to();
if let Ok(s) = core::str::from_utf8(&input[..valid]) {
encode_utf16be(s, out);
}
out.extend_from_slice(&0xFFFDu16.to_be_bytes());
match e.error_len() {
Some(len) => input = &input[valid + len..],
None => break, }
},
}
}
}
fn encode_utf16be(s: &str, out: &mut Vec<u8>) {
for unit in s.encode_utf16() {
out.extend_from_slice(&unit.to_be_bytes());
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
mod tests {
use super::*;
#[test]
fn both_endian_layout() {
assert_eq!(both_endian_u32(0x0102_0304), [4, 3, 2, 1, 1, 2, 3, 4]);
assert_eq!(both_endian_u16(0x0102), [2, 1, 1, 2]);
}
#[test]
fn record_lengths_are_even() {
assert_eq!(dir_rec_len(1), 34);
assert_eq!(dir_rec_len(2), 36);
assert_eq!(pt_rec_len(1), 10); assert_eq!(pt_rec_len(2), 10); }
#[test]
fn mangle_uppercases_and_sanitizes() {
assert_eq!(mangle(b"Hello.txt"), b"HELLO.TXT");
assert_eq!(mangle(b"a b/c"), b"A_B_C");
assert_eq!(mangle(b""), b"_");
}
#[test]
fn joliet_roundtrips_unicode() {
let name = "héllo".as_bytes();
let encoded = joliet_name(name);
assert_eq!(utf16be_to_bytes(&encoded), name);
}
#[test]
fn joliet_name_sanitizes_forbidden_chars() {
let encoded = joliet_name(b"C:*/;?\\\x01");
assert_eq!(utf16be_to_bytes(&encoded), b"C_______");
assert!(!joliet_ident_has_forbidden(&encoded));
let legal = joliet_name(b"Hello.txt");
assert_eq!(utf16be_to_bytes(&legal), b"Hello.txt");
assert!(!joliet_ident_has_forbidden(&legal));
}
#[test]
fn joliet_escape_detected() {
let mut esc = [0u8; 32];
esc[0..3].copy_from_slice(&[0x25, 0x2F, 0x45]);
assert!(is_joliet_escape(&esc));
assert!(!is_joliet_escape(&[0u8; 32]));
}
}