ISO-9660: Parse headers and critical volume descriptors

Author: hounsell

Docs/FileSystems/ECMA-119_4th_edition_june_2019.pdf

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using System.IO;
 using TotalImage.FileSystems.FAT;
+using TotalImage.FileSystems.ISO;
 
 namespace TotalImage.FileSystems
 {
@@ -10,7 +11,8 @@ namespace TotalImage.FileSystems
     public abstract class FileSystem
     {
         private readonly static ImmutableArray<IFileSystemFactory> _knownFactories = ImmutableArray.Create<IFileSystemFactory>(
-            new FatFactory()
+            new FatFactory(),
+            new IsoFactory()
         );
 
         /// <summary>

TotalImage.IO/FileSystems/FileSystem.cs

@@ -0,0 +1,84 @@
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+
+namespace TotalImage.FileSystems.ISO
+{
+    /*
+     * The ISO 9660 implementation here is based on the ECMA-119 specification, 4th edition
+     * https://www.ecma-international.org/wp-content/uploads/ECMA-119_4th_edition_june_2019.pdf
+     * A copy has also been included in the TotalImage repository, under the docs folder
+     */
+
+    /// <summary>
+    /// Representation of an ISO 9660 file system
+    /// </summary>
+    public class Iso9660FileSystem : FileSystem
+    {
+        /// <summary>
+        /// The volume descriptors for the ISO 9660 file system
+        /// </summary>
+        public ImmutableArray<IsoVolumeDescriptor> VolumeDescriptors { get; }
+
+        /// <summary>
+        /// The first primary volume descriptor
+        /// </summary>
+        public IsoPrimaryVolumeDescriptor? PrimaryVolumeDescriptor
+            => VolumeDescriptors
+                .OfType<IsoPrimaryVolumeDescriptor>()
+                .FirstOrDefault();
+
+        /// <summary>
+        /// Create an ISO 9660 file system
+        /// </summary>
+        /// <param name="containerStream">The underlying stream</param>
+        public Iso9660FileSystem(Stream containerStream) : base(containerStream)
+        {
+            containerStream.Seek(0x8000, SeekOrigin.Begin);
+
+            var volumeDescriptors = ImmutableArray.CreateBuilder<IsoVolumeDescriptor>();
+
+            byte[] recordBytes = new byte[2048];
+            do
+            {
+                containerStream.Read(recordBytes);
+
+                var record = IsoVolumeDescriptor.ReadVolumeDescriptor(recordBytes);
+                if (!record.IsValid())
+                {
+                    throw new InvalidDataException();
+                }
+
+                volumeDescriptors.Add(record);
+            }
+            while (volumeDescriptors[^1].Type != IsoVolumeDescriptorType.VolumeDescriptorSetTerminator);
+
+            VolumeDescriptors = volumeDescriptors.ToImmutable();
+
+            IsoPrimaryVolumeDescriptor? primaryDescriptor = PrimaryVolumeDescriptor;
+            if (primaryDescriptor == null)
+            {
+                throw new InvalidDataException("No primary volume descriptor");
+            }
+
+            VolumeLabel = primaryDescriptor.VolumeSetIdentifier;
+            RootDirectory = primaryDescriptor.RootDirectory;
+            TotalSize = primaryDescriptor.LogicalBlockSize * primaryDescriptor.VolumeSpace;
+        }
+
+        /// <inheritdoc />
+        public override string DisplayName => "ISO 9660";
+
+        /// <inheritdoc />
+        public override string VolumeLabel { get; set; }
+
+        /// <inheritdoc />
+        public override Directory RootDirectory { get; }
+
+        /// <inheritdoc />
+        public override long TotalFreeSpace => 0;
+
+        /// <inheritdoc />
+        public override long TotalSize { get; }
+    }
+}

TotalImage.IO/FileSystems/ISO/Iso9660FileSystem.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Immutable;
+using System.Text;
+
+namespace TotalImage.FileSystems.ISO
+{
+    /// <summary>
+    /// Represents an ISO 9660 Boot Record
+    /// </summary>
+    public class IsoBootVolumeDescriptor : IsoVolumeDescriptor
+    {
+        /// <summary>
+        /// An identifier of which system can read the boot record
+        /// </summary>
+        public string BootSystemIdentifier { get; }
+
+        /// <summary>
+        /// An identifier for the boot record
+        /// </summary>
+        public string BootIdentifier { get; }
+
+        /// <summary>
+        /// The raw binary to be used by the boot system
+        /// </summary>
+        public ImmutableArray<byte> BootSystemContent { get; }
+
+        /// <summary>
+        /// Create an ISO 9660 Boot Record
+        /// </summary>
+        /// <param name="record">A span containing the volume descriptor record</param>
+        /// <param name="type">The type of the volume descriptor</param>
+        /// <param name="identifier">The volume descriptor identifier</param>
+        /// <param name="version">The version of the volume descriptor</param>
+        public IsoBootVolumeDescriptor(in ReadOnlySpan<byte> record, in IsoVolumeDescriptorType type, in ImmutableArray<byte> identifier, in byte version)
+            : base(type, identifier, version)
+        {
+            Span<char> tmp = new char[32];
+
+            Encoding.ASCII.GetChars(record[7..39], tmp);
+            BootSystemIdentifier = tmp.TrimEnd('\0').ToString();
+
+            Encoding.ASCII.GetChars(record[39..71], tmp);
+            BootIdentifier = tmp.TrimEnd('\0').ToString();
+
+            BootSystemContent = record[71..].ToArray().ToImmutableArray();
+        }
+    }
+}

TotalImage.IO/FileSystems/ISO/IsoBootVolumeDescriptor.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Text;
+
+namespace TotalImage.FileSystems.ISO
+{
+    /// <summary>
+    /// Represents a directory record within an ISO 9660 file system
+    /// </summary>
+    public class IsoDirectoryRecord : Directory
+    {
+        /// <summary>
+        /// Used to separate a file name and extension in a file identifier
+        /// </summary>
+        public const char IDENTIFIER_SEPARATOR_1 = '.';
+
+        /// <summary>
+        /// Used to separate a file extension and file version in a file identifier
+        /// </summary>
+        public const char IDENTIFIER_SEPARATOR_2 = ';';
+
+        #region Implemented Properties / Methods
+        /// <inheritdoc />
+        public override string Name { get => FileIdentifier; set => throw new NotImplementedException(); }
+
+        /// <inheritdoc />
+        public override FileAttributes Attributes { get => 0; set => throw new NotImplementedException(); }
+
+        /// <inheritdoc />
+        public override DateTime? LastAccessTime { get => null; set => throw new NotImplementedException(); }
+
+        /// <inheritdoc />
+        public override DateTime? LastWriteTime { get => RecordingDate?.LocalDateTime.ToLocalTime(); set => throw new NotImplementedException(); }
+
+        /// <inheritdoc />
+        public override DateTime? CreationTime { get => null; set => throw new NotImplementedException(); }
+
+        /// <inheritdoc />
+        public override ulong Length { get => DataLength; set => throw new NotImplementedException(); }
+
+        public override Directory CreateSubdirectory(string path)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Delete()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override IEnumerable<FileSystemObject> EnumerateFileSystemObjects(bool showHidden, bool showDeleted)
+        {
+            return Array.Empty<FileSystemObject>();
+        }
+
+        public override void MoveTo(string path)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+
+        /// <summary>
+        /// Length of directory record
+        /// </summary>
+        public byte RecordLength { get; }
+
+        /// <summary>
+        /// Length of extended attribute record
+        /// </summary>
+        public byte ExtendedAttributeLength { get; }
+
+        /// <summary>
+        /// Offset of extent
+        /// </summary>
+        public uint ExtentOffset { get; }
+
+        /// <summary>
+        /// Length of data
+        /// </summary>
+        public uint DataLength { get; }
+
+        /// <summary>
+        /// Time directory was recorded to disc
+        /// </summary>
+        public DateTimeOffset? RecordingDate { get; }
+
+        /// <summary>
+        /// Flags indicating the characteristics of the directory
+        /// </summary>
+        public IsoFileFlags FileFlags { get; }
+
+        /// <summary>
+        /// File unit size if data is recorded in interleave mode
+        /// </summary>
+        public byte FileUnitSize { get; }
+
+        /// <summary>
+        /// The interleave gap size if data is recorded in interleave mode
+        /// </summary>
+        public byte InterleaveGapSize { get; }
+
+        /// <summary>
+        /// The ordinal number of the volume that this extent appears on within the volume set
+        /// </summary>
+        public ushort VolumeSequenceNumber { get; }
+
+        /// <summary>
+        /// Length of the file identifier
+        /// </summary>
+        public byte FileIdentifierLength { get; }
+
+        /// <summary>
+        /// The identifier of the file
+        /// </summary>
+        public string FileIdentifier { get; }
+
+        /// <summary>
+        /// Raw binary data reserved for system use
+        /// </summary>
+        public ImmutableArray<byte> SystemUseContent { get; }
+
+        /// <summary>
+        /// Create an ISO 9660 directory record
+        /// </summary>
+        /// <param name="record">A span containing the directory record</param>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown if the span provided does not cover the entire record</exception>
+        public IsoDirectoryRecord(in ReadOnlySpan<byte> record) : base(null, null)
+        {
+            if (record[0] > record.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(record));
+            }
+
+            RecordLength = record[0];
+            ExtendedAttributeLength = record[1];
+            ExtentOffset = IsoUtilities.ReadUInt32MultiEndian(record[2..10]);
+            DataLength = IsoUtilities.ReadUInt32MultiEndian(record[10..18]);
+            RecordingDate = IsoUtilities.FromIsoRecordingDateTime(record[18..25]);
+            FileFlags = (IsoFileFlags)record[25];
+            FileUnitSize = record[26];
+            InterleaveGapSize = record[27];
+            VolumeSequenceNumber = IsoUtilities.ReadUInt16MultiEndian(record[28..32]);
+            FileIdentifierLength = record[32];
+
+            char[] textBuffer = new char[FileIdentifierLength];
+            Encoding.ASCII.GetChars(record[33..(33 + FileIdentifierLength)], textBuffer);
+            FileIdentifier = textBuffer.AsSpan().Trim('\0').ToString();
+
+            int systemUseStart = 33 + FileIdentifierLength;
+            if (systemUseStart % 2 == 1) systemUseStart++; // account for padding field
+
+            if (systemUseStart == RecordLength)
+            {
+                SystemUseContent = Array.Empty<byte>().ToImmutableArray();
+            }
+            else
+            {
+                record[systemUseStart..RecordLength].ToArray().ToImmutableArray();
+            }
+        }
+    }
+}

TotalImage.IO/FileSystems/ISO/IsoDirectoryRecord.cs

@@ -0,0 +1,26 @@
+using System;
+using System.IO;
+using System.Linq;
+
+namespace TotalImage.FileSystems.ISO
+{
+    /// <summary>
+    /// A factory class that can create an ISO 9660 file system
+    /// </summary>
+    public class IsoFactory : IFileSystemFactory
+    {
+        /// <inheritdoc />
+        public FileSystem? TryLoadFileSystem(Stream stream)
+        {
+            stream.Seek(0x8001, SeekOrigin.Begin);
+            byte[] identifier = new byte[5];
+            stream.Read(identifier);
+            if (identifier.SequenceEqual(IsoVolumeDescriptor.StandardIdentifier))
+            {
+                return new Iso9660FileSystem(stream);
+            }
+
+            return null;
+        }
+    }
+}

TotalImage.IO/FileSystems/ISO/IsoFactory.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace TotalImage.FileSystems.ISO
+{
+    /// <summary>
+    /// Flags set for a file on the ISO 9660 file system
+    /// </summary>
+    [Flags]
+    public enum IsoFileFlags : byte
+    {
+        /// <summary>
+        /// If set, the existence of the file should not be shown to the user
+        /// </summary>
+        Existence = 1 << 0,
+
+        /// <summary>
+        /// If set, the record is a directory
+        /// </summary>
+        Directory = 1 << 1,
+
+        /// <summary>
+        /// If set, the record is an associated file
+        /// </summary>
+        AssociatedFile = 1 << 2,
+
+        /// <summary>
+        /// If set, the record is an extended attribute record
+        /// </summary>
+        Record = 1 << 3,
+
+        /// <summary>
+        /// If set, permissions for this file are set in an extended attribute record
+        /// </summary>
+        Protection = 1 << 4,
+
+        /// <summary>
+        /// If set, this is not the final record for the entry
+        /// </summary>
+        MultiExtent = 1 << 7
+    }
+}