Add DMG support

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using SharpCompress.Archives.Dmg;
 using SharpCompress.Archives.GZip;
 using SharpCompress.Archives.Rar;
 using SharpCompress.Archives.SevenZip;
@@ -44,6 +45,12 @@ public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
                 return GZipArchive.Open(stream, readerOptions);
             }
             stream.Seek(0, SeekOrigin.Begin);
+            if (DmgArchive.IsDmgFile(stream))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return DmgArchive.Open(stream, readerOptions);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
             if (RarArchive.IsRarFile(stream, readerOptions))
             {
                 stream.Seek(0, SeekOrigin.Begin);
@@ -55,7 +62,7 @@ public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
                 stream.Seek(0, SeekOrigin.Begin);
                 return TarArchive.Open(stream, readerOptions);
             }
-            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
+            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip, Dmg");
         }
 
         public static IWritableArchive Create(ArchiveType type)
@@ -106,6 +113,12 @@ public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
                 return GZipArchive.Open(fileInfo, options);
             }
             stream.Seek(0, SeekOrigin.Begin);
+            if (DmgArchive.IsDmgFile(stream))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return DmgArchive.Open(fileInfo, options);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
             if (RarArchive.IsRarFile(stream, options))
             {
                 return RarArchive.Open(fileInfo, options);
@@ -115,7 +128,7 @@ public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
             {
                 return TarArchive.Open(fileInfo, options);
             }
-            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
+            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, Dmg");
         }
 
         /// <summary>

src/SharpCompress/Archives/Dmg/DmgArchive.cs

@@ -0,0 +1,117 @@
+using SharpCompress.Common;
+using SharpCompress.Common.Dmg;
+using SharpCompress.Common.Dmg.Headers;
+using SharpCompress.Common.Dmg.HFS;
+using SharpCompress.Readers;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace SharpCompress.Archives.Dmg
+{
+    public class DmgArchive : AbstractArchive<DmgArchiveEntry, DmgVolume>
+    {
+        private readonly string _fileName;
+
+        internal DmgArchive(FileInfo fileInfo, ReaderOptions readerOptions)
+            : base(ArchiveType.Dmg, fileInfo, readerOptions)
+        {
+            _fileName = fileInfo.FullName;
+        }
+
+        internal DmgArchive(Stream stream, ReaderOptions readerOptions)
+            : base(ArchiveType.Dmg, stream.AsEnumerable(), readerOptions)
+        {
+            _fileName = string.Empty;
+        }
+
+        protected override IReader CreateReaderForSolidExtraction()
+            => new DmgReader(ReaderOptions, this, _fileName);
+
+        protected override IEnumerable<DmgArchiveEntry> LoadEntries(IEnumerable<DmgVolume> volumes)
+            => volumes.Single().LoadEntries();
+
+        protected override IEnumerable<DmgVolume> LoadVolumes(FileInfo file)
+            => new DmgVolume(this, file.OpenRead(), file.FullName, ReaderOptions).AsEnumerable();
+
+        protected override IEnumerable<DmgVolume> LoadVolumes(IEnumerable<Stream> streams)
+            => new DmgVolume(this, streams.Single(), string.Empty, ReaderOptions).AsEnumerable();
+
+        public static bool IsDmgFile(FileInfo fileInfo)
+        {
+            if (!fileInfo.Exists) return false;
+
+            using var stream = fileInfo.OpenRead();
+            return IsDmgFile(stream);
+        }
+
+        public static bool IsDmgFile(Stream stream)
+        {
+            long headerPos = stream.Length - DmgHeader.HeaderSize;
+            if (headerPos < 0) return false;
+            stream.Position = headerPos;
+
+            return DmgHeader.TryRead(stream, out _);
+        }
+
+        /// <summary>
+        /// Constructor expects a filepath to an existing file.
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="readerOptions"></param>
+        public static DmgArchive Open(string filePath, ReaderOptions? readerOptions = null)
+        {
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+        }
+
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="readerOptions"></param>
+        public static DmgArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+        {
+            fileInfo.CheckNotNull(nameof(fileInfo));
+            return new DmgArchive(fileInfo, readerOptions ?? new ReaderOptions());
+        }
+
+        /// <summary>
+        /// Takes a seekable Stream as a source
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        public static DmgArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+        {
+            stream.CheckNotNull(nameof(stream));
+            return new DmgArchive(stream, readerOptions ?? new ReaderOptions());
+        }
+
+        private sealed class DmgReader : AbstractReader<DmgEntry, DmgVolume>
+        {
+            private readonly DmgArchive _archive;
+            private readonly string _fileName;
+            private readonly Stream? _partitionStream;
+
+            public override DmgVolume Volume { get; }
+
+            internal DmgReader(ReaderOptions readerOptions, DmgArchive archive, string fileName)
+                : base(readerOptions, ArchiveType.Dmg)
+            {
+                _archive = archive;
+                _fileName = fileName;
+                Volume = archive.Volumes.Single();
+
+                using var compressedStream = DmgUtil.LoadHFSPartitionStream(Volume.Stream, Volume.Header);
+                _partitionStream = compressedStream?.Decompress();
+            }
+
+            protected override IEnumerable<DmgEntry> GetEntries(Stream stream)
+            {
+                if (_partitionStream is null) return Array.Empty<DmgArchiveEntry>();
+                else return HFSUtil.LoadEntriesFromPartition(_partitionStream, _fileName, _archive);
+            }
+        }
+    }
+}

src/SharpCompress/Archives/Dmg/DmgArchiveEntry.cs

@@ -0,0 +1,32 @@
+using SharpCompress.Common.Dmg;
+using SharpCompress.Common.Dmg.HFS;
+using System;
+using System.IO;
+
+namespace SharpCompress.Archives.Dmg
+{
+    public sealed class DmgArchiveEntry : DmgEntry, IArchiveEntry
+    {
+        private readonly Stream? _stream;
+
+        public bool IsComplete { get; } = true;
+
+        public IArchive Archive { get; }
+
+        internal DmgArchiveEntry(Stream? stream, DmgArchive archive, HFSCatalogRecord record, string path, DmgFilePart part)
+            : base(record, path, stream?.Length ?? 0, part)
+        {
+            _stream = stream;
+            Archive = archive;
+        }
+
+        public Stream OpenEntryStream()
+        {
+            if (IsDirectory)
+                throw new NotSupportedException("Directories cannot be opened as stream");
+
+            _stream!.Position = 0;
+            return _stream;
+        }
+    }
+}

src/SharpCompress/Common/ArchiveException.cs

@@ -8,5 +8,10 @@ public ArchiveException(string message)
             : base(message)
         {
         }
+
+        public ArchiveException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
     }
 }

src/SharpCompress/Common/ArchiveType.cs

@@ -6,6 +6,7 @@ public enum ArchiveType
         Zip,
         Tar,
         SevenZip,
-        GZip
+        GZip,
+        Dmg
     }
 }