Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/System.IO.Compression/SharpCompress/Common/ArchiveEncoding.cs

@@ -0,0 +1,29 @@
+using System.Globalization;
+using System.Text;
+
+namespace SharpCompress.Common
+{
+    internal class ArchiveEncoding
+    {
+        /// <summary>
+        /// Default encoding to use when archive format doesn't specify one.
+        /// </summary>
+        public static Encoding Default;
+
+        /// <summary>
+        /// Encoding used by encryption schemes which don't comply with RFC 2898.
+        /// </summary>
+        public static Encoding Password;
+
+        static ArchiveEncoding()
+        {
+#if PORTABLE || NETFX_CORE
+            Default = Encoding.UTF8;
+            Password = Encoding.UTF8;
+#else
+            Default = Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage);
+            Password = Encoding.Default;
+#endif
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/ArchiveException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal class ArchiveException : Exception
+    {
+        public ArchiveException(string message)
+            : base(message)
+        {
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/ArchiveExtractionEventArgs.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal class ArchiveExtractionEventArgs<T> : EventArgs
+    {
+        internal ArchiveExtractionEventArgs(T entry)
+        {
+            Item = entry;
+        }
+
+        public T Item { get; private set; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/ArchiveType.cs

@@ -0,0 +1,11 @@
+namespace SharpCompress.Common
+{
+    internal enum ArchiveType
+    {
+        Rar,
+        Zip,
+        Tar,
+        SevenZip,
+        GZip,
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/CompressedBytesReadEventArgs.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal class CompressedBytesReadEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Compressed bytes read for the current entry
+        /// </summary>
+        public long CompressedBytesRead { get; internal set; }
+
+        /// <summary>
+        /// Current file part read for Multipart files (e.g. Rar)
+        /// </summary>
+        public long CurrentFilePartCompressedBytesRead { get; internal set; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/CompressionInfo.cs

@@ -0,0 +1,30 @@
+using SharpCompress.Compressor.Deflate;
+
+namespace SharpCompress.Common
+{
+    /// <summary>
+    /// Detailed compression properties when saving.
+    /// </summary>
+    internal class CompressionInfo
+    {
+        public CompressionInfo()
+        {
+            DeflateCompressionLevel = CompressionLevel.Default;
+        }
+
+        /// <summary>
+        /// The algorthm to use.  Must be valid for the format type.
+        /// </summary>
+        public CompressionType Type { get; set; }
+
+        /// <summary>
+        /// When CompressionType.Deflate is used, this property is referenced.  Defaults to CompressionLevel.Default.
+        /// </summary>
+        public CompressionLevel DeflateCompressionLevel { get; set; }
+
+        public static implicit operator CompressionInfo(CompressionType compressionType)
+        {
+            return new CompressionInfo() {Type = compressionType};
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/CompressionType.cs

@@ -0,0 +1,16 @@
+namespace SharpCompress.Common
+{
+    internal enum CompressionType
+    {
+        None,
+        GZip,
+        BZip2,
+        PPMd,
+        Deflate,
+        Rar,
+        LZMA,
+        BCJ,
+        BCJ2,
+        Unknown,
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/CryptographicException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal class CryptographicException : Exception
+    {
+        public CryptographicException(string message)
+            : base(message)
+        {
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Entry.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+
+namespace SharpCompress.Common
+{
+    internal abstract class Entry : IEntry
+    {
+        /// <summary>
+        /// The File's 32 bit CRC Hash
+        /// </summary>
+        public abstract uint Crc { get; }
+
+        /// <summary>
+        /// The string key of the file internal to the Archive.
+        /// </summary>
+        public abstract string Key { get; }
+
+        /// <summary>
+        /// The compressed file size
+        /// </summary>
+        public abstract long CompressedSize { get; }
+
+        /// <summary>
+        /// The compression type
+        /// </summary>
+        public abstract CompressionType CompressionType { get; }
+
+        /// <summary>
+        /// The uncompressed file size
+        /// </summary>
+        public abstract long Size { get; }
+
+        /// <summary>
+        /// The entry last modified time in the archive, if recorded
+        /// </summary>
+        public abstract DateTime? LastModifiedTime { get; set; }
+
+        /// <summary>
+        /// The entry create time in the archive, if recorded
+        /// </summary>
+        public abstract DateTime? CreatedTime { get; }
+
+        /// <summary>
+        /// The entry last accessed time in the archive, if recorded
+        /// </summary>
+        public abstract DateTime? LastAccessedTime { get; }
+
+        /// <summary>
+        /// The entry time whend archived, if recorded
+        /// </summary>
+        public abstract DateTime? ArchivedTime { get; }
+
+        /// <summary>
+        /// Entry is password protected and encrypted and cannot be extracted.
+        /// </summary>
+        public abstract bool IsEncrypted { get; }
+
+        /// <summary>
+        /// Entry is password protected and encrypted and cannot be extracted.
+        /// </summary>
+        public abstract bool IsDirectory { get; }
+
+        /// <summary>
+        /// Entry is split among multiple volumes
+        /// </summary>
+        public abstract bool IsSplit { get; }
+
+        internal abstract IEnumerable<FilePart> Parts { get; }
+        internal bool IsSolid { get; set; }
+
+        internal virtual void Close()
+        {
+            
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/EntryStream.cs

@@ -0,0 +1,101 @@
+using System;
+using System.IO;
+
+namespace SharpCompress.Common
+{
+    internal class EntryStream : Stream
+    {
+        private Stream stream;
+        private bool completed;
+        private bool isDisposed;
+
+        internal EntryStream(Stream stream)
+        {
+            this.stream = stream;
+        }
+
+        /// <summary>
+        /// When reading a stream from OpenEntryStream, the stream must be completed so use this to finish reading the entire entry.
+        /// </summary>
+        public void SkipEntry()
+        {
+            var buffer = new byte[4096];
+            while (Read(buffer, 0, buffer.Length) > 0)
+            {
+            }
+            completed = true;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!completed)
+            {
+                throw new InvalidOperationException(
+                    "EntryStream has not been fully consumed.  Read the entire stream or use SkipEntry.");
+            }
+            if (isDisposed)
+            {
+                return;
+            }
+            isDisposed = true;
+            base.Dispose(disposing);
+            stream.Dispose();
+        }
+
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return false; }
+        }
+
+        public override void Flush()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override long Length
+        {
+            get { throw new System.NotImplementedException(); }
+        }
+
+        public override long Position
+        {
+            get { throw new System.NotImplementedException(); }
+            set { throw new System.NotImplementedException(); }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int read = stream.Read(buffer, offset, count);
+            if (read <= 0)
+            {
+                completed = true;
+            }
+            return read;
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/ExtractOptions.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    [Flags]
+    internal enum ExtractOptions
+    {
+        None,
+
+        /// <summary>
+        /// overwrite target if it exists
+        /// </summary>
+        Overwrite,
+
+        /// <summary>
+        /// extract with internal directory structure
+        /// </summary>
+        ExtractFullPath,
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/ExtractionException.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal class ExtractionException : Exception
+    {
+        public ExtractionException(string message)
+            : base(message)
+        {
+        }
+
+        public ExtractionException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/FilePart.cs

@@ -0,0 +1,12 @@
+using System.IO;
+
+namespace SharpCompress.Common
+{
+    internal abstract class FilePart
+    {
+        internal abstract string FilePartName { get; }
+
+        internal abstract Stream GetCompressedStream();
+        internal abstract Stream GetRawStream();
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal class FilePartExtractionBeginEventArgs : EventArgs
+    {
+        /// <summary>
+        /// File name for the part for the current entry
+        /// </summary>
+        public string Name { get; internal set; }
+
+        /// <summary>
+        /// Uncompressed size of the current entry in the part
+        /// </summary>
+        public long Size { get; internal set; }
+
+        /// <summary>
+        /// Compressed size of the current entry in the part
+        /// </summary>
+        public long CompressedSize { get; internal set; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/FlagUtility.cs

@@ -0,0 +1,130 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal static class FlagUtility
+    {
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag<T>(long bitField, T flag)
+            where T : struct
+        {
+            return HasFlag(bitField, flag);
+        }
+
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag<T>(ulong bitField, T flag)
+            where T : struct
+        {
+            return HasFlag(bitField, flag);
+        }
+
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag(ulong bitField, ulong flag)
+        {
+            return ((bitField & flag) == flag);
+        }
+
+        public static bool HasFlag(short bitField, short flag)
+        {
+            return ((bitField & flag) == flag);
+        }
+
+#if PORTABLE
+    /// <summary>
+    /// Generically checks enums in a Windows Phone 7 enivronment
+    /// </summary>
+    /// <param name="enumVal"></param>
+    /// <param name="flag"></param>
+    /// <returns></returns>
+        public static bool HasFlag(this Enum enumVal, Enum flag)
+        {
+            if (enumVal.GetHashCode() > 0) //GetHashCode returns the enum value. But it's something very crazy if not set beforehand
+            {
+                ulong num = Convert.ToUInt64(flag.GetHashCode());
+                return ((Convert.ToUInt64(enumVal.GetHashCode()) & num) == num);
+            }
+            else
+            {
+                return false;
+            }
+        }
+#endif
+
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag<T>(T bitField, T flag)
+            where T : struct
+        {
+            return HasFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag));
+        }
+
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag(long bitField, long flag)
+        {
+            return ((bitField & flag) == flag);
+        }
+
+
+        /// <summary>
+        /// Sets a bit-field to either on or off for the specified flag.
+        /// </summary>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to change</param>
+        /// <param name="on">bool</param>
+        /// <returns>The flagged variable with the flag changed</returns>
+        public static long SetFlag(long bitField, long flag, bool @on)
+        {
+            if (@on)
+            {
+                return bitField | flag;
+            }
+            return bitField & (~flag);
+        }
+
+        /// <summary>
+        /// Sets a bit-field to either on or off for the specified flag.
+        /// </summary>
+        /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to change</param>
+        /// <param name="on">bool</param>
+        /// <returns>The flagged variable with the flag changed</returns>
+        public static long SetFlag<T>(T bitField, T flag, bool @on)
+            where T : struct
+        {
+            return SetFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag), @on);
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/IEntry.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal interface IEntry
+    {
+        CompressionType CompressionType { get; }
+        DateTime? ArchivedTime { get; }
+        long CompressedSize { get; }
+        uint Crc { get; }
+        DateTime? CreatedTime { get; }
+        string Key { get; }
+        bool IsDirectory { get; }
+        bool IsEncrypted { get; }
+        bool IsSplit { get; }
+        DateTime? LastAccessedTime { get; }
+        DateTime? LastModifiedTime { get; set; }
+        long Size { get; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/IExtractionListener.cs

@@ -0,0 +1,8 @@
+namespace SharpCompress.Common
+{
+    internal interface IExtractionListener
+    {
+        void FireFilePartExtractionBegin(string name, long size, long compressedSize);
+        void FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes);
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/IVolume.cs

@@ -0,0 +1,11 @@
+using System;
+#if !PORTABLE && !NETFX_CORE
+using System.IO;
+#endif
+
+namespace SharpCompress.Common
+{
+    internal interface IVolume : IDisposable
+    {
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/IncompleteArchiveException.cs

@@ -0,0 +1,10 @@
+namespace SharpCompress.Common
+{
+    internal class IncompleteArchiveException : ArchiveException
+    {
+        public IncompleteArchiveException(string message)
+            : base(message)
+        {
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/InvalidFormatException.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace SharpCompress.Common
+{
+    internal class InvalidFormatException : ExtractionException
+    {
+        public InvalidFormatException(string message)
+            : base(message)
+        {
+        }
+
+        public InvalidFormatException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}