开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 搜索引擎 > 查看源码
Zip.cs
资源名称：Searcharoo_7_its.zip　[点击查看]
上传用户：huiyue
上传日期：2022-04-08
资源大小：1429k
文件大小：51k
源码类别：

搜索引擎

开发平台：

ASP/ASPX

Zip.cs：源码内容
  1. // Zip.cs
  2. //
  3. // Copyright (c) 2006, 2007 Microsoft Corporation.  All rights reserved.
  4. //
  5. // 
  6. // This class library reads and writes zip files, according to the format
  7. // described by pkware, at:
  8. // http://www.pkware.com/business_and_developers/developer/popups/appnote.txt
  9. //
  10. // This implementation is based on the
  11. // System.IO.Compression.DeflateStream base class in the .NET Framework
  12. // v2.0 base class library.
  13. //
  14. // There are other Zip class libraries available.  For example, it is
  15. // possible to read and write zip files within .NET via the J# runtime.
  16. // But some people don't like to install the extra DLL.  Also, there is
  17. // a 3rd party LGPL-based (or is it GPL?) library called SharpZipLib,
  18. // which works, in both .NET 1.1 and .NET 2.0.  But some people don't
  19. // like the GPL. Finally, there are commercial tools (From ComponentOne,
  20. // XCeed, etc).  But some people don't want to incur the cost.
  21. //
  22. // This alternative implementation is not GPL licensed, is free of cost,
  23. // and does not require J#. It does require .NET 2.0 (for the DeflateStream 
  24. // class).  
  25. // 
  26. // This code is released under the Microsoft Permissive License of OCtober 2006. 
  27. // See the License.txt for details.  
  28. //
  29. // Notes:
  30. // This is at best a cripppled and naive implementation. 
  31. //
  32. // Bugs:
  33. // 1. does not do 0..9 compression levels (not supported by DeflateStream)
  34. // 2. does not do encryption
  35. // 3. no support for reading or writing multi-disk zip archives
  36. // 4. no support for file comments or archive comments
  37. // 5. does not stream as it compresses; all compressed data is kept in memory.
  38. // 6. no support for double-byte chars in filenames
  39. // 7. no support for asynchronous operation
  40. // 
  41. // But it does read and write basic zip files, and it gets reasonable compression. 
  42. //
  43. // NB: PKWare's zip specification states: 
  44. //
  45. // ----------------------
  46. //   PKWARE is committed to the interoperability and advancement of the
  47. //   .ZIP format.  PKWARE offers a free license for certain technological
  48. //   aspects described above under certain restrictions and conditions.
  49. //   However, the use or implementation in a product of certain technological
  50. //   aspects set forth in the current APPNOTE, including those with regard to
  51. //   strong encryption or patching, requires a license from PKWARE.  Please 
  52. //   contact PKWARE with regard to acquiring a license.
  53. // ----------------------
  54. //    
  55. // Fri, 31 Mar 2006  14:43
  56. //
  57. // update Thu, 22 Feb 2007  19:03
  58. //  Fixed a problem with archives that had bit-3 (0x0008) set, 
  59. //  where the CRC, Compressed Size, and Uncompressed size 
  60. //  actually followed the compressed file data. 
  61. //
  65. using System;
  67. namespace ionic.utils.zip
  68. {
  70.     class Shared
  71.     {
  72.         protected internal static string StringFromBuffer(byte[] buf, int start, int maxlength)
  73.         {
  74.             int i;
  75.             char[] c = new char[maxlength];
  76.             for (i = 0; (i < maxlength) && (i < buf.Length) && (buf[i] != 0); i++)
  77.             {
  78.                 c[i] = (char)buf[i]; // System.BitConverter.ToChar(buf, start+i*2);
  79.             }
  80.             string s = new System.String(c, 0, i);
  81.             return s;
  82.         }
  84.         protected internal static int ReadSignature(System.IO.Stream s)
  85.         {
  86.             int n = 0;
  87.             byte[] sig = new byte[4];
  88.             n = s.Read(sig, 0, sig.Length);
  89.             if (n != sig.Length) throw new Exception("Could not read signature - no data!");
  90.             int signature = (((sig[3] * 256 + sig[2]) * 256) + sig[1]) * 256 + sig[0];
  91.             return signature;
  92.         }
  94.         protected internal static long FindSignature(System.IO.Stream s, int SignatureToFind)
  95.         {
  96.             long startingPosition = s.Position;
  98.             int BATCH_SIZE = 1024;
  99.             byte[] targetBytes = new byte[4];
  100.             targetBytes[0] = (byte) (SignatureToFind >> 24);
  101.             targetBytes[1] = (byte) ((SignatureToFind & 0x00FF0000) >> 16);
  102.             targetBytes[2] = (byte) ((SignatureToFind & 0x0000FF00) >> 8);
  103.             targetBytes[3] = (byte) (SignatureToFind & 0x000000FF);
  104.             byte[] batch = new byte[BATCH_SIZE];
  105.             int n = 0;
  106.             bool success = false;
  107.             do
  108.             {
  109.                 n = s.Read(batch, 0, batch.Length);
  110.                 if (n != 0)
  111.                 {
  112.                     for (int i = 0; i < n; i++)
  113.                     {
  114.                         if (batch[i] == targetBytes[3])
  115.                         {
  116.                             s.Seek(i - n, System.IO.SeekOrigin.Current);
  117.                             int sig = ReadSignature(s);
  118.                             success = (sig == SignatureToFind);
  119.                             if (!success) s.Seek(-3, System.IO.SeekOrigin.Current);
  120.                             break; // out of for loop
  121.                         }
  122.                     }
  123.                 }
  124.                 else break;
  125.                 if (success) break;
  126.             } while (true);
  127.             if (!success)
  128.             {
  129.                 s.Seek(startingPosition, System.IO.SeekOrigin.Begin);
  130.                 return -1;  // or throw?
  131.             }
  133.             // subtract 4 for the signature.
  134.             long bytesRead = (s.Position - startingPosition) - 4 ;
  135.             // number of bytes read, should be the same as compressed size of file            
  136.             return bytesRead;   
  137.         }
  138.         protected internal static DateTime PackedToDateTime(Int32 packedDateTime)
  139.         {
  140.             Int16 packedTime = (Int16)(packedDateTime & 0x0000ffff);
  141.             Int16 packedDate = (Int16)((packedDateTime & 0xffff0000) >> 16);
  143.             int year = 1980 + ((packedDate & 0xFE00) >> 9);
  144.             int month = (packedDate & 0x01E0) >> 5;
  145.             int day = packedDate & 0x001F;
  148.             int hour = (packedTime & 0xF800) >> 11;
  149.             int minute = (packedTime & 0x07E0) >> 5;
  150.             int second = packedTime & 0x001F;
  152.             DateTime d = System.DateTime.Now;
  153.             try { d = new System.DateTime(year, month, day, hour, minute, second, 0); }
  154.             catch
  155.             {
  156.                 Console.Write("nInvalid date/time?:nyear: {0} ", year);
  157.                 Console.Write("month: {0} ", month);
  158.                 Console.WriteLine("day: {0} ", day);
  159.                 Console.WriteLine("HH:MM:SS= {0}:{1}:{2}", hour, minute, second);
  160.             }
  162.             return d;
  163.         }
  166.         protected internal static Int32 DateTimeToPacked(DateTime time)
  167.         {
  168.             UInt16 packedDate = (UInt16)((time.Day & 0x0000001F) | ((time.Month << 5) & 0x000001E0) | (((time.Year - 1980) << 9) & 0x0000FE00));
  169.             UInt16 packedTime = (UInt16)((time.Second & 0x0000001F) | ((time.Minute << 5) & 0x000007E0) | ((time.Hour << 11) & 0x0000F800));
  170.             return (Int32)(((UInt32)(packedDate << 16)) | packedTime);
  171.         }
  172.     }
  178.     public class ZipDirEntry
  179.     {
  181.         internal const int ZipDirEntrySignature = 0x02014b50;
  183.         private bool _Debug = false;
  185.         private ZipDirEntry() { }
  187.         private DateTime _LastModified;
  188.         public DateTime LastModified
  189.         {
  190.             get { return _LastModified; }
  191.         }
  193.         private string _FileName;
  194.         public string FileName
  195.         {
  196.             get { return _FileName; }
  197.         }
  199.         private string _Comment;
  200.         public string Comment
  201.         {
  202.             get { return _Comment; }
  203.         }
  205.         private Int16 _VersionMadeBy;
  206.         public Int16 VersionMadeBy
  207.         {
  208.             get { return _VersionMadeBy; }
  209.         }
  211.         private Int16 _VersionNeeded;
  212.         public Int16 VersionNeeded
  213.         {
  214.             get { return _VersionNeeded; }
  215.         }
  217.         private Int16 _CompressionMethod;
  218.         public Int16 CompressionMethod
  219.         {
  220.             get { return _CompressionMethod; }
  221.         }
  223.         private Int32 _CompressedSize;
  224.         public Int32 CompressedSize
  225.         {
  226.             get { return _CompressedSize; }
  227.         }
  229.         private Int32 _UncompressedSize;
  230.         public Int32 UncompressedSize
  231.         {
  232.             get { return _UncompressedSize; }
  233.         }
  235.         public Double CompressionRatio
  236.         {
  237.             get
  238.             {
  239.                 return 100 * (1.0 - (1.0 * CompressedSize) / (1.0 * UncompressedSize));
  240.             }
  241.         }
  243.         private Int16 _BitField;
  244.         private Int32 _LastModDateTime;
  246.         private Int32 _Crc32;
  247.         private byte[] _Extra;
  249.         internal ZipDirEntry(ZipEntry ze) { }
  252.         public static ZipDirEntry Read(System.IO.Stream s)
  253.         {
  254.             return Read(s, false);
  255.         }
  258.         public static ZipDirEntry Read(System.IO.Stream s, bool TurnOnDebug)
  259.         {
  261.             int signature = ionic.utils.zip.Shared.ReadSignature(s);
  262.             // return null if this is not a local file header signature
  263.             if (SignatureIsNotValid(signature))
  264.             {
  265.                 s.Seek(-4, System.IO.SeekOrigin.Current);
  266.                 if (TurnOnDebug) System.Console.WriteLine("  ZipDirEntry::Read(): Bad signature ({0:X8}) at position {1}", signature, s.Position);
  267.                 return null;
  268.             }
  270.             byte[] block = new byte[42];
  271.             int n = s.Read(block, 0, block.Length);
  272.             if (n != block.Length) return null;
  274.             int i = 0;
  275.             ZipDirEntry zde = new ZipDirEntry();
  277.             zde._Debug = TurnOnDebug;
  278.             zde._VersionMadeBy = (short)(block[i++] + block[i++] * 256);
  279.             zde._VersionNeeded = (short)(block[i++] + block[i++] * 256);
  280.             zde._BitField = (short)(block[i++] + block[i++] * 256);
  281.             zde._CompressionMethod = (short)(block[i++] + block[i++] * 256);
  282.             zde._LastModDateTime = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  283.             zde._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  284.             zde._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  285.             zde._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  287.             zde._LastModified = ionic.utils.zip.Shared.PackedToDateTime(zde._LastModDateTime);
  289.             Int16 filenameLength = (short)(block[i++] + block[i++] * 256);
  290.             Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256);
  291.             Int16 commentLength = (short)(block[i++] + block[i++] * 256);
  292.             Int16 diskNumber = (short)(block[i++] + block[i++] * 256);
  293.             Int16 internalFileAttrs = (short)(block[i++] + block[i++] * 256);
  294.             Int32 externalFileAttrs = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  295.             Int32 Offset = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  297.             block = new byte[filenameLength];
  298.             n = s.Read(block, 0, block.Length);
  299.             zde._FileName = ionic.utils.zip.Shared.StringFromBuffer(block, 0, block.Length);
  301.             zde._Extra = new byte[extraFieldLength];
  302.             n = s.Read(zde._Extra, 0, zde._Extra.Length);
  304.             block = new byte[commentLength];
  305.             n = s.Read(block, 0, block.Length);
  306.             zde._Comment = ionic.utils.zip.Shared.StringFromBuffer(block, 0, block.Length);
  308.             return zde;
  309.         }
  311.         private static bool SignatureIsNotValid(int signature)
  312.         {
  313.             return (signature != ZipDirEntrySignature);
  314.         }
  316.     }
  318.     public class ZipEntry
  319.     {
  321.         private const int ZipEntrySignature = 0x04034b50;
  322.         private const int ZipEntryDataDescriptorSignature= 0x08074b50;
  323.  
  324.         private bool _Debug = false;
  326.         private DateTime _LastModified;
  327.         public DateTime LastModified
  328.         {
  329.             get { return _LastModified; }
  330.         }
  332.         private string _FileName;
  333.         public string FileName
  334.         {
  335.             get { return _FileName; }
  336.         }
  338.         private Int16 _VersionNeeded;
  339.         public Int16 VersionNeeded
  340.         {
  341.             get { return _VersionNeeded; }
  342.         }
  344.         private Int16 _BitField;
  345.         public Int16 BitField
  346.         {
  347.             get { return _BitField; }
  348.         }
  350.         private Int16 _CompressionMethod;
  351.         public Int16 CompressionMethod
  352.         {
  353.             get { return _CompressionMethod; }
  354.         }
  356.         private Int32 _CompressedSize;
  357.         public Int32 CompressedSize
  358.         {
  359.             get { return _CompressedSize; }
  360.         }
  362.         private Int32 _UncompressedSize;
  363.         public Int32 UncompressedSize
  364.         {
  365.             get { return _UncompressedSize; }
  366.         }
  368.         public Double CompressionRatio
  369.         {
  370.             get
  371.             {
  372.                 return 100 * (1.0 - (1.0 * CompressedSize) / (1.0 * UncompressedSize));
  373.             }
  374.         }
  376.         private Int32 _LastModDateTime;
  377.         private Int32 _Crc32;
  378.         private byte[] _Extra;
  380.         private byte[] __filedata;
  381.         private byte[] _FileData
  382.         {
  383.             get
  384.             {
  385.                 if (__filedata == null)
  386.                 {
  387.                 }
  388.                 return __filedata;
  389.             }
  390.         }
  392.         private System.IO.MemoryStream _UnderlyingMemoryStream;
  393.         private System.IO.Compression.DeflateStream _CompressedStream;
  394.         private System.IO.Compression.DeflateStream CompressedStream
  395.         {
  396.             get
  397.             {
  398.                 if (_CompressedStream == null)
  399.                 {
  400.                     _UnderlyingMemoryStream = new System.IO.MemoryStream();
  401.                     bool LeaveUnderlyingStreamOpen = true;
  402.                     _CompressedStream = new System.IO.Compression.DeflateStream(_UnderlyingMemoryStream,
  403.                                                     System.IO.Compression.CompressionMode.Compress,
  404.                                                     LeaveUnderlyingStreamOpen);
  405.                 }
  406.                 return _CompressedStream;
  407.             }
  408.         }
  410.         private byte[] _header;
  411.         internal byte[] Header
  412.         {
  413.             get
  414.             {
  415.                 return _header;
  416.             }
  417.         }
  419.         private int _RelativeOffsetOfHeader;
  422.         private static bool ReadHeader(System.IO.Stream s, ZipEntry ze)
  423.         {
  424.             int signature = ionic.utils.zip.Shared.ReadSignature(s);
  426.             // return null if this is not a local file header signature
  427.             if (SignatureIsNotValid(signature))
  428.             {
  429.                 s.Seek(-4, System.IO.SeekOrigin.Current);
  430.                 if (ze._Debug) System.Console.WriteLine("  ZipEntry::Read(): Bad signature ({0:X8}) at position {1}", signature, s.Position);
  431.                 return false;
  432.             }
  434.             byte[] block = new byte[26];
  435.             int n = s.Read(block, 0, block.Length);
  436.             if (n != block.Length) return false;
  438.             int i = 0;
  439.             ze._VersionNeeded = (short)(block[i++] + block[i++] * 256);
  440.             ze._BitField = (short)(block[i++] + block[i++] * 256);
  441.             ze._CompressionMethod = (short)(block[i++] + block[i++] * 256);
  442.             ze._LastModDateTime = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  444.             // the PKZIP spec says that if bit 3 is set (0x0008), then the CRC, Compressed size, and uncompressed size
  445.             // come directly after the file data.  The only way to find it is to scan the zip archive for the signature of 
  446.             // the Data Descriptor, and presume that that signature does not appear in the (compressed) data of the compressed file.  
  448.             if ((ze._BitField & 0x0008) != 0x0008)
  449.             {
  450.                 ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  451.                 ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  452.                 ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  453.             }
  454.             else
  455.             {
  456.                 // the CRC, compressed size, and uncompressed size are stored later in the stream.
  457.                 // here, we advance the pointer.
  458.                 i += 12;
  459.             }
  461.             Int16 filenameLength = (short)(block[i++] + block[i++] * 256);
  462.             Int16 extraFieldLength = (short)(block[i++] + block[i++] * 256);
  464.             block = new byte[filenameLength];
  465.             n = s.Read(block, 0, block.Length);
  466.             ze._FileName = ionic.utils.zip.Shared.StringFromBuffer(block, 0, block.Length);
  468.             ze._Extra = new byte[extraFieldLength];
  469.             n = s.Read(ze._Extra, 0, ze._Extra.Length);
  471.             // transform the time data into something usable
  472.             ze._LastModified = ionic.utils.zip.Shared.PackedToDateTime(ze._LastModDateTime);
  474.             // actually get the compressed size and CRC if necessary
  475.             if ((ze._BitField & 0x0008) == 0x0008)
  476.             {
  477.                 long posn = s.Position;
  478.                 long SizeOfDataRead = ionic.utils.zip.Shared.FindSignature(s, ZipEntryDataDescriptorSignature);
  479.                 if (SizeOfDataRead == -1) return false; 
  481.                 // read 3x 4-byte fields (CRC, Compressed Size, Uncompressed Size)
  482.                 block = new byte[12];
  483.                 n = s.Read(block, 0, block.Length);
  484.                 if (n != 12) return false;
  485.                 i = 0;
  486.                 ze._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  487.                 ze._CompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  488.                 ze._UncompressedSize = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256;
  490.                 if (SizeOfDataRead != ze._CompressedSize)
  491.                     throw new Exception("Data format error (bit 3 is set)"); 
  492.                 
  493.                 // seek back to previous position, to read file data
  494.                 s.Seek(posn, System.IO.SeekOrigin.Begin);
  495.             }
  497.             return true;
  498.         }
  501.         private static bool SignatureIsNotValid(int signature)
  502.         {
  503.             return (signature != ZipEntrySignature);
  504.         }
  507.         public static ZipEntry Read(System.IO.Stream s)
  508.         {
  509.             return Read(s, false);
  510.         }
  513.         public static ZipEntry Read(System.IO.Stream s, bool TurnOnDebug)
  514.         {
  515.             ZipEntry entry = new ZipEntry();
  516.             entry._Debug = TurnOnDebug;
  517.             if (!ReadHeader(s, entry)) return null;
  519.             entry.__filedata = new byte[entry.CompressedSize];
  520.             int n = s.Read(entry._FileData, 0, entry._FileData.Length);
  521.             if (n != entry._FileData.Length)
  522.             {
  523.                 throw new Exception("badly formatted zip file.");
  524.             }
  525.             // finally, seek past the (already read) Data descriptor if necessary
  526.             if ((entry._BitField & 0x0008) == 0x0008)
  527.             {
  528.                 s.Seek(16, System.IO.SeekOrigin.Current);
  529.             }
  530.             return entry;
  531.         }
  535.         internal static ZipEntry Create(String filename)
  536.         {
  537.             ZipEntry entry = new ZipEntry();
  538.             entry._FileName = filename;
  540.             entry._LastModified = System.IO.File.GetLastWriteTime(filename);
  541.             if (entry._LastModified.IsDaylightSavingTime())
  542.             {
  543.                 System.DateTime AdjustedTime = entry._LastModified - new System.TimeSpan(1, 0, 0);
  544.                 entry._LastModDateTime = ionic.utils.zip.Shared.DateTimeToPacked(AdjustedTime);
  545.             }
  546.             else
  547.                 entry._LastModDateTime = ionic.utils.zip.Shared.DateTimeToPacked(entry._LastModified);
  549.             // we don't actually slurp in the file until the caller invokes Write on this entry.
  551.             return entry;
  552.         }
  556.         public void Extract()
  557.         {
  558.             Extract(".");
  559.         }
  561.         public void Extract(System.IO.Stream s)
  562.         {
  563.             Extract(null, s);
  564.         }
  566.         public void Extract(string basedir)
  567.         {
  568.             Extract(basedir, null);
  569.         }
  572.         // pass in either basdir or s, but not both. 
  573.         private void Extract(string basedir, System.IO.Stream s)
  574.         {
  575.             string TargetFile = null;
  576.             if (basedir != null)
  577.             {
  578.                 TargetFile = System.IO.Path.Combine(basedir, FileName);
  580.                 // check if a directory
  581.                 if (FileName.EndsWith("/"))
  582.                 {
  583.                     if (!System.IO.Directory.Exists(TargetFile))
  584.                         System.IO.Directory.CreateDirectory(TargetFile);
  585.                     return;
  586.                 }
  587.             }
  588.             else if (s != null)
  589.             {
  590.                 if (FileName.EndsWith("/"))
  591.                     // extract a directory to streamwriter?  nothing to do!
  592.                     return;
  593.             }
  594.             else throw new Exception("Invalid input.");
  597.             using (System.IO.MemoryStream memstream = new System.IO.MemoryStream(_FileData))
  598.             {
  600.                 System.IO.Stream input = null;
  601.                 try
  602.                 {
  604.                     if (CompressedSize == UncompressedSize)
  605.                     {
  606.                         // the System.IO.Compression.DeflateStream class does not handle uncompressed data.
  607.                         // so if an entry is not compressed, then we just translate the bytes directly.
  608.                         input = memstream;
  609.                     }
  610.                     else
  611.                     {
  612.                         input = new System.IO.Compression.DeflateStream(memstream, System.IO.Compression.CompressionMode.Decompress);
  613.                     }
  616.                     if (TargetFile != null)
  617.                     {
  618.                         // ensure the target path exists
  619.                         if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(TargetFile)))
  620.                         {
  621.                             System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(TargetFile));
  622.                         }
  623.                     }
  626.                     System.IO.Stream output = null;
  627.                     try
  628.                     {
  629.                         if (TargetFile != null)
  630.                             output = new System.IO.FileStream(TargetFile, System.IO.FileMode.CreateNew);
  631.                         else
  632.                             output = s;
  635.                         byte[] bytes = new byte[4096];
  636.                         int n;
  638.                         if (_Debug)
  639.                         {
  640.                             Console.WriteLine("{0}: _FileData.Length= {1}", TargetFile, _FileData.Length);
  641.                             Console.WriteLine("{0}: memstream.Position: {1}", TargetFile, memstream.Position);
  642.                             n = _FileData.Length;
  643.                             if (n > 1000)
  644.                             {
  645.                                 n = 500;
  646.                                 Console.WriteLine("{0}: truncating dump from {1} to {2} bytes...", TargetFile, _FileData.Length, n);
  647.                             }
  648.                             for (int j = 0; j < n; j += 2)
  649.                             {
  650.                                 if ((j > 0) && (j % 40 == 0))
  651.                                     System.Console.WriteLine();
  652.                                 System.Console.Write(" {0:X2}", _FileData[j]);
  653.                                 if (j + 1 < n)
  654.                                     System.Console.Write("{0:X2}", _FileData[j + 1]);
  655.                             }
  656.                             System.Console.WriteLine("n");
  657.                         }
  659.                         n = 1; // anything non-zero
  660.                         while (n != 0)
  661.                         {
  662.                             if (_Debug) Console.WriteLine("{0}: about to read...", TargetFile);
  663.                             n = input.Read(bytes, 0, bytes.Length);
  664.                             if (_Debug) Console.WriteLine("{0}: got {1} bytes", TargetFile, n);
  665.                             if (n > 0)
  666.                             {
  667.                                 if (_Debug) Console.WriteLine("{0}: about to write...", TargetFile);
  668.                                 output.Write(bytes, 0, n);
  669.                             }
  670.                         }
  671.                     }
  672.                     finally
  673.                     {
  674.                         // we only close the output stream if we opened it. 
  675.                         if ((output != null) && (TargetFile != null))
  676.                         {
  677.                             output.Close();
  678.                             output.Dispose();
  679.                         }
  680.                     }
  682.                     if (TargetFile != null)
  683.                     {
  684.                         // We may have to adjust the last modified time to compensate
  685.                         // for differences in how the .NET Base Class Library deals
  686.                         // with daylight saving time (DST) versus how the Windows
  687.                         // filesystem deals with daylight saving time.
  688.                         if (LastModified.IsDaylightSavingTime())
  689.                         {
  690.                             DateTime AdjustedLastModified = LastModified + new System.TimeSpan(1, 0, 0);
  691.                             System.IO.File.SetLastWriteTime(TargetFile, AdjustedLastModified);
  692.                         }
  693.                         else
  694.                             System.IO.File.SetLastWriteTime(TargetFile, LastModified);
  695.                     }
  697.                 }
  698.                 finally
  699.                 {
  700.                     // we cannot use using() here because in some cases we do not want to Dispose the stream
  701.                     if ((input != null) && (input != memstream))
  702.                     {
  703.                         input.Close();
  704.                         input.Dispose();
  705.                     }
  706.                 }
  707.             }
  708.         }
  711.         internal void WriteCentralDirectoryEntry(System.IO.Stream s)
  712.         {
  713.             byte[] bytes = new byte[4096];
  714.             int i = 0;
  715.             // signature
  716.             bytes[i++] = (byte)(ZipDirEntry.ZipDirEntrySignature & 0x000000FF);
  717.             bytes[i++] = (byte)((ZipDirEntry.ZipDirEntrySignature & 0x0000FF00) >> 8);
  718.             bytes[i++] = (byte)((ZipDirEntry.ZipDirEntrySignature & 0x00FF0000) >> 16);
  719.             bytes[i++] = (byte)((ZipDirEntry.ZipDirEntrySignature & 0xFF000000) >> 24);
  721.             // Version Made By
  722.             bytes[i++] = Header[4];
  723.             bytes[i++] = Header[5];
  725.             // Version Needed, Bitfield, compression method, lastmod,
  726.             // crc, sizes, filename length and extra field length -
  727.             // are all the same as the local file header. So just copy them
  728.             int j = 0;
  729.             for (j = 0; j < 26; j++)
  730.                 bytes[i + j] = Header[4 + j];
  732.             i += j;  // positioned at next available byte
  734.             // File Comment Length
  735.             bytes[i++] = 0;
  736.             bytes[i++] = 0;
  738.             // Disk number start
  739.             bytes[i++] = 0;
  740.             bytes[i++] = 0;
  742.             // internal file attrs
  743.             // TODO: figure out what is required here. 
  744.             bytes[i++] = 1;
  745.             bytes[i++] = 0;
  747.             // external file attrs
  748.             // TODO: figure out what is required here. 
  749.             bytes[i++] = 0x20;
  750.             bytes[i++] = 0;
  751.             bytes[i++] = 0xb6;
  752.             bytes[i++] = 0x81;
  754.             // relative offset of local header (I think this can be zero)
  755.             bytes[i++] = (byte)(_RelativeOffsetOfHeader & 0x000000FF);
  756.             bytes[i++] = (byte)((_RelativeOffsetOfHeader & 0x0000FF00) >> 8);
  757.             bytes[i++] = (byte)((_RelativeOffsetOfHeader & 0x00FF0000) >> 16);
  758.             bytes[i++] = (byte)((_RelativeOffsetOfHeader & 0xFF000000) >> 24);
  760.             if (_Debug) System.Console.WriteLine("ninserting filename into CDS: (length= {0})", Header.Length - 30);
  761.             // actual filename (starts at offset 34 in header) 
  762.             for (j = 0; j < Header.Length - 30; j++)
  763.             {
  764.                 bytes[i + j] = Header[30 + j];
  765.                 if (_Debug) System.Console.Write(" {0:X2}", bytes[i + j]);
  766.             }
  767.             if (_Debug) System.Console.WriteLine();
  768.             i += j;
  770.             s.Write(bytes, 0, i);
  771.         }
  774.         private void WriteHeader(System.IO.Stream s, byte[] bytes)
  775.         {
  776.             // write the header info
  778.             int i = 0;
  779.             // signature
  780.             bytes[i++] = (byte)(ZipEntrySignature & 0x000000FF);
  781.             bytes[i++] = (byte)((ZipEntrySignature & 0x0000FF00) >> 8);
  782.             bytes[i++] = (byte)((ZipEntrySignature & 0x00FF0000) >> 16);
  783.             bytes[i++] = (byte)((ZipEntrySignature & 0xFF000000) >> 24);
  785.             // version needed
  786.             Int16 FixedVersionNeeded = 0x14; // from examining existing zip files
  787.             bytes[i++] = (byte)(FixedVersionNeeded & 0x00FF);
  788.             bytes[i++] = (byte)((FixedVersionNeeded & 0xFF00) >> 8);
  790.             // bitfield
  791.             Int16 BitField = 0x00; // from examining existing zip files
  792.             bytes[i++] = (byte)(BitField & 0x00FF);
  793.             bytes[i++] = (byte)((BitField & 0xFF00) >> 8);
  795.             // compression method
  796.             Int16 CompressionMethod = 0x08; // 0x08 = Deflate
  797.             bytes[i++] = (byte)(CompressionMethod & 0x00FF);
  798.             bytes[i++] = (byte)((CompressionMethod & 0xFF00) >> 8);
  800.             // LastMod
  801.             bytes[i++] = (byte)(_LastModDateTime & 0x000000FF);
  802.             bytes[i++] = (byte)((_LastModDateTime & 0x0000FF00) >> 8);
  803.             bytes[i++] = (byte)((_LastModDateTime & 0x00FF0000) >> 16);
  804.             bytes[i++] = (byte)((_LastModDateTime & 0xFF000000) >> 24);
  806.             // CRC32 (Int32)
  807.             CRC32 crc32 = new CRC32();
  808.             UInt32 crc = 0;
  809.             using (System.IO.Stream input = System.IO.File.OpenRead(FileName))
  810.             {
  811.                 crc = crc32.GetCrc32AndCopy(input, CompressedStream);
  812.             }
  813.             CompressedStream.Close();  // to get the footer bytes written to the underlying stream
  815.             bytes[i++] = (byte)(crc & 0x000000FF);
  816.             bytes[i++] = (byte)((crc & 0x0000FF00) >> 8);
  817.             bytes[i++] = (byte)((crc & 0x00FF0000) >> 16);
  818.             bytes[i++] = (byte)((crc & 0xFF000000) >> 24);
  820.             // CompressedSize (Int32)
  821.             Int32 isz = (Int32)_UnderlyingMemoryStream.Length;
  822.             UInt32 sz = (UInt32)isz;
  823.             bytes[i++] = (byte)(sz & 0x000000FF);
  824.             bytes[i++] = (byte)((sz & 0x0000FF00) >> 8);
  825.             bytes[i++] = (byte)((sz & 0x00FF0000) >> 16);
  826.             bytes[i++] = (byte)((sz & 0xFF000000) >> 24);
  828.             // UncompressedSize (Int32)
  829.             if (_Debug) System.Console.WriteLine("Uncompressed Size: {0}", crc32.TotalBytesRead);
  830.             bytes[i++] = (byte)(crc32.TotalBytesRead & 0x000000FF);
  831.             bytes[i++] = (byte)((crc32.TotalBytesRead & 0x0000FF00) >> 8);
  832.             bytes[i++] = (byte)((crc32.TotalBytesRead & 0x00FF0000) >> 16);
  833.             bytes[i++] = (byte)((crc32.TotalBytesRead & 0xFF000000) >> 24);
  835.             // filename length (Int16)
  836.             Int16 length = (Int16)FileName.Length;
  837.             bytes[i++] = (byte)(length & 0x00FF);
  838.             bytes[i++] = (byte)((length & 0xFF00) >> 8);
  840.             // extra field length (short)
  841.             Int16 ExtraFieldLength = 0x00;
  842.             bytes[i++] = (byte)(ExtraFieldLength & 0x00FF);
  843.             bytes[i++] = (byte)((ExtraFieldLength & 0xFF00) >> 8);
  845.             // actual filename
  846.             char[] c = FileName.ToCharArray();
  847.             int j = 0;
  849.             if (_Debug)
  850.             {
  851.                 System.Console.WriteLine("local header: writing filename, {0} chars", c.Length);
  852.                 System.Console.WriteLine("starting offset={0}", i);
  853.             }
  854.             for (j = 0; (j < c.Length) && (i + j < bytes.Length); j++)
  855.             {
  856.                 bytes[i + j] = System.BitConverter.GetBytes(c[j])[0];
  857.                 if (_Debug) System.Console.Write(" {0:X2}", bytes[i + j]);
  858.             }
  859.             if (_Debug) System.Console.WriteLine();
  861.             i += j;
  863.             // extra field (we always write null in this implementation)
  864.             // ;;
  866.             // remember the file offset of this header
  867.             _RelativeOffsetOfHeader = (int)s.Length;
  870.             if (_Debug)
  871.             {
  872.                 System.Console.WriteLine("nAll header data:");
  873.                 for (j = 0; j < i; j++)
  874.                     System.Console.Write(" {0:X2}", bytes[j]);
  875.                 System.Console.WriteLine();
  876.             }
  877.             // finally, write the header to the stream
  878.             s.Write(bytes, 0, i);
  880.             // preserve this header data for use with the central directory structure.
  881.             _header = new byte[i];
  882.             if (_Debug) System.Console.WriteLine("preserving header of {0} bytes", _header.Length);
  883.             for (j = 0; j < i; j++)
  884.                 _header[j] = bytes[j];
  886.         }
  889.         internal void Write(System.IO.Stream s)
  890.         {
  891.             byte[] bytes = new byte[4096];
  892.             int n;
  894.             // write the header:
  895.             WriteHeader(s, bytes);
  897.             // write the actual file data: 
  898.             _UnderlyingMemoryStream.Position = 0;
  900.             if (_Debug)
  901.             {
  902.                 Console.WriteLine("{0}: writing compressed data to zipfile...", FileName);
  903.                 Console.WriteLine("{0}: total data length: {1}", FileName, _UnderlyingMemoryStream.Length);
  904.             }
  905.             while ((n = _UnderlyingMemoryStream.Read(bytes, 0, bytes.Length)) != 0)
  906.             {
  908.                 if (_Debug)
  909.                 {
  910.                     Console.WriteLine("{0}: transferring {1} bytes...", FileName, n);
  912.                     for (int j = 0; j < n; j += 2)
  913.                     {
  914.                         if ((j > 0) && (j % 40 == 0))
  915.                             System.Console.WriteLine();
  916.                         System.Console.Write(" {0:X2}", bytes[j]);
  917.                         if (j + 1 < n)
  918.                             System.Console.Write("{0:X2}", bytes[j + 1]);
  919.                     }
  920.                     System.Console.WriteLine("n");
  921.                 }
  923.                 s.Write(bytes, 0, n);
  924.             }
  926.             //_CompressedStream.Close();
  927.             //_CompressedStream= null;
  928.             _UnderlyingMemoryStream.Close();
  929.             _UnderlyingMemoryStream = null;
  930.         }
  931.     }
  936.     public class ZipFile : System.Collections.Generic.IEnumerable<ZipEntry>,
  937.       IDisposable
  938.     {
  939.         private string _name;
  940.         public string Name
  941.         {
  942.             get { return _name; }
  943.         }
  945.         private System.IO.Stream ReadStream
  946.         {
  947.             get
  948.             {
  949.                 if (_readstream == null)
  950.                 {
  951.                     _readstream = System.IO.File.OpenRead(_name);
  952.                 }
  953.                 return _readstream;
  954.             }
  955.         }
  957.         private System.IO.FileStream WriteStream
  958.         {
  959.             get
  960.             {
  961.                 if (_writestream == null)
  962.                 {
  963.                     _writestream = new System.IO.FileStream(_name, System.IO.FileMode.CreateNew);
  964.                 }
  965.                 return _writestream;
  966.             }
  967.         }
  969.         private ZipFile() { }
  972.         #region For Writing Zip Files
  974.         public ZipFile(string NewZipFileName)
  975.         {
  976.             // create a new zipfile
  977.             _name = NewZipFileName;
  978.             if (System.IO.File.Exists(_name))
  979.                 throw new System.Exception(String.Format("That file ({0}) already exists.", NewZipFileName));
  980.             _entries = new System.Collections.Generic.List<ZipEntry>();
  981.         }
  984.         public void AddItem(string FileOrDirectoryName)
  985.         {
  986.             AddItem(FileOrDirectoryName, false);
  987.         }
  989.         public void AddItem(string FileOrDirectoryName, bool WantVerbose)
  990.         {
  991.             if (System.IO.File.Exists(FileOrDirectoryName))
  992.                 AddFile(FileOrDirectoryName, WantVerbose);
  993.             else if (System.IO.Directory.Exists(FileOrDirectoryName))
  994.                 AddDirectory(FileOrDirectoryName, WantVerbose);
  996.             else
  997.                 throw new Exception(String.Format("That file or directory ({0}) does not exist!", FileOrDirectoryName));
  998.         }
  1000.         public void AddFile(string FileName)
  1001.         {
  1002.             AddFile(FileName, false);
  1003.         }
  1005.         public void AddFile(string FileName, bool WantVerbose)
  1006.         {
  1007.             ZipEntry ze = ZipEntry.Create(FileName);
  1008.             if (WantVerbose) Console.WriteLine("adding {0}...", FileName);
  1009.             _entries.Add(ze);
  1010.         }
  1012.         public void AddDirectory(string DirectoryName)
  1013.         {
  1014.             AddDirectory(DirectoryName, false);
  1015.         }
  1017.         public void AddDirectory(string DirectoryName, bool WantVerbose)
  1018.         {
  1019.             String[] filenames = System.IO.Directory.GetFiles(DirectoryName);
  1020.             foreach (String filename in filenames)
  1021.             {
  1022.                 if (WantVerbose) Console.WriteLine("adding {0}...", filename);
  1023.                 AddFile(filename);
  1024.             }
  1026.             String[] dirnames = System.IO.Directory.GetDirectories(DirectoryName);
  1027.             foreach (String dir in dirnames)
  1028.             {
  1029.                 AddDirectory(dir, WantVerbose);
  1030.             }
  1031.         }
  1034.         public void Save()
  1035.         {
  1036.             // an entry for each file
  1037.             foreach (ZipEntry e in _entries)
  1038.             {
  1039.                 e.Write(WriteStream);
  1040.             }
  1042.             WriteCentralDirectoryStructure();
  1043.             WriteStream.Close();
  1044.             _writestream = null;
  1045.         }
  1048.         private void WriteCentralDirectoryStructure()
  1049.         {
  1050.             // the central directory structure
  1051.             long Start = WriteStream.Length;
  1052.             foreach (ZipEntry e in _entries)
  1053.             {
  1054.                 e.WriteCentralDirectoryEntry(WriteStream);
  1055.             }
  1056.             long Finish = WriteStream.Length;
  1058.             // now, the footer
  1059.             WriteCentralDirectoryFooter(Start, Finish);
  1060.         }
  1063.         private void WriteCentralDirectoryFooter(long StartOfCentralDirectory, long EndOfCentralDirectory)
  1064.         {
  1065.             byte[] bytes = new byte[1024];
  1066.             int i = 0;
  1067.             // signature
  1068.             UInt32 EndOfCentralDirectorySignature = 0x06054b50;
  1069.             bytes[i++] = (byte)(EndOfCentralDirectorySignature & 0x000000FF);
  1070.             bytes[i++] = (byte)((EndOfCentralDirectorySignature & 0x0000FF00) >> 8);
  1071.             bytes[i++] = (byte)((EndOfCentralDirectorySignature & 0x00FF0000) >> 16);
  1072.             bytes[i++] = (byte)((EndOfCentralDirectorySignature & 0xFF000000) >> 24);
  1074.             // number of this disk
  1075.             bytes[i++] = 0;
  1076.             bytes[i++] = 0;
  1078.             // number of the disk with the start of the central directory
  1079.             bytes[i++] = 0;
  1080.             bytes[i++] = 0;
  1082.             // total number of entries in the central dir on this disk
  1083.             bytes[i++] = (byte)(_entries.Count & 0x00FF);
  1084.             bytes[i++] = (byte)((_entries.Count & 0xFF00) >> 8);
  1086.             // total number of entries in the central directory
  1087.             bytes[i++] = (byte)(_entries.Count & 0x00FF);
  1088.             bytes[i++] = (byte)((_entries.Count & 0xFF00) >> 8);
  1090.             // size of the central directory
  1091.             Int32 SizeOfCentralDirectory = (Int32)(EndOfCentralDirectory - StartOfCentralDirectory);
  1092.             bytes[i++] = (byte)(SizeOfCentralDirectory & 0x000000FF);
  1093.             bytes[i++] = (byte)((SizeOfCentralDirectory & 0x0000FF00) >> 8);
  1094.             bytes[i++] = (byte)((SizeOfCentralDirectory & 0x00FF0000) >> 16);
  1095.             bytes[i++] = (byte)((SizeOfCentralDirectory & 0xFF000000) >> 24);
  1097.             // offset of the start of the central directory 
  1098.             Int32 StartOffset = (Int32)StartOfCentralDirectory;  // cast down from Long
  1099.             bytes[i++] = (byte)(StartOffset & 0x000000FF);
  1100.             bytes[i++] = (byte)((StartOffset & 0x0000FF00) >> 8);
  1101.             bytes[i++] = (byte)((StartOffset & 0x00FF0000) >> 16);
  1102.             bytes[i++] = (byte)((StartOffset & 0xFF000000) >> 24);
  1104.             // zip comment length
  1105.             bytes[i++] = 0;
  1106.             bytes[i++] = 0;
  1108.             WriteStream.Write(bytes, 0, i);
  1109.         }
  1111.         #endregion
  1113.         #region For Reading Zip Files
  1115.         /// <summary>
  1116.         /// This will throw if the zipfile does not exist. 
  1117.         /// </summary>
  1118.         public static ZipFile Read(string zipfilename)
  1119.         {
  1120.             return Read(zipfilename, false);
  1121.         }
  1123.         /// <summary>
  1124.         /// This will throw if the zipfile does not exist. 
  1125.         /// </summary>
  1126.         public static ZipFile Read(string zipfilename, bool TurnOnDebug)
  1127.         {
  1129.             ZipFile zf = new ZipFile();
  1130.             zf._Debug = TurnOnDebug;
  1131.             zf._name = zipfilename;
  1132.             zf._entries = new System.Collections.Generic.List<ZipEntry>();
  1133.             ZipEntry e;
  1134.             while ((e = ZipEntry.Read(zf.ReadStream, zf._Debug)) != null)
  1135.             {
  1136.                 if (zf._Debug) System.Console.WriteLine("  ZipFile::Read(): ZipEntry: {0}", e.FileName);
  1137.                 zf._entries.Add(e);
  1138.             }
  1140.             // read the zipfile's central directory structure here.
  1141.             zf._direntries = new System.Collections.Generic.List<ZipDirEntry>();
  1143.             ZipDirEntry de;
  1144.             while ((de = ZipDirEntry.Read(zf.ReadStream, zf._Debug)) != null)
  1145.             {
  1146.                 if (zf._Debug) System.Console.WriteLine("  ZipFile::Read(): ZipDirEntry: {0}", de.FileName);
  1147.                 zf._direntries.Add(de);
  1148.             }
  1150.             return zf;
  1151.         }
  1153.         public System.Collections.Generic.IEnumerator<ZipEntry> GetEnumerator()
  1154.         {
  1155.             foreach (ZipEntry e in _entries)
  1156.                 yield return e;
  1157.         }
  1159.         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
  1160.         {
  1161.             return GetEnumerator();
  1162.         }
  1165.         public void ExtractAll(string path)
  1166.         {
  1167.             ExtractAll(path, false);
  1168.         }
  1171.         public void ExtractAll(string path, bool WantVerbose)
  1172.         {
  1173.             bool header = WantVerbose;
  1174.             foreach (ZipEntry e in _entries)
  1175.             {
  1176.                 if (header)
  1177.                 {
  1178.                     System.Console.WriteLine("n{1,-22} {2,-6} {3,4}   {4,-8}  {0}",
  1179.                                  "Name", "Modified", "Size", "Ratio", "Packed");
  1180.                     System.Console.WriteLine(new System.String('-', 72));
  1181.                     header = false;
  1182.                 }
  1183.                 if (WantVerbose)
  1184.                     System.Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8} {0}",
  1185.                                  e.FileName,
  1186.                                  e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),
  1187.                                  e.UncompressedSize,
  1188.                                  e.CompressionRatio,
  1189.                                  e.CompressedSize);
  1190.                 e.Extract(path);
  1191.             }
  1192.         }
  1195.         public void Extract(string filename)
  1196.         {
  1197.             this[filename].Extract();
  1198.         }
  1201.         public void Extract(string filename, System.IO.Stream s)
  1202.         {
  1203.             this[filename].Extract(s);
  1204.         }
  1207.         public ZipEntry this[String filename]
  1208.         {
  1209.             get
  1210.             {
  1211.                 foreach (ZipEntry e in _entries)
  1212.                 {
  1213.                     if (e.FileName == filename) return e;
  1214.                 }
  1215.                 return null;
  1216.             }
  1217.         }
  1219.         #endregion
  1224.         // the destructor
  1225.         ~ZipFile()
  1226.         {
  1227.             // call Dispose with false.  Since we're in the
  1228.             // destructor call, the managed resources will be
  1229.             // disposed of anyways.
  1230.             Dispose(false);
  1231.         }
  1233.         public void Dispose()
  1234.         {
  1235.             // dispose of the managed and unmanaged resources
  1236.             Dispose(true);
  1238.             // tell the GC that the Finalize process no longer needs
  1239.             // to be run for this object.
  1240.             GC.SuppressFinalize(this);
  1241.         }
  1244.         protected virtual void Dispose(bool disposeManagedResources)
  1245.         {
  1246.             if (!this._disposed)
  1247.             {
  1248.                 if (disposeManagedResources)
  1249.                 {
  1250.                     // dispose managed resources
  1251.                     if (_readstream != null)
  1252.                     {
  1253.                         _readstream.Dispose();
  1254.                         _readstream = null;
  1255.                     }
  1256.                     if (_writestream != null)
  1257.                     {
  1258.                         _writestream.Dispose();
  1259.                         _writestream = null;
  1260.                     }
  1261.                 }
  1262.                 this._disposed = true;
  1263.             }
  1264.         }
  1267.         private System.IO.Stream _readstream;
  1268.         private System.IO.FileStream _writestream;
  1269.         private bool _Debug = false;
  1270.         private bool _disposed = false;
  1271.         private System.Collections.Generic.List<ZipEntry> _entries = null;
  1272.         private System.Collections.Generic.List<ZipDirEntry> _direntries = null;
  1273.     }
  1275. }
  1278. // Example usage: 
  1279. // 1. Extracting all files from a Zip file: 
  1280. //
  1281. //     try 
  1282. //     {
  1283. //       using(ZipFile zip= ZipFile.Read(ZipFile))
  1284. //       {
  1285. //         zip.ExtractAll(TargetDirectory, true);
  1286. //       }
  1287. //     }
  1288. //     catch (System.Exception ex1)
  1289. //     {
  1290. //       System.Console.Error.WriteLine("exception: " + ex1);
  1291. //     }
  1292. //
  1293. // 2. Extracting files from a zip individually:
  1294. //
  1295. //     try 
  1296. //     {
  1297. //       using(ZipFile zip= ZipFile.Read(ZipFile)) 
  1298. //       {
  1299. //         foreach (ZipEntry e in zip) 
  1300. //         {
  1301. //           e.Extract(TargetDirectory);
  1302. //         }
  1303. //       }
  1304. //     }
  1305. //     catch (System.Exception ex1)
  1306. //     {
  1307. //       System.Console.Error.WriteLine("exception: " + ex1);
  1308. //     }
  1309. //
  1310. // 3. Creating a zip archive: 
  1311. //
  1312. //     try 
  1313. //     {
  1314. //       using(ZipFile zip= new ZipFile(NewZipFile)) 
  1315. //       {
  1316. //
  1317. //         String[] filenames= System.IO.Directory.GetFiles(Directory); 
  1318. //         foreach (String filename in filenames) 
  1319. //         {
  1320. //           zip.Add(filename);
  1321. //         }
  1322. //
  1323. //         zip.Save(); 
  1324. //       }
  1325. //
  1326. //     }
  1327. //     catch (System.Exception ex1)
  1328. //     {
  1329. //       System.Console.Error.WriteLine("exception: " + ex1);
  1330. //     }
  1331. //
  1332. //
  1333. // ==================================================================
  1334. //
  1335. //
  1336. //
  1337. // Information on the ZIP format:
  1338. //
  1339. // From
  1340. // http://www.pkware.com/business_and_developers/developer/popups/appnote.txt
  1341. //
  1342. //  Overall .ZIP file format:
  1343. //
  1344. //     [local file header 1]
  1345. //     [file data 1]
  1346. //     [data descriptor 1]  ** sometimes
  1347. //     . 
  1348. //     .
  1349. //     .
  1350. //     [local file header n]
  1351. //     [file data n]
  1352. //     [data descriptor n]   ** sometimes
  1353. //     [archive decryption header] 
  1354. //     [archive extra data record] 
  1355. //     [central directory]
  1356. //     [zip64 end of central directory record]
  1357. //     [zip64 end of central directory locator] 
  1358. //     [end of central directory record]
  1359. //
  1360. // Local File Header format:
  1361. //         local file header signature     4 bytes  (0x04034b50)
  1362. //         version needed to extract       2 bytes
  1363. //         general purpose bit flag        2 bytes
  1364. //         compression method              2 bytes
  1365. //         last mod file time              2 bytes
  1366. //         last mod file date              2 bytes
  1367. //         crc-32                          4 bytes
  1368. //         compressed size                 4 bytes
  1369. //         uncompressed size               4 bytes
  1370. //         file name length                2 bytes
  1371. //         extra field length              2 bytes
  1372. //         file name                       varies
  1373. //         extra field                     varies
  1374. //
  1375. //
  1376. // Data descriptor:  (used only when bit 3 of the general purpose bitfield is set)
  1377. //         local file header signature     4 bytes  (0x08074b50)
  1378. //         crc-32                          4 bytes
  1379. //         compressed size                 4 bytes
  1380. //         uncompressed size               4 bytes
  1381. //
  1382. //
  1383. //   Central directory structure:
  1384. //
  1385. //       [file header 1]
  1386. //       .
  1387. //       .
  1388. //       . 
  1389. //       [file header n]
  1390. //       [digital signature] 
  1391. //
  1392. //
  1393. //       File header:  (This is ZipDirEntry in the code above)
  1394. //         central file header signature   4 bytes  (0x02014b50)
  1395. //         version made by                 2 bytes
  1396. //         version needed to extract       2 bytes
  1397. //         general purpose bit flag        2 bytes
  1398. //         compression method              2 bytes
  1399. //         last mod file time              2 bytes
  1400. //         last mod file date              2 bytes
  1401. //         crc-32                          4 bytes
  1402. //         compressed size                 4 bytes
  1403. //         uncompressed size               4 bytes
  1404. //         file name length                2 bytes
  1405. //         extra field length              2 bytes
  1406. //         file comment length             2 bytes
  1407. //         disk number start               2 bytes
  1408. //         internal file attributes        2 bytes
  1409. //         external file attributes        4 bytes
  1410. //         relative offset of local header 4 bytes
  1411. //         file name (variable size)
  1412. //         extra field (variable size)
  1413. //         file comment (variable size)
  1414. //
  1415. // End of central directory record:
  1416. //
  1417. //         end of central dir signature    4 bytes  (0x06054b50)
  1418. //         number of this disk             2 bytes
  1419. //         number of the disk with the
  1420. //         start of the central directory  2 bytes
  1421. //         total number of entries in the
  1422. //         central directory on this disk  2 bytes
  1423. //         total number of entries in
  1424. //         the central directory           2 bytes
  1425. //         size of the central directory   4 bytes
  1426. //         offset of start of central
  1427. //         directory with respect to
  1428. //         the starting disk number        4 bytes
  1429. //         .ZIP file comment length        2 bytes
  1430. //         .ZIP file comment       (variable size)
  1431. //
  1432. // date and time are packed values, as MSDOS did them
  1433. // time: bits 0-4 : second
  1434. //            5-10: minute
  1435. //            11-15: hour
  1436. // date  bits 0-4 : day
  1437. //            5-8: month
  1438. //            9-15 year (since 1980)
  1439. //
  1440. // see http://www.vsft.com/hal/dostime.htm