Migrate to Rust edition 2024

.github/workflows/build.yaml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        toolchain: [ stable, 1.81.0, nightly ]
+        toolchain: [ stable, 1.85.0, nightly ]
       fail-fast: false
     env:
       RUSTFLAGS: -D warnings

Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
 members = ["nod", "nodtool"]
-resolver = "2"
+resolver = "3"
 
 [profile.release]
 debug = 1
@@ -13,8 +13,8 @@ codegen-units = 1
 
 [workspace.package]
 version = "2.0.0-alpha.1"
-edition = "2021"
+edition = "2024"
-rust-version = "1.81"
+rust-version = "1.85"
 authors = ["Luke Street <luke@street.dev>"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/encounter/nod"

README.md

@@ -6,7 +6,7 @@
 [crates.io]: https://crates.io/crates/nod
 [Api Rustdoc]: https://img.shields.io/badge/api-rustdoc-blue.svg
 [rustdoc]: https://docs.rs/nod
-[Rust Version]: https://img.shields.io/badge/rust-1.81+-blue.svg?maxAge=3600
+[Rust Version]: https://img.shields.io/badge/rust-1.85+-blue.svg?maxAge=3600
 
 Library for reading and writing Nintendo Optical Disc (GameCube and Wii) images.
 

nod/src/build/gc.rs

@@ -9,14 +9,14 @@ use tracing::debug;
 use zerocopy::{FromZeros, IntoBytes};
 
 use crate::{
+    Error, Result, ResultContext,
     disc::{
-        fst::{Fst, FstBuilder},
+        BI2_SIZE, BOOT_SIZE, BootHeader, DiscHeader, GCN_MAGIC, MINI_DVD_SIZE, SECTOR_SIZE,
-        BootHeader, DiscHeader, BI2_SIZE, BOOT_SIZE, GCN_MAGIC, MINI_DVD_SIZE, SECTOR_SIZE,
         WII_MAGIC,
+        fst::{Fst, FstBuilder},
     },
     read::DiscStream,
-    util::{array_ref, array_ref_mut, lfg::LaggedFibonacci, Align},
+    util::{Align, array_ref, array_ref_mut, lfg::LaggedFibonacci},
-    Error, Result, ResultContext,
 };
 
 pub trait FileCallback: Clone + Send + Sync {

nod/src/common.rs

@@ -5,12 +5,12 @@ use std::{borrow::Cow, fmt, str::FromStr, sync::Arc};
 use zerocopy::FromBytes;
 
 use crate::{
+    Error, Result,
     disc::{
-        fst::Fst, wii::WiiPartitionHeader, BootHeader, DebugHeader, DiscHeader, BB2_OFFSET,
+        BB2_OFFSET, BOOT_SIZE, BootHeader, DebugHeader, DiscHeader, SECTOR_SIZE, fst::Fst,
-        BOOT_SIZE, SECTOR_SIZE,
+        wii::WiiPartitionHeader,
     },
     util::array_ref,
-    Error, Result,
 };
 
 /// SHA-1 hash bytes

nod/src/disc/direct.rs

@@ -7,11 +7,11 @@ use std::{
 use zerocopy::FromZeros;
 
 use crate::{
+    Result,
     common::KeyBytes,
-    disc::{wii::SECTOR_DATA_SIZE, DiscHeader, SECTOR_SIZE},
+    disc::{DiscHeader, SECTOR_SIZE, wii::SECTOR_DATA_SIZE},
     io::block::{Block, BlockReader},
     util::impl_read_for_bufread,
-    Result,
 };
 
 #[derive(Clone)]

nod/src/disc/fst.rs

@@ -4,11 +4,11 @@ use std::{borrow::Cow, ffi::CStr, mem::size_of};
 
 use encoding_rs::SHIFT_JIS;
 use itertools::Itertools;
-use zerocopy::{big_endian::*, FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout, big_endian::*};
 
 use crate::{
-    util::{array_ref, static_assert},
     Error, Result,
+    util::{array_ref, static_assert},
 };
 
 /// File system node kind.
@@ -39,13 +39,14 @@ impl Node {
     /// Create a new node.
     #[inline]
     pub fn new(kind: NodeKind, name_offset: u32, offset: u64, length: u32, is_wii: bool) -> Self {
+        let name_offset_bytes = name_offset.to_be_bytes();
         Self {
             kind: match kind {
                 NodeKind::File => 0,
                 NodeKind::Directory => 1,
                 NodeKind::Invalid => u8::MAX,
             },
-            name_offset: *array_ref![name_offset.to_be_bytes(), 1, 3],
+            name_offset: *array_ref![name_offset_bytes, 1, 3],
             offset: U32::new(match kind {
                 NodeKind::File if is_wii => (offset / 4) as u32,
                 _ => offset as u32,
@@ -91,7 +92,8 @@ impl Node {
     /// Set the name offset of the node.
     #[inline]
     pub fn set_name_offset(&mut self, name_offset: u32) {
-        self.name_offset = *array_ref![name_offset.to_be_bytes(), 1, 3];
+        let name_offset_bytes = name_offset.to_be_bytes();
+        self.name_offset = *array_ref![name_offset_bytes, 1, 3];
     }
 
     /// For files, this is the partition offset of the file data. (Wii: >> 2)

nod/src/disc/gcn.rs

@@ -8,10 +8,11 @@ use std::{
 use zerocopy::{FromBytes, FromZeros, IntoBytes};
 
 use crate::{
+    Result, ResultContext,
     disc::{
-        preloader::{fetch_sector_group, Preloader, SectorGroup, SectorGroupRequest},
+        ApploaderHeader, BB2_OFFSET, BI2_SIZE, BOOT_SIZE, BootHeader, DolHeader, SECTOR_GROUP_SIZE,
-        ApploaderHeader, BootHeader, DolHeader, BB2_OFFSET, BI2_SIZE, BOOT_SIZE, SECTOR_GROUP_SIZE,
         SECTOR_SIZE,
+        preloader::{Preloader, SectorGroup, SectorGroupRequest, fetch_sector_group},
     },
     io::block::BlockReader,
     read::{DiscStream, PartitionEncryption, PartitionMeta, PartitionReader},
@@ -19,7 +20,6 @@ use crate::{
         impl_read_for_bufread,
         read::{read_arc, read_arc_slice, read_from},
     },
-    Result, ResultContext,
 };
 
 pub struct PartitionReaderGC {

nod/src/disc/hashes.rs

@@ -4,8 +4,8 @@ use zerocopy::{FromZeros, IntoBytes};
 use crate::{
     common::HashBytes,
     disc::{
-        wii::{HASHES_SIZE, SECTOR_DATA_SIZE},
         SECTOR_GROUP_SIZE, SECTOR_SIZE,
+        wii::{HASHES_SIZE, SECTOR_DATA_SIZE},
     },
     util::{array_ref, array_ref_mut, digest::sha1_hash},
 };

nod/src/disc/mod.rs

@@ -2,7 +2,7 @@
 
 use std::{ffi::CStr, str::from_utf8};
 
-use zerocopy::{big_endian::*, FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, big_endian::*};
 
 use crate::{common::MagicBytes, util::static_assert};
 
@@ -166,11 +166,7 @@ impl BootHeader {
     /// Offset within the partition to the main DOL.
     #[inline]
     pub fn dol_offset(&self, is_wii: bool) -> u64 {
-        if is_wii {
+        if is_wii { self.dol_offset.get() as u64 * 4 } else { self.dol_offset.get() as u64 }
-            self.dol_offset.get() as u64 * 4
-        } else {
-            self.dol_offset.get() as u64
-        }
     }
 
     /// Set the offset within the partition to the main DOL.
@@ -186,11 +182,7 @@ impl BootHeader {
     /// Offset within the partition to the file system table (FST).
     #[inline]
     pub fn fst_offset(&self, is_wii: bool) -> u64 {
-        if is_wii {
+        if is_wii { self.fst_offset.get() as u64 * 4 } else { self.fst_offset.get() as u64 }
-            self.fst_offset.get() as u64 * 4
-        } else {
-            self.fst_offset.get() as u64
-        }
     }
 
     /// Set the offset within the partition to the file system table (FST).
@@ -206,11 +198,7 @@ impl BootHeader {
     /// Size of the file system table (FST).
     #[inline]
     pub fn fst_size(&self, is_wii: bool) -> u64 {
-        if is_wii {
+        if is_wii { self.fst_size.get() as u64 * 4 } else { self.fst_size.get() as u64 }
-            self.fst_size.get() as u64 * 4
-        } else {
-            self.fst_size.get() as u64
-        }
     }
 
     /// Set the size of the file system table (FST).
@@ -226,11 +214,7 @@ impl BootHeader {
     /// Maximum size of the file system table (FST) across multi-disc games.
     #[inline]
     pub fn fst_max_size(&self, is_wii: bool) -> u64 {
-        if is_wii {
+        if is_wii { self.fst_max_size.get() as u64 * 4 } else { self.fst_max_size.get() as u64 }
-            self.fst_max_size.get() as u64 * 4
-        } else {
-            self.fst_max_size.get() as u64
-        }
     }
 
     /// Set the maximum size of the file system table (FST) across multi-disc games.

nod/src/disc/preloader.rs

@@ -13,16 +13,17 @@ use crossbeam_channel::{Receiver, Sender};
 use crossbeam_utils::sync::WaitGroup;
 use lru::LruCache;
 use polonius_the_crab::{polonius, polonius_return};
-use simple_moving_average::{SingleSumSMA, SMA};
+use simple_moving_average::{SMA, SingleSumSMA};
-use tracing::{debug, error, instrument, span, Level};
+use tracing::{Level, debug, error, instrument, span};
 use zerocopy::FromZeros;
 
 use crate::{
+    IoResultContext,
     common::PartitionInfo,
     disc::{
-        hashes::{hash_sector_group, GroupHashes},
-        wii::HASHES_SIZE,
         DiscHeader, SECTOR_GROUP_SIZE, SECTOR_SIZE,
+        hashes::{GroupHashes, hash_sector_group},
+        wii::HASHES_SIZE,
     },
     io::{
         block::{Block, BlockKind, BlockReader},
@@ -33,7 +34,6 @@ use crate::{
         aes::{decrypt_sector, encrypt_sector},
         array_ref_mut,
     },
-    IoResultContext,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

nod/src/disc/reader.rs

@@ -10,20 +10,21 @@ use tracing::warn;
 use zerocopy::{FromBytes, IntoBytes};
 
 use crate::{
+    Error, Result, ResultContext,
     common::{PartitionInfo, PartitionKind},
     disc::{
+        BB2_OFFSET, BOOT_SIZE, BootHeader, DL_DVD_SIZE, DiscHeader, MINI_DVD_SIZE,
+        SECTOR_GROUP_SIZE, SECTOR_SIZE, SL_DVD_SIZE,
         direct::{DirectDiscReader, DirectDiscReaderMode},
         fst::{Fst, NodeKind},
-        gcn::{read_fst, PartitionReaderGC},
+        gcn::{PartitionReaderGC, read_fst},
         preloader::{
-            fetch_sector_group, Preloader, SectorGroup, SectorGroupLoader, SectorGroupRequest,
+            Preloader, SectorGroup, SectorGroupLoader, SectorGroupRequest, fetch_sector_group,
         },
         wii::{
-            PartitionReaderWii, WiiPartEntry, WiiPartGroup, WiiPartitionHeader, REGION_OFFSET,
+            PartitionReaderWii, REGION_OFFSET, REGION_SIZE, WII_PART_GROUP_OFF, WiiPartEntry,
-            REGION_SIZE, WII_PART_GROUP_OFF,
+            WiiPartGroup, WiiPartitionHeader,
         },
-        BootHeader, DiscHeader, BB2_OFFSET, BOOT_SIZE, DL_DVD_SIZE, MINI_DVD_SIZE,
-        SECTOR_GROUP_SIZE, SECTOR_SIZE, SL_DVD_SIZE,
     },
     io::block::BlockReader,
     read::{DiscMeta, DiscOptions, PartitionEncryption, PartitionOptions, PartitionReader},
@@ -31,7 +32,6 @@ use crate::{
         array_ref, impl_read_for_bufread,
         read::{read_arc, read_from, read_vec},
     },
-    Error, Result, ResultContext,
 };
 
 pub struct DiscReader {

nod/src/disc/wii.rs

@@ -8,14 +8,15 @@ use std::{
     sync::Arc,
 };
 
-use zerocopy::{big_endian::*, FromBytes, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout, big_endian::*};
 
 use crate::{
+    Error, Result, ResultContext,
     common::{HashBytes, KeyBytes, PartitionInfo},
     disc::{
-        gcn::{read_part_meta, PartitionReaderGC},
-        preloader::{fetch_sector_group, Preloader, SectorGroup, SectorGroupRequest},
         SECTOR_GROUP_SIZE, SECTOR_SIZE,
+        gcn::{PartitionReaderGC, read_part_meta},
+        preloader::{Preloader, SectorGroup, SectorGroupRequest, fetch_sector_group},
     },
     io::block::BlockReader,
     read::{PartitionEncryption, PartitionMeta, PartitionOptions, PartitionReader},
@@ -27,7 +28,6 @@ use crate::{
         read::{read_arc, read_arc_slice},
         static_assert,
     },
-    Error, Result, ResultContext,
 };
 
 /// Size in bytes of the hashes block in a Wii disc sector

nod/src/disc/writer.rs

@@ -8,15 +8,15 @@ use dyn_clone::DynClone;
 use rayon::prelude::*;
 
 use crate::{
+    Error, Result, ResultContext,
     common::PartitionInfo,
     disc::{
+        SECTOR_SIZE,
         reader::DiscReader,
         wii::{HASHES_SIZE, SECTOR_DATA_SIZE},
-        SECTOR_SIZE,
     },
     util::{aes::decrypt_sector_b2b, array_ref, array_ref_mut, lfg::LaggedFibonacci},
     write::{DiscFinalization, DiscWriterWeight, ProcessOptions},
-    Error, Result, ResultContext,
 };
 
 /// A callback for writing disc data.

nod/src/io/block.rs

@@ -3,10 +3,11 @@ use std::{fs, io, io::Read, path::Path};
 use dyn_clone::DynClone;
 
 use crate::{
+    Error, Result, ResultContext,
     common::{Format, KeyBytes, MagicBytes, PartitionInfo},
     disc::{
-        wii::{HASHES_SIZE, SECTOR_DATA_SIZE},
         DiscHeader, GCN_MAGIC, SECTOR_SIZE, WII_MAGIC,
+        wii::{HASHES_SIZE, SECTOR_DATA_SIZE},
     },
     io::{
         split::SplitFileReader,
@@ -14,7 +15,6 @@ use crate::{
     },
     read::{DiscMeta, DiscStream},
     util::{aes::decrypt_sector, array_ref, array_ref_mut, lfg::LaggedFibonacci, read::read_from},
-    Error, Result, ResultContext,
 };
 
 /// Block reader trait for reading disc images.
@@ -45,7 +45,7 @@ pub fn new(mut stream: Box<dyn DiscStream>) -> Result<Box<dyn BlockReader>> {
             return Err(Error::DiscFormat("GCZ support is disabled".to_string()));
         }
         Some(Format::Nfs) => {
-            return Err(Error::DiscFormat("NFS requires a filesystem path".to_string()))
+            return Err(Error::DiscFormat("NFS requires a filesystem path".to_string()));
         }
         Some(Format::Wbfs) => crate::io::wbfs::BlockReaderWBFS::new(stream)?,
         Some(Format::Wia | Format::Rvz) => crate::io::wia::BlockReaderWIA::new(stream)?,

nod/src/io/ciso.rs

@@ -6,17 +6,18 @@ use std::{
 };
 
 use bytes::{BufMut, Bytes, BytesMut};
-use zerocopy::{little_endian::*, FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout, little_endian::*};
 
 use crate::{
+    Error, Result, ResultContext,
     common::{Compression, Format, MagicBytes},
     disc::{
+        SECTOR_SIZE,
         reader::DiscReader,
         writer::{
-            check_block, par_process, read_block, BlockProcessor, BlockResult, CheckBlockResult,
+            BlockProcessor, BlockResult, CheckBlockResult, DataCallback, DiscWriter, check_block,
-            DataCallback, DiscWriter,
+            par_process, read_block,
         },
-        SECTOR_SIZE,
     },
     io::{
         block::{Block, BlockKind, BlockReader, CISO_MAGIC},
@@ -31,7 +32,6 @@ use crate::{
         static_assert,
     },
     write::{DiscFinalization, DiscWriterWeight, FormatOptions, ProcessOptions},
-    Error, Result, ResultContext,
 };
 
 pub const CISO_MAP_SIZE: usize = SECTOR_SIZE - 8;

nod/src/io/gcz.rs

@@ -7,14 +7,15 @@ use std::{
 
 use adler::adler32_slice;
 use bytes::{BufMut, Bytes, BytesMut};
-use zerocopy::{little_endian::*, FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout, little_endian::*};
 
 use crate::{
+    Error, Result, ResultContext,
     common::{Compression, Format, MagicBytes},
     disc::{
-        reader::DiscReader,
-        writer::{par_process, read_block, BlockProcessor, BlockResult, DataCallback, DiscWriter},
         SECTOR_SIZE,
+        reader::DiscReader,
+        writer::{BlockProcessor, BlockResult, DataCallback, DiscWriter, par_process, read_block},
     },
     io::block::{Block, BlockKind, BlockReader, GCZ_MAGIC},
     read::{DiscMeta, DiscStream},
@@ -25,7 +26,6 @@ use crate::{
         static_assert,
     },
     write::{DiscFinalization, DiscWriterWeight, FormatOptions, ProcessOptions},
-    Error, Result, ResultContext,
 };
 
 /// GCZ header (little endian)

nod/src/io/iso.rs

@@ -4,17 +4,17 @@ use std::{
 };
 
 use crate::{
+    Result, ResultContext,
     common::Format,
     disc::{
+        SECTOR_SIZE,
         reader::DiscReader,
         writer::{DataCallback, DiscWriter},
-        SECTOR_SIZE,
     },
     io::block::{Block, BlockKind, BlockReader},
     read::{DiscMeta, DiscStream},
     util::digest::DigestManager,
     write::{DiscFinalization, DiscWriterWeight, ProcessOptions},
-    Result, ResultContext,
 };
 
 #[derive(Clone)]

nod/src/io/nfs.rs

@@ -7,9 +7,10 @@ use std::{
     sync::Arc,
 };
 
-use zerocopy::{big_endian::U32, FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout, big_endian::U32};
 
 use crate::{
+    Error, Result, ResultContext,
     common::{Format, KeyBytes, MagicBytes},
     disc::SECTOR_SIZE,
     io::{
@@ -18,7 +19,6 @@ use crate::{
     },
     read::DiscMeta,
     util::{aes::aes_cbc_decrypt, array_ref_mut, read::read_arc, static_assert},
-    Error, Result, ResultContext,
 };
 
 pub const NFS_END_MAGIC: MagicBytes = *b"SGGE";

nod/src/io/tgc.rs

@@ -5,27 +5,27 @@ use std::{
 };
 
 use bytes::{BufMut, Bytes, BytesMut};
-use zerocopy::{big_endian::U32, FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout};
+use zerocopy::{FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout, big_endian::U32};
 
 use crate::{
-    build::gc::{insert_junk_data, FileCallback, GCPartitionStream, WriteInfo, WriteKind},
+    Error, Result, ResultContext,
+    build::gc::{FileCallback, GCPartitionStream, WriteInfo, WriteKind, insert_junk_data},
     common::{Compression, Format, MagicBytes, PartitionKind},
     disc::{
+        BB2_OFFSET, BootHeader, DiscHeader, SECTOR_SIZE,
         fst::Fst,
         gcn::{read_dol, read_fst},
         reader::DiscReader,
         writer::{DataCallback, DiscWriter},
-        BootHeader, DiscHeader, BB2_OFFSET, SECTOR_SIZE,
     },
     io::block::{Block, BlockKind, BlockReader, TGC_MAGIC},
     read::{DiscMeta, DiscStream, PartitionOptions, PartitionReader},
     util::{
-        array_ref,
+        Align, array_ref,
         read::{read_arc, read_arc_slice, read_from, read_with_zero_fill},
-        static_assert, Align,
+        static_assert,
     },
     write::{DiscFinalization, DiscWriterWeight, FormatOptions, ProcessOptions},
-    Error, Result, ResultContext,
 };
 
 /// TGC header (big endian)