Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/DirectoryEndHeader.cs

@@ -0,0 +1,52 @@
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal class DirectoryEndHeader : ZipHeader
+    {
+        public DirectoryEndHeader()
+            : base(ZipHeaderType.DirectoryEnd)
+        {
+        }
+
+        internal override void Read(BinaryReader reader)
+        {
+            VolumeNumber = reader.ReadUInt16();
+            FirstVolumeWithDirectory = reader.ReadUInt16();
+            TotalNumberOfEntriesInDisk = reader.ReadUInt16();
+            TotalNumberOfEntries = reader.ReadUInt16();
+            DirectorySize = reader.ReadUInt32();
+            DirectoryStartOffsetRelativeToDisk = reader.ReadUInt32();
+            CommentLength = reader.ReadUInt16();
+            Comment = reader.ReadBytes(CommentLength);
+        }
+
+        internal override void Write(BinaryWriter writer)
+        {
+            writer.Write(VolumeNumber);
+            writer.Write(FirstVolumeWithDirectory);
+            writer.Write(TotalNumberOfEntriesInDisk);
+            writer.Write(TotalNumberOfEntries);
+            writer.Write(DirectorySize);
+            writer.Write(DirectoryStartOffsetRelativeToDisk);
+            writer.Write(CommentLength);
+            writer.Write(Comment);
+        }
+
+        public ushort VolumeNumber { get; private set; }
+
+        public ushort FirstVolumeWithDirectory { get; private set; }
+
+        public ushort TotalNumberOfEntriesInDisk { get; private set; }
+
+        public uint DirectorySize { get; private set; }
+
+        public uint DirectoryStartOffsetRelativeToDisk { get; private set; }
+
+        public ushort CommentLength { get; private set; }
+
+        public byte[] Comment { get; private set; }
+
+        public ushort TotalNumberOfEntries { get; private set; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs

@@ -0,0 +1,81 @@
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal class DirectoryEntryHeader : ZipFileEntry
+    {
+        public DirectoryEntryHeader()
+            : base(ZipHeaderType.DirectoryEntry)
+        {
+        }
+
+        internal override void Read(BinaryReader reader)
+        {
+            Version = reader.ReadUInt16();
+            VersionNeededToExtract = reader.ReadUInt16();
+            Flags = (HeaderFlags) reader.ReadUInt16();
+            CompressionMethod = (ZipCompressionMethod) reader.ReadUInt16();
+            LastModifiedTime = reader.ReadUInt16();
+            LastModifiedDate = reader.ReadUInt16();
+            Crc = reader.ReadUInt32();
+            CompressedSize = reader.ReadUInt32();
+            UncompressedSize = reader.ReadUInt32();
+            ushort nameLength = reader.ReadUInt16();
+            ushort extraLength = reader.ReadUInt16();
+            ushort commentLength = reader.ReadUInt16();
+            DiskNumberStart = reader.ReadUInt16();
+            InternalFileAttributes = reader.ReadUInt16();
+            ExternalFileAttributes = reader.ReadUInt32();
+            RelativeOffsetOfEntryHeader = reader.ReadUInt32();
+
+            byte[] name = reader.ReadBytes(nameLength);
+            Name = DecodeString(name);
+            byte[] extra = reader.ReadBytes(extraLength);
+            byte[] comment = reader.ReadBytes(commentLength);
+            Comment = DecodeString(comment);
+            LoadExtra(extra);
+        }
+
+        internal override void Write(BinaryWriter writer)
+        {
+            writer.Write(Version);
+            writer.Write(VersionNeededToExtract);
+            writer.Write((ushort) Flags);
+            writer.Write((ushort) CompressionMethod);
+            writer.Write(LastModifiedTime);
+            writer.Write(LastModifiedDate);
+            writer.Write(Crc);
+            writer.Write(CompressedSize);
+            writer.Write(UncompressedSize);
+
+            byte[] nameBytes = EncodeString(Name);
+            writer.Write((ushort) nameBytes.Length);
+            //writer.Write((ushort)Extra.Length);
+            writer.Write((ushort) 0);
+            writer.Write((ushort) Comment.Length);
+
+            writer.Write(DiskNumberStart);
+            writer.Write(InternalFileAttributes);
+            writer.Write(ExternalFileAttributes);
+            writer.Write(RelativeOffsetOfEntryHeader);
+
+            writer.Write(nameBytes);
+            // writer.Write(Extra);
+            writer.Write(Comment);
+        }
+
+        internal ushort Version { get; private set; }
+
+        public ushort VersionNeededToExtract { get; set; }
+
+        public uint RelativeOffsetOfEntryHeader { get; set; }
+
+        public uint ExternalFileAttributes { get; set; }
+
+        public ushort InternalFileAttributes { get; set; }
+
+        public ushort DiskNumberStart { get; set; }
+
+        public string Comment { get; private set; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/HeaderFlags.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    [Flags]
+    internal enum HeaderFlags : ushort
+    {
+        Encrypted = 1, // http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+        Bit1 = 2,
+        Bit2 = 4,
+        UsePostDataDescriptor = 8,
+        EnhancedDeflate = 16,
+        UTF8 = 2048
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/IgnoreHeader.cs

@@ -0,0 +1,22 @@
+using System;
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal class IgnoreHeader : ZipHeader
+    {
+        public IgnoreHeader(ZipHeaderType type)
+            : base(type)
+        {
+        }
+
+        internal override void Read(BinaryReader reader)
+        {
+        }
+
+        internal override void Write(BinaryWriter writer)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs

@@ -0,0 +1,66 @@
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal enum ExtraDataType : ushort
+    {
+        WinZipAes = 0x9901,
+    }
+
+    internal class ExtraData
+    {
+        internal ExtraDataType Type { get; set; }
+        internal ushort Length { get; set; }
+        internal byte[] DataBytes { get; set; }
+    }
+
+    internal class LocalEntryHeader : ZipFileEntry
+    {
+        public LocalEntryHeader()
+            : base(ZipHeaderType.LocalEntry)
+        {
+        }
+
+        internal override void Read(BinaryReader reader)
+        {
+            Version = reader.ReadUInt16();
+            Flags = (HeaderFlags) reader.ReadUInt16();
+            CompressionMethod = (ZipCompressionMethod) reader.ReadUInt16();
+            LastModifiedTime = reader.ReadUInt16();
+            LastModifiedDate = reader.ReadUInt16();
+            Crc = reader.ReadUInt32();
+            CompressedSize = reader.ReadUInt32();
+            UncompressedSize = reader.ReadUInt32();
+            ushort nameLength = reader.ReadUInt16();
+            ushort extraLength = reader.ReadUInt16();
+            byte[] name = reader.ReadBytes(nameLength);
+            byte[] extra = reader.ReadBytes(extraLength);
+            Name = DecodeString(name);
+            LoadExtra(extra);
+        }
+
+        internal override void Write(BinaryWriter writer)
+        {
+            writer.Write(Version);
+            writer.Write((ushort) Flags);
+            writer.Write((ushort) CompressionMethod);
+            writer.Write(LastModifiedTime);
+            writer.Write(LastModifiedDate);
+            writer.Write(Crc);
+            writer.Write(CompressedSize);
+            writer.Write(UncompressedSize);
+
+            byte[] nameBytes = EncodeString(Name);
+
+            writer.Write((ushort) nameBytes.Length);
+            writer.Write((ushort) 0);
+            //if (Extra != null)
+            //{
+            //    writer.Write(Extra);
+            //}
+            writer.Write(nameBytes);
+        }
+
+        internal ushort Version { get; private set; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/SplitHeader.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal class SplitHeader : ZipHeader
+    {
+        public SplitHeader()
+            : base(ZipHeaderType.Split)
+        {
+        }
+
+        internal override void Read(System.IO.BinaryReader reader)
+        {
+            throw new NotImplementedException();
+        }
+
+        internal override void Write(System.IO.BinaryWriter writer)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/ZipFileEntry..cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal abstract class ZipFileEntry : ZipHeader
+    {
+        protected ZipFileEntry(ZipHeaderType type)
+            : base(type)
+        {
+            Extra = new List<ExtraData>();
+        }
+
+
+        internal bool IsDirectory
+        {
+            get { return Name.EndsWith("/"); }
+        }
+
+        protected string DecodeString(byte[] str)
+        {
+            if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8))
+            {
+                return Encoding.UTF8.GetString(str, 0, str.Length);
+            }
+            return ArchiveEncoding.Default.GetString(str, 0, str.Length);
+        }
+
+        protected byte[] EncodeString(string str)
+        {
+            if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8))
+            {
+                return Encoding.UTF8.GetBytes(str);
+            }
+            return ArchiveEncoding.Default.GetBytes(str);
+        }
+
+        internal Stream PackedStream { get; set; }
+
+        internal string Name { get; set; }
+
+        internal HeaderFlags Flags { get; set; }
+
+        internal ZipCompressionMethod CompressionMethod { get; set; }
+
+        internal uint CompressedSize { get; set; }
+
+        internal long? DataStartPosition { get; set; }
+
+        internal uint UncompressedSize { get; set; }
+
+        internal List<ExtraData> Extra { get; set; }
+
+        internal PkwareTraditionalEncryptionData PkwareTraditionalEncryptionData { get; set; }
+#if !PORTABLE && !NETFX_CORE
+        internal WinzipAesEncryptionData WinzipAesEncryptionData { get; set; }
+#endif
+
+        internal ushort LastModifiedDate { get; set; }
+
+        internal ushort LastModifiedTime { get; set; }
+
+        internal uint Crc { get; set; }
+
+        protected void LoadExtra(byte[] extra)
+        {
+            for (int i = 0; i < extra.Length;)
+            {
+                ExtraDataType type = (ExtraDataType) BitConverter.ToUInt16(extra, i);
+                if (!Enum.IsDefined(typeof (ExtraDataType), type))
+                {
+                    return;
+                }
+                ushort length = BitConverter.ToUInt16(extra, i + 2);
+                byte[] data = new byte[length];
+                Buffer.BlockCopy(extra, i + 4, data, 0, length);
+                Extra.Add(new ExtraData
+                              {
+                                  Type = type,
+                                  Length = length,
+                                  DataBytes = data
+                              });
+                i += length + 4;
+            }
+        }
+
+        internal ZipFilePart Part { get; set; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/ZipHeader.cs

@@ -0,0 +1,21 @@
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal abstract class ZipHeader
+    {
+        protected ZipHeader(ZipHeaderType type)
+        {
+            ZipHeaderType = type;
+            HasData = true;
+        }
+
+        internal ZipHeaderType ZipHeaderType { get; private set; }
+
+        internal abstract void Read(BinaryReader reader);
+
+        internal abstract void Write(BinaryWriter writer);
+
+        internal bool HasData { get; set; }
+    }
+}

mcs/class/System.IO.Compression/SharpCompress/Common/Zip/Headers/ZipHeaderType.cs

@@ -0,0 +1,11 @@
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal enum ZipHeaderType
+    {
+        Ignore,
+        LocalEntry,
+        DirectoryEntry,
+        DirectoryEnd,
+        Split,
+    }
+}