private bool AreEqual(ZipEntry approvedEntry, ZipEntry receivedEntry)
 {
     if (approvedEntry.IsDirectory && receivedEntry.IsDirectory)
     {
         return true;
     }
     using (var approvedStream = new MemoryStream())
     {
         using (var receivedStream = new MemoryStream())
         {
             approvedEntry.Extract(approvedStream);
             receivedEntry.Extract(receivedStream);
             var approvedBytes = approvedStream.ToArray();
             var receivedBytes = receivedStream.ToArray();
             var areEqual = approvedBytes == receivedBytes;
             for (int i = 0; i < receivedBytes.Length && i < approvedBytes.Length; i++)
             {
                 if (receivedBytes[i] != approvedBytes[i])
                 {
                     Logger.Event("Failed on {0}[{1}]      '{2}' != '{3}'", receivedEntry.FileName, i,
                         (char) receivedBytes[i], (char) approvedBytes[i]);
                     return false;
                 }
             }
             return true;
         }
     }
 }

        protected override OperationResult Handle(ZipEntry entry, ZipFile zip)
        {
            string orig = entry.FileName;
            string stripped = GetStripped(entry.FileName);
            if (stripped == null)
            {
                if (entry.IsDirectory)
                {
                    zip.RemoveEntry(entry);
                    return OperationResult.Removed;
                }

                stripped = orig;
            }

            try
            {
                entry.FileName = stripped;
                return OperationResult.Changed;
            }
            catch (Exception ex)
            {
                string type = entry.IsDirectory ? "directory" : "file";
                throw new Exception(string.Format("Could not rename {0} '{1}' to '{2}'", type, orig, stripped), ex);
            }
        }

 internal ZipPackagePart(ZipPackage package, ZipEntry entry)
 {
     Package = package;
     Entry = entry;
     SaveHandler = null;
     Uri = new Uri(package.GetUriKey(entry.FileName), UriKind.Relative);
 }

        public MemoryStream GetEntryMemoryStream(ZipEntry zipEntry)
        {
            var stream = new MemoryStream();
            zipEntry.Extract(stream);
            stream.Position = 0;

            return stream;
        }

 private static Bitmap LoadBitmap(ZipEntry zipEntry)
 {
     MemoryStream stream = new MemoryStream();
     zipEntry.Extract(stream);
     stream.Position = 0;
     Bitmap result = new Bitmap(stream);
     stream.Dispose();
     return result;
 }

 /// <summary>
 /// Constructors
 /// </summary>
 /// <param name="ze"></param>
 public EmlParser(ZipEntry ze)
 {
     try
     {
         parseEML(ze);
     }
     catch (Exception ex)
     { throw ex; }
 }

        public static PartWrapper Create(ZipEntry part)
        {
            if (part.IsZip())
            {
                return new ZipPartWrapper(part);
            }

            return new PartWrapper(part);
        }

		private static void SetZipFile(ZipEntry zipEntry, ZipFileInfo file)
		{
			if (!string.IsNullOrEmpty(file.Password))
				zipEntry.Password = file.Password;

			zipEntry.Comment = file.Comment;
			zipEntry.CompressionMethod = (Ionic.Zip.CompressionMethod)((int)file.CompressionMethod);
			zipEntry.CompressionLevel = (Ionic.Zlib.CompressionLevel)((int)file.CompressionLevel);
		}

		public void Check()
		{
			// Is there a valid input stream
			if (_stream == null)
				throw new FileNotFoundException("No valid file");

			// Now read gwz file and save for later use
			_zip = ZipFile.Read(_stream);

			if (_zip == null)
				throw new FileLoadException("No valid gwz file");

			foreach(ZipEntry zipEntry in _zip.Entries)
			{
				switch(Path.GetExtension(zipEntry.FileName).ToLower())
				{
					case ".lua":
						_luaFile = zipEntry;
						_luaFiles += 1;
						break;
				}
			}

			// Is there a Lua file?
			if (_luaFile == null)
				throw new FileNotFoundException("No valid Lua file found");

			// Is there more than one Lua file
			if (_luaFiles > 1)
				throw new FileLoadException("More than one Lua file found");

			// Any compilation errors of the Lua file
			LUA.Check(_zip[_luaFile.FileName].OpenReader(), _luaFile.FileName);

			// Extract cartridge data from Lua file
			cartridge = LUA.Extract(_zip[_luaFile.FileName].OpenReader());

			// Save Lua file name for later use
			cartridge.LuaFileName = _luaFile.FileName;

			// Now check, if all media resources files exist
			foreach(Media media in cartridge.Medias) {
				foreach(MediaResource resource in media.Resources) {
					// Check, if filename is in list of files
					if (!_zip.EntryFileNames.Contains(resource.Filename))
					{
						if (string.IsNullOrWhiteSpace(resource.Filename))
							throw new FileNotFoundException("The Lua file is referencing a file without a filename");
						else
							throw new FileNotFoundException(String.Format("The GWZ is missing a file referred to by the cartridge's code. The file name is: {0}", resource.Filename));
					}
				}
			}

			// Now all is checked without any problems
			// So it seams, that this GWZ file is valid
		}

        protected override OperationResult Handle(ZipEntry entry, ZipFile zip)
        {
            if (entry.IsDirectory && (entry.Attributes & FileAttributes.Directory) != FileAttributes.Directory)
            {
                entry.Attributes |= FileAttributes.Directory;
            }

            // This just helps if a file is resaved. It shouldn't be treated as modified if this cleans something up.
            return OperationResult.NoChange;
        }

        protected override OperationResult Handle(ZipEntry entry, ZipFile zip)
        {
            if (_regex.IsMatch(entry.FileName))
            {
                zip.RemoveEntry(entry);
                return OperationResult.Removed;
            }

            return OperationResult.NoChange;
        }

 public ContentSection(ZipEntry entry)
 {
     Id = Path.GetFileNameWithoutExtension(entry.FileName);
     ArchivePath = entry.FileName;
     using (Stream s = entry.OpenReader())
     {
         using (StreamReader sr = new StreamReader(s))
         {
             Content = sr.ReadToEnd();
         }
     }
 }

 public static MemoryStream ExtractFileToStream(string zipSource, string filePath)
 {
     MemoryStream stream = new MemoryStream();
     using (ZipFile zip = ZipFile.Read(zipSource))
     {
         var matchFile = new ZipEntry();
         foreach (var file in zip.Where(file => file.FileName == filePath))
             matchFile = file;
         matchFile.Extract(stream);
     }
     return stream;
 }

        public static string ExtractFileFromStream(ZipEntry entry)
        {
            var reader = new MemoryStream();
            entry.Extract(reader);
            reader = new MemoryStream(reader.ToArray());

            var streamReader = new StreamReader(reader);

            var text = streamReader.ReadToEnd();
            reader.Dispose();
            return text;
        }

        public static ZipCrypto ForRead(string password, ZipEntry e)
        {
            System.IO.Stream s = e._archiveStream;
            e._WeakEncryptionHeader = new byte[12];
            byte[] eh = e._WeakEncryptionHeader;
            ZipCrypto z = new ZipCrypto();

            if (password == null)
                throw new BadPasswordException("This entry requires a password.");

            z.InitCipher(password);

            ZipEntry.ReadWeakEncryptionHeader(s, eh);

            // Decrypt the header.  This has a side effect of "further initializing the
            // encryption keys" in the traditional zip encryption. 
            byte[] DecryptedHeader = z.DecryptMessage(eh, eh.Length);

            // CRC check
            // According to the pkzip spec, the final byte in the decrypted header 
            // is the highest-order byte in the CRC. We check it here. 
            if (DecryptedHeader[11] != (byte)((e._Crc32 >> 24) & 0xff))
            {
                // In the case that bit 3 of the general purpose bit flag is set to
                // indicate the presence of an 'Extended File Header' or a 'data
                // descriptor' (signature 0x08074b50), the last byte of the decrypted
                // header is sometimes compared with the high-order byte of the
                // lastmodified time, rather than the high-order byte of the CRC, to
                // verify the password.
                //
                // This is not documented in the PKWare Appnote.txt.  
                // This was discovered this by analysis of the Crypt.c source file in the InfoZip library
                // http://www.info-zip.org/pub/infozip/

                if ((e._BitField & 0x0008) != 0x0008)
                {
                    throw new BadPasswordException("The password did not match.");
                }
                else if (DecryptedHeader[11] != (byte)((e._TimeBlob >> 8) & 0xff))
                {
                    throw new BadPasswordException("The password did not match.");
                }

                // We have a good password. 
            }
            else
            {
                // A-OK
            }
            return z;
        }

        private BitmapSource GenerateBitmapFromZipEntry(ZipEntry entry)
        {
            MemoryStream stream = new MemoryStream();
            entry.Extract(stream);
            stream.Seek(0, SeekOrigin.Begin);

            var decoder = BitmapDecoder.Create(stream,
                BitmapCreateOptions.None,
                BitmapCacheOption.OnLoad);
            BitmapSource bitmapSource = decoder.Frames[0];

            stream.Dispose();

            return bitmapSource;
        }

        /// <summary>
        /// Reads one <c>ZipEntry</c> from the given stream.  If the entry is encrypted, we don't
        /// decrypt at this point.  We also do not decompress.  Mostly we read metadata.
        /// </summary>
        /// <param name="zc">the ZipContainer this entry belongs to.</param>
        /// <param name="first">true of this is the first entry being read from the stream.</param>
        /// <returns>the <c>ZipEntry</c> read from the stream.</returns>
        internal static ZipEntry ReadEntry(ZipContainer zc, bool first)
        {
            ZipFile zf = zc.ZipFile;

            Stream s = zc.ReadStream;

            System.Text.Encoding defaultEncoding = zc.ProvisionalAlternateEncoding;
            ZipEntry entry = new ZipEntry();
            entry._Source = ZipEntrySource.ZipFile;
            entry._container = zc;
            entry._archiveStream = s;
            if (zf != null)
                zf.OnReadEntry(true, null);

            if (first) HandlePK00Prefix(s);

            // Read entry header, including any encryption header
            if (!ReadHeader(entry, defaultEncoding)) return null;

            // Store the position in the stream for this entry
            // change for workitem 8098
            entry.__FileDataPosition = entry.ArchiveStream.Position;

            // seek past the data without reading it. We will read on Extract()
            s.Seek(entry._CompressedFileDataSize + entry._LengthOfTrailer, SeekOrigin.Current);
            // workitem 10178
            Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s);

            // ReadHeader moves the file pointer to the end of the entry header,
            // as well as any encryption header.

            // CompressedFileDataSize includes:
            //   the maybe compressed, maybe encrypted file data
            //   the encryption trailer, if any
            //   the bit 3 descriptor, if any

            // workitem 5306
            // http://www.codeplex.com/DotNetZip/WorkItem/View.aspx?WorkItemId=5306
            HandleUnexpectedDataDescriptor(entry);

            if (zf != null)
            {
                zf.OnReadBytes(entry);
                zf.OnReadEntry(false, entry);
            }

            return entry;
        }

        public static string GetStringFile(ZipEntry zipEntry)
        {
            if (zipEntry != null)
            {
                using (var stream = zipEntry.OpenReader())
                {
                    using (StreamReader sr = new StreamReader(stream, KPGenericUtil.GetDefaultEncoding()))
                    {
                        string fileString = sr.ReadToEnd();
                        return fileString;
                    }
                }
            }

            return String.Empty;
        }

        private static void Save(ZipEntry entry, string outputFilePath)
        {
            using (var input = entry.OpenReader())
            {
                var folderPath = Path.GetDirectoryName(outputFilePath);
                if (!Directory.Exists(folderPath))
                {
                    Directory.CreateDirectory(folderPath);
                }

                using (Stream output = File.OpenWrite(outputFilePath))
                {
                    CopyStream(input, output);
                }
            }
        }

 /// <summary>
 /// Copy metadata that may have been changed by the app.  We do this when
 /// resetting the zipFile instance.  If the app calls Save() on a ZipFile, then
 /// tries to party on that file some more, we may need to Reset() it , which
 /// means re-reading the entries and then copying the metadata.  I think.
 /// </summary>
 internal void CopyMetaData(ZipEntry source)
 {
     this.__FileDataPosition = source.__FileDataPosition;
     this.CompressionMethod = source.CompressionMethod;
     this._CompressionMethod_FromZipFile = source._CompressionMethod_FromZipFile;
     this._CompressedFileDataSize = source._CompressedFileDataSize;
     this._UncompressedSize = source._UncompressedSize;
     this._BitField = source._BitField;
     this._Source = source._Source;
     this._LastModified = source._LastModified;
     this._Mtime = source._Mtime;
     this._Atime = source._Atime;
     this._Ctime = source._Ctime;
     this._ntfsTimesAreSet = source._ntfsTimesAreSet;
     this._emitUnixTimes = source._emitUnixTimes;
     this._emitNtfsTimes = source._emitNtfsTimes;
 }