Convert Installshield Executable code to use proper reader/wrapper in…

…stead of living in PortableExecutable (#59)

* Figure out how to access OverlayAddress in wrapper or reader (ideally the latter) for a non-PE reader/wrapper

* Code works

* Remove TODOs

* First round of fixes.

* use constants

* remove comment

SabreTools.Serialization.Test/Readers/InstallShieldExecutableFileTests.cs

@@ -5,14 +5,14 @@
 
 namespace SabreTools.Serialization.Test.Readers
 {
-    public class InstallShieldExecutableFileTests
+    public class InstallShieldExecutableTests
     {
         [Fact]
         public void NullArray_Null()
         {
             byte[]? data = null;
             int offset = 0;
-            var deserializer = new InstallShieldExecutableFile();
+            var deserializer = new InstallShieldExecutable();
 
             var actual = deserializer.Deserialize(data, offset);
             Assert.Null(actual);
@@ -23,7 +23,7 @@ public void EmptyArray_Null()
         {
             byte[]? data = [];
             int offset = 0;
-            var deserializer = new InstallShieldExecutableFile();
+            var deserializer = new InstallShieldExecutable();
 
             var actual = deserializer.Deserialize(data, offset);
             Assert.Null(actual);
@@ -34,7 +34,7 @@ public void InvalidArray_Null()
         {
             byte[]? data = [.. Enumerable.Repeat<byte>(0xFF, 1024)];
             int offset = 0;
-            var deserializer = new InstallShieldExecutableFile();
+            var deserializer = new InstallShieldExecutable();
 
             var actual = deserializer.Deserialize(data, offset);
             Assert.Null(actual);
@@ -44,7 +44,7 @@ public void InvalidArray_Null()
         public void NullStream_Null()
         {
             Stream? data = null;
-            var deserializer = new InstallShieldExecutableFile();
+            var deserializer = new InstallShieldExecutable();
 
             var actual = deserializer.Deserialize(data);
             Assert.Null(actual);
@@ -54,7 +54,7 @@ public void NullStream_Null()
         public void EmptyStream_Null()
         {
             Stream? data = new MemoryStream([]);
-            var deserializer = new InstallShieldExecutableFile();
+            var deserializer = new InstallShieldExecutable();
 
             var actual = deserializer.Deserialize(data);
             Assert.Null(actual);
@@ -64,7 +64,7 @@ public void EmptyStream_Null()
         public void InvalidStream_Null()
         {
             Stream? data = new MemoryStream([.. Enumerable.Repeat<byte>(0xFF, 1024)]);
-            var deserializer = new InstallShieldExecutableFile();
+            var deserializer = new InstallShieldExecutable();
 
             var actual = deserializer.Deserialize(data);
             Assert.Null(actual);

SabreTools.Serialization/Models/InstallShieldExecutable/Constants.cs

@@ -0,0 +1,15 @@
+namespace SabreTools.Data.Models.InstallShieldExecutable
+{
+    public static class Constants
+    {
+        /// <summary>
+        /// The signature for one of two kinds of currently unsupported ISEXE formats.
+        /// </summary>
+        public const string ISSignatureString = "InstallShield";
+
+        /// <summary>
+        /// The signature for one of two kinds of currently unsupported ISEXE formats.
+        /// </summary>
+        public const string ISSetupSignatureString = "ISSetupStream";
+    }
+}

SabreTools.Serialization/Models/InstallShieldExecutable/FileEntry.cs

@@ -1,5 +1,8 @@
 namespace SabreTools.Data.Models.InstallShieldExecutable
 {
+    /// <summary>
+    /// Set of attributes for each fileEntry in an InstallShield Executable
+    /// </summary>
     public class FileEntry
     {
         /// <summary>
@@ -24,5 +27,11 @@ public class FileEntry
         /// Length of the file. Stored in the installshield executable as a string.
         /// </summary>
         public ulong Length { get; set; }
+
+        /// <summary>
+        /// Offset of the file.
+        /// </summary>
+        /// <remarks>This is not stored in the installshield executable, but it needs to be stored here for extraction.</remarks>
+        public long Offset { get; set; }
     }
 }

SabreTools.Serialization/Models/InstallShieldExecutable/SFX.cs

@@ -25,7 +25,6 @@ namespace SabreTools.Data.Models.InstallShieldExecutable
     /// documents the plain variant. Clearer naming and separation between the types is yet
     /// to come.
     /// </remarks>
-    /// TODO: Look into making the array a dictionary
     /// There is no unified header or footer that indicates a file
     /// table, so having either each file entry cache the data
     /// or be associated with an offset may make it more useful.

SabreTools.Serialization/Readers/InstallShieldExecutable.cs

@@ -0,0 +1,98 @@
+using System.Collections.Generic;
+using System.IO;
+using SabreTools.Data.Models.InstallShieldExecutable;
+using SabreTools.IO.Extensions;
+using static SabreTools.Data.Models.InstallShieldExecutable.Constants;
+
+namespace SabreTools.Serialization.Readers
+{
+    public class InstallShieldExecutable : BaseBinaryReader<SFX>
+    {
+        public override SFX? Deserialize(Stream? data)
+        {
+            // If the data is invalid
+            if (data == null || !data.CanRead)
+                return null;
+
+            try
+            {
+                var sfx = new SFX();
+
+                // Cache the initial offset
+                long initialOffset = data.Position;
+
+                var sfxList = new List<FileEntry>();
+
+                while (data.Position < data.Length)
+                {
+                    // Try to parse the entry
+                    var fileEntry = ParseFileEntry(data, initialOffset);
+                    if (fileEntry == null)
+                        break;
+
+                    // Get the length, and make sure it won't EOF
+                    long length = (long)fileEntry.Length;
+                    if (length > data.Length - data.Position)
+                        break;
+
+                    data.SeekIfPossible(length, SeekOrigin.Current);
+                    sfxList.Add(fileEntry);
+                }
+
+                if (sfxList.Count == 0)
+                    return null;
+
+                sfx.Entries = [.. sfxList];
+                return sfx;
+            }
+            catch
+            {
+                // Ignore the actual error
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Parse a Stream into a FileEntry
+        /// </summary>
+        /// <param name="data">Stream to parse</param>
+        /// <returns>Filled FileEntry on success, null on error</returns>
+        public static FileEntry? ParseFileEntry(Stream data, long initialOffset)
+        {
+            string? name = data.ReadNullTerminatedAnsiString();
+            if (name == null)
+                return null;
+
+            // Both of these strings indicate that this is a different kind of encrypted and/or compressed format of
+            // ISEXE that is not yet supported, but will be in the future. 
+            // They return early because no extraction can be performed, like how MsCab currently returns if a folder
+            // is LZX or Quantum.
+            if (name == ISSignatureString)
+                return null;
+
+            if (name == ISSetupSignatureString)
+                return null;
+
+            string? path = data.ReadNullTerminatedAnsiString();
+            if (path == null)
+                return null;
+
+            string? version = data.ReadNullTerminatedAnsiString();
+            if (version == null)
+                return null;
+
+            var lengthString = data.ReadNullTerminatedAnsiString();
+            if (lengthString == null || !ulong.TryParse(lengthString, out var lengthValue))
+                return null;
+
+            var obj = new FileEntry();
+            obj.Name = name;
+            obj.Path = path;
+            obj.Version = version;
+            obj.Length = lengthValue;
+            obj.Offset = data.Position - initialOffset;
+
+            return obj;
+        }
+    }
+}

SabreTools.Serialization/Wrappers/InstallShieldExecutable.Extraction.cs

@@ -0,0 +1,65 @@
+using System;
+using System.IO;
+using SabreTools.IO.Extensions;
+
+namespace SabreTools.Serialization.Wrappers
+{
+    public partial class InstallShieldExecutable : IExtractable
+    {
+        #region Extraction
+
+        /// <inheritdoc/>
+        public bool Extract(string outputDirectory, bool includeDebug)
+        {
+            const int chunkSize = 2048 * 1024;
+            try
+            {
+                for (int i = 0; i < Entries.Length; i++)
+                {
+                    var entry = Entries[i];
+                    _dataSource.SeekIfPossible(entry.Offset, SeekOrigin.Begin);
+
+                    // Get the length, and make sure it won't EOF
+                    long length = (long)entry.Length;
+                    if (length > _dataSource.Length - _dataSource.Position)
+                        break;
+
+                    // Ensure directory separators are consistent
+                    var filename = entry.Path.TrimEnd('\0');
+                    if (Path.DirectorySeparatorChar == '\\')
+                        filename = filename.Replace('/', '\\');
+                    else if (Path.DirectorySeparatorChar == '/')
+                        filename = filename.Replace('\\', '/');
+
+                    // Ensure the full output directory exists
+                    filename = Path.Combine(outputDirectory, filename);
+                    var directoryName = Path.GetDirectoryName(filename);
+                    if (directoryName != null && !Directory.Exists(directoryName))
+                        Directory.CreateDirectory(directoryName);
+
+                    // Write the output file
+                    using var fs = File.Open(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
+                    while (length > 0)
+                    {
+                        int bytesToRead = (int)Math.Min(length, chunkSize);
+
+                        byte[] buffer = _dataSource.ReadBytes(bytesToRead);
+                        fs.Write(buffer, 0, bytesToRead);
+                        fs.Flush();
+
+                        length -= bytesToRead;
+                    }
+                }
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                if (includeDebug) Console.Error.WriteLine(ex);
+                return false;
+            }
+        }
+
+        #endregion
+    }
+}