コード例 #1
0
 private static bool ReadHeader(Stream s, ZipEntry ze)
 {
     int signature = Shared.ReadSignature(s);
     if (IsNotValidSig(signature))
     {
         s.Seek(-4L, SeekOrigin.Current);
         if (ZipDirEntry.IsNotValidSig(signature))
         {
             throw new Exception(string.Format("  ZipEntry::Read(): Bad signature ({0:X8}) at position  0x{1:X8}", signature, s.Position));
         }
         return false;
     }
     byte[] buffer = new byte[0x1a];
     if (s.Read(buffer, 0, buffer.Length) != buffer.Length)
     {
         return false;
     }
     int num3 = 0;
     ze._VersionNeeded = (short) (buffer[num3++] + (buffer[num3++] * 0x100));
     ze._BitField = (short) (buffer[num3++] + (buffer[num3++] * 0x100));
     ze._CompressionMethod = (short) (buffer[num3++] + (buffer[num3++] * 0x100));
     ze._LastModDateTime = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100);
     if ((ze._BitField & 8) != 8)
     {
         ze._Crc32 = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100);
         ze._CompressedSize = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100);
         ze._UncompressedSize = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100);
     }
     else
     {
         num3 += 12;
     }
     short num4 = (short) (buffer[num3++] + (buffer[num3++] * 0x100));
     short num5 = (short) (buffer[num3++] + (buffer[num3++] * 0x100));
     buffer = new byte[num4];
     int num2 = s.Read(buffer, 0, buffer.Length);
     ze._FileNameInArchive = Shared.StringFromBuffer(buffer, 0, buffer.Length);
     ze._LocalFileName = ze._FileNameInArchive;
     ze._Extra = new byte[num5];
     num2 = s.Read(ze._Extra, 0, ze._Extra.Length);
     ze._LastModified = Shared.PackedToDateTime(ze._LastModDateTime);
     if ((ze._BitField & 8) == 8)
     {
         long position = s.Position;
         long num7 = Shared.FindSignature(s, 0x8074b50);
         if (num7 == -1L)
         {
             return false;
         }
         buffer = new byte[12];
         if (s.Read(buffer, 0, buffer.Length) != 12)
         {
             return false;
         }
         num3 = 0;
         ze._Crc32 = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100);
         ze._CompressedSize = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100);
         ze._UncompressedSize = ((buffer[num3++] + (buffer[num3++] * 0x100)) + ((buffer[num3++] * 0x100) * 0x100)) + (((buffer[num3++] * 0x100) * 0x100) * 0x100);
         if (num7 != ze._CompressedSize)
         {
             throw new Exception("Data format error (bit 3 is set)");
         }
         s.Seek(position, SeekOrigin.Begin);
     }
     return true;
 }
コード例 #2
0
ファイル: ZipDirEntry.cs プロジェクト: banksyhf/Auxilium-2
 internal ZipDirEntry(ZipEntry ze)
 {
 }
コード例 #3
0
 internal static ZipEntry Read(Stream s)
 {
     ZipEntry ze = new ZipEntry();
     if (!ReadHeader(s, ze))
     {
         return null;
     }
     ze.__filedata = new byte[ze.CompressedSize];
     if (s.Read(ze._FileData, 0, ze._FileData.Length) != ze._FileData.Length)
     {
         throw new Exception("badly formatted zip file.");
     }
     if ((ze._BitField & 8) == 8)
     {
         s.Seek(0x10L, SeekOrigin.Current);
     }
     return ze;
 }
コード例 #4
0
 internal static ZipEntry Create(string filename, string DirectoryPathInArchive)
 {
     ZipEntry entry = new ZipEntry {
         _LocalFileName = filename
     };
     if (DirectoryPathInArchive == null)
     {
         entry._FileNameInArchive = filename;
     }
     else
     {
         entry._FileNameInArchive = Path.Combine(DirectoryPathInArchive, Path.GetFileName(filename));
     }
     entry._LastModified = File.GetLastWriteTime(filename);
     if (entry._LastModified.IsDaylightSavingTime())
     {
         DateTime time = entry._LastModified - new TimeSpan(1, 0, 0);
         entry._LastModDateTime = Shared.DateTimeToPacked(time);
         return entry;
     }
     entry._LastModDateTime = Shared.DateTimeToPacked(entry._LastModified);
     return entry;
 }
コード例 #5
0
ファイル: ZipEntry.cs プロジェクト: banksyhf/Auxilium-2
        private static bool ReadHeader(System.IO.Stream s, ZipEntry ze)
        {
            int signature = Ionic.Utils.Zip.Shared.ReadSignature(s);

            // Return false if this is not a local file header signature.
            if (ZipEntry.IsNotValidSig(signature))
            {
                s.Seek(-4, System.IO.SeekOrigin.Current); // unread the signature
                // Getting "not a ZipEntry signature" is not always wrong or an error.
                // This can happen when walking through a zipfile.  After the last compressed entry,
                // we expect to read a ZipDirEntry signature.  When we get this is how we
                // know we've reached the end of the compressed entries.
                if (ZipDirEntry.IsNotValidSig(signature))
                {
                    throw new Exception(String.Format("  ZipEntry::Read(): Bad signature ({0:X8}) at position  0x{1:X8}", signature, s.Position));
                }
                return false;
            }

            byte[] block = new byte[26];
            int n = s.Read(block, 0, block.Length);
            if (n != block.Length) return false;

            int i = 0;
            ze._VersionNeeded = (short)(block[i++] + block[i++] * 256);
            ze._BitField = (short)(block[i++] + block[i++] * 256);
            ze._CompressionMethod = (short)(block[i++] + block[i++] * 256);
            ze._LastModDateTime = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;

            // the PKZIP spec says that if bit 3 is set (0x0008), then the CRC, Compressed size, and uncompressed size
            // come directly after the file data.  The only way to find it is to scan the zip archive for the signature of
            // the Data Descriptor, and presume that that signature does not appear in the (compressed) data of the compressed file.

            if ((ze._BitField & 0x0008) != 0x0008)
            {
                ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
                ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
                ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
            }
            else
            {
                // the CRC, compressed size, and uncompressed size are stored later in the stream.
                // here, we advance the pointer.
                i += 12;
            }

            Int16 filenameLength = (short)(block[i++] + block[i++] * 256);
            Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256);

            block = new byte[filenameLength];
            n = s.Read(block, 0, block.Length);
            ze._FileNameInArchive = Ionic.Utils.Zip.Shared.StringFromBuffer(block, 0, block.Length);

            // when creating an entry by reading, the LocalFileName is the same as the FileNameInArchivre
            ze._LocalFileName = ze._FileNameInArchive;

            ze._Extra = new byte[extraFieldLength];
            n = s.Read(ze._Extra, 0, ze._Extra.Length);

            // transform the time data into something usable
            ze._LastModified = Ionic.Utils.Zip.Shared.PackedToDateTime(ze._LastModDateTime);

            // actually get the compressed size and CRC if necessary
            if ((ze._BitField & 0x0008) == 0x0008)
            {
                long posn = s.Position;
                long SizeOfDataRead = Ionic.Utils.Zip.Shared.FindSignature(s, ZipConstants.ZipEntryDataDescriptorSignature);
                if (SizeOfDataRead == -1) return false;

                // read 3x 4-byte fields (CRC, Compressed Size, Uncompressed Size)
                block = new byte[12];
                n = s.Read(block, 0, block.Length);
                if (n != 12) return false;
                i = 0;
                ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
                ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
                ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;

                if (SizeOfDataRead != ze._CompressedSize)
                    throw new Exception("Data format error (bit 3 is set)");

                // seek back to previous position, to read file data
                s.Seek(posn, System.IO.SeekOrigin.Begin);
            }

            return true;
        }
コード例 #6
0
ファイル: ZipEntry.cs プロジェクト: banksyhf/Auxilium-2
        internal static ZipEntry Create(String filename, string DirectoryPathInArchive)
        {
            ZipEntry entry = new ZipEntry();
            entry._LocalFileName = filename;
            if (DirectoryPathInArchive == null)
                entry._FileNameInArchive = filename;
            else
            {
                // explicitly specify a pathname for this file
                entry._FileNameInArchive =
                    System.IO.Path.Combine(DirectoryPathInArchive, System.IO.Path.GetFileName(filename));
            }

            entry._LastModified = System.IO.File.GetLastWriteTime(filename);

            // adjust the time if the .NET BCL thinks it is in DST.
            // see the note elsewhere in this file for more info.
            if (entry._LastModified.IsDaylightSavingTime())
            {
                System.DateTime AdjustedTime = entry._LastModified - new System.TimeSpan(1, 0, 0);
                entry._LastModDateTime = Ionic.Utils.Zip.Shared.DateTimeToPacked(AdjustedTime);
            }
            else
                entry._LastModDateTime = Ionic.Utils.Zip.Shared.DateTimeToPacked(entry._LastModified);

            // we don't actually slurp in the file until the caller invokes Write on this entry.

            return entry;
        }
コード例 #7
0
ファイル: ZipEntry.cs プロジェクト: banksyhf/Auxilium-2
        /// <summary>
        /// Reads one ZipEntry from the given stream.
        /// </summary>
        /// <param name="s">the stream to read from.</param>
        /// <returns>the ZipEntry read from the stream.</returns>
        public static ZipEntry Read(System.IO.Stream s)
        {
            ZipEntry entry = new ZipEntry();

            if (!ReadHeader(s, entry)) return null;

            entry.__filedata = new byte[entry.CompressedSize];
            int n = s.Read(entry._FileData, 0, entry._FileData.Length);
            if (n != entry._FileData.Length)
            {
                throw new Exception("badly formatted zip file.");
            }
            // finally, seek past the (already read) Data descriptor if necessary
            if ((entry._BitField & 0x0008) == 0x0008)
            {
                s.Seek(16, System.IO.SeekOrigin.Current);
            }
            return entry;
        }