Dec2017-Script-Dump/ICSharpCode.SharpZipLib/Zip/ZipFile.cs

using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Text;
using ICSharpCode.SharpZipLib.Checksums;
using ICSharpCode.SharpZipLib.Core;
using ICSharpCode.SharpZipLib.Encryption;
using ICSharpCode.SharpZipLib.Zip.Compression;
using ICSharpCode.SharpZipLib.Zip.Compression.Streams;

namespace ICSharpCode.SharpZipLib.Zip
{
	// Token: 0x02000068 RID: 104
	public class ZipFile : IEnumerable, IDisposable
	{
		// Token: 0x060003D9 RID: 985 RVA: 0x000132E8 File Offset: 0x000122E8
		private void OnKeysRequired(string fileName)
		{
			if (this.KeysRequired != null)
			{
				KeysRequiredEventArgs keysRequiredEventArgs = new KeysRequiredEventArgs(fileName, this.key);
				this.KeysRequired(this, keysRequiredEventArgs);
				this.key = keysRequiredEventArgs.Key;
			}
		}

		// Token: 0x170000E7 RID: 231
		// (get) Token: 0x060003DA RID: 986 RVA: 0x00013323 File Offset: 0x00012323
		// (set) Token: 0x060003DB RID: 987 RVA: 0x0001332B File Offset: 0x0001232B
		private byte[] Key
		{
			get
			{
				return this.key;
			}
			set
			{
				this.key = value;
			}
		}

		// Token: 0x170000E8 RID: 232
		// (set) Token: 0x060003DC RID: 988 RVA: 0x00013334 File Offset: 0x00012334
		public string Password
		{
			set
			{
				if (value == null || value.Length == 0)
				{
					this.key = null;
					return;
				}
				this.rawPassword_ = value;
				this.key = PkzipClassic.GenerateKeys(ZipConstants.ConvertToArray(value));
			}
		}

		// Token: 0x170000E9 RID: 233
		// (get) Token: 0x060003DD RID: 989 RVA: 0x00013361 File Offset: 0x00012361
		private bool HaveKeys
		{
			get
			{
				return this.key != null;
			}
		}

		// Token: 0x060003DE RID: 990 RVA: 0x00013370 File Offset: 0x00012370
		public ZipFile(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			this.name_ = name;
			this.baseStream_ = File.Open(name, FileMode.Open, FileAccess.Read, FileShare.Read);
			this.isStreamOwner = true;
			try
			{
				this.ReadEntries();
			}
			catch
			{
				this.DisposeInternal(true);
				throw;
			}
		}

		// Token: 0x060003DF RID: 991 RVA: 0x000133F0 File Offset: 0x000123F0
		public ZipFile(FileStream file)
		{
			if (file == null)
			{
				throw new ArgumentNullException("file");
			}
			if (!file.CanSeek)
			{
				throw new ArgumentException("Stream is not seekable", "file");
			}
			this.baseStream_ = file;
			this.name_ = file.Name;
			this.isStreamOwner = true;
			try
			{
				this.ReadEntries();
			}
			catch
			{
				this.DisposeInternal(true);
				throw;
			}
		}

		// Token: 0x060003E0 RID: 992 RVA: 0x00013484 File Offset: 0x00012484
		public ZipFile(Stream stream)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream");
			}
			if (!stream.CanSeek)
			{
				throw new ArgumentException("Stream is not seekable", "stream");
			}
			this.baseStream_ = stream;
			this.isStreamOwner = true;
			if (this.baseStream_.Length > 0L)
			{
				try
				{
					this.ReadEntries();
					return;
				}
				catch
				{
					this.DisposeInternal(true);
					throw;
				}
			}
			this.entries_ = new ZipEntry[0];
			this.isNewArchive_ = true;
		}

		// Token: 0x060003E1 RID: 993 RVA: 0x0001352C File Offset: 0x0001252C
		internal ZipFile()
		{
			this.entries_ = new ZipEntry[0];
			this.isNewArchive_ = true;
		}

		// Token: 0x060003E2 RID: 994 RVA: 0x00013564 File Offset: 0x00012564
		~ZipFile()
		{
			this.Dispose(false);
		}

		// Token: 0x060003E3 RID: 995 RVA: 0x00013594 File Offset: 0x00012594
		public void Close()
		{
			this.DisposeInternal(true);
			GC.SuppressFinalize(this);
		}

		// Token: 0x060003E4 RID: 996 RVA: 0x000135A4 File Offset: 0x000125A4
		public static ZipFile Create(string fileName)
		{
			if (fileName == null)
			{
				throw new ArgumentNullException("fileName");
			}
			FileStream fileStream = File.Create(fileName);
			return new ZipFile
			{
				name_ = fileName,
				baseStream_ = fileStream,
				isStreamOwner = true
			};
		}

		// Token: 0x060003E5 RID: 997 RVA: 0x000135E4 File Offset: 0x000125E4
		public static ZipFile Create(Stream outStream)
		{
			if (outStream == null)
			{
				throw new ArgumentNullException("outStream");
			}
			if (!outStream.CanWrite)
			{
				throw new ArgumentException("Stream is not writeable", "outStream");
			}
			if (!outStream.CanSeek)
			{
				throw new ArgumentException("Stream is not seekable", "outStream");
			}
			return new ZipFile
			{
				baseStream_ = outStream
			};
		}

		// Token: 0x170000EA RID: 234
		// (get) Token: 0x060003E6 RID: 998 RVA: 0x0001363D File Offset: 0x0001263D
		// (set) Token: 0x060003E7 RID: 999 RVA: 0x00013645 File Offset: 0x00012645
		public bool IsStreamOwner
		{
			get
			{
				return this.isStreamOwner;
			}
			set
			{
				this.isStreamOwner = value;
			}
		}

		// Token: 0x170000EB RID: 235
		// (get) Token: 0x060003E8 RID: 1000 RVA: 0x0001364E File Offset: 0x0001264E
		public bool IsEmbeddedArchive
		{
			get
			{
				return this.offsetOfFirstEntry > 0L;
			}
		}

		// Token: 0x170000EC RID: 236
		// (get) Token: 0x060003E9 RID: 1001 RVA: 0x0001365A File Offset: 0x0001265A
		public bool IsNewArchive
		{
			get
			{
				return this.isNewArchive_;
			}
		}

		// Token: 0x170000ED RID: 237
		// (get) Token: 0x060003EA RID: 1002 RVA: 0x00013662 File Offset: 0x00012662
		public string ZipFileComment
		{
			get
			{
				return this.comment_;
			}
		}

		// Token: 0x170000EE RID: 238
		// (get) Token: 0x060003EB RID: 1003 RVA: 0x0001366A File Offset: 0x0001266A
		public string Name
		{
			get
			{
				return this.name_;
			}
		}

		// Token: 0x170000EF RID: 239
		// (get) Token: 0x060003EC RID: 1004 RVA: 0x00013672 File Offset: 0x00012672
		[Obsolete("Use the Count property instead")]
		public int Size
		{
			get
			{
				return this.entries_.Length;
			}
		}

		// Token: 0x170000F0 RID: 240
		// (get) Token: 0x060003ED RID: 1005 RVA: 0x0001367C File Offset: 0x0001267C
		public long Count
		{
			get
			{
				return (long)this.entries_.Length;
			}
		}

		// Token: 0x170000F1 RID: 241
		[IndexerName("EntryByIndex")]
		public ZipEntry this[int index]
		{
			get
			{
				return (ZipEntry)this.entries_[index].Clone();
			}
		}

		// Token: 0x060003EF RID: 1007 RVA: 0x0001369B File Offset: 0x0001269B
		public IEnumerator GetEnumerator()
		{
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			return new ZipFile.ZipEntryEnumerator(this.entries_);
		}

		// Token: 0x060003F0 RID: 1008 RVA: 0x000136BC File Offset: 0x000126BC
		public int FindEntry(string name, bool ignoreCase)
		{
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			for (int i = 0; i < this.entries_.Length; i++)
			{
				if (string.Compare(name, this.entries_[i].Name, ignoreCase, CultureInfo.InvariantCulture) == 0)
				{
					return i;
				}
			}
			return -1;
		}

		// Token: 0x060003F1 RID: 1009 RVA: 0x00013710 File Offset: 0x00012710
		public ZipEntry GetEntry(string name)
		{
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			int num = this.FindEntry(name, true);
			if (num < 0)
			{
				return null;
			}
			return (ZipEntry)this.entries_[num].Clone();
		}

		// Token: 0x060003F2 RID: 1010 RVA: 0x00013754 File Offset: 0x00012754
		public Stream GetInputStream(ZipEntry entry)
		{
			if (entry == null)
			{
				throw new ArgumentNullException("entry");
			}
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			long num = entry.ZipFileIndex;
			if (num < 0L || num >= (long)this.entries_.Length || this.entries_[(int)(checked((IntPtr)num))].Name != entry.Name)
			{
				num = (long)this.FindEntry(entry.Name, true);
				if (num < 0L)
				{
					throw new ZipException("Entry cannot be found");
				}
			}
			return this.GetInputStream(num);
		}

		// Token: 0x060003F3 RID: 1011 RVA: 0x000137DC File Offset: 0x000127DC
		public Stream GetInputStream(long entryIndex)
		{
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			checked
			{
				long num = this.LocateEntry(this.entries_[(int)((IntPtr)entryIndex)]);
				CompressionMethod compressionMethod = this.entries_[(int)((IntPtr)entryIndex)].CompressionMethod;
				Stream stream = new ZipFile.PartialInputStream(this, num, this.entries_[(int)((IntPtr)entryIndex)].CompressedSize);
				if (this.entries_[(int)((IntPtr)entryIndex)].IsCrypted)
				{
					stream = this.CreateAndInitDecryptionStream(stream, this.entries_[(int)((IntPtr)entryIndex)]);
					if (stream == null)
					{
						throw new ZipException("Unable to decrypt this entry");
					}
				}
				CompressionMethod compressionMethod2 = compressionMethod;
				if (compressionMethod2 != CompressionMethod.Stored)
				{
					if (compressionMethod2 != CompressionMethod.Deflated)
					{
						throw new ZipException("Unsupported compression method " + compressionMethod);
					}
					stream = new InflaterInputStream(stream, new Inflater(true));
				}
				return stream;
			}
		}

		// Token: 0x060003F4 RID: 1012 RVA: 0x00013890 File Offset: 0x00012890
		public bool TestArchive(bool testData)
		{
			return this.TestArchive(testData, TestStrategy.FindFirstError, null);
		}

		// Token: 0x060003F5 RID: 1013 RVA: 0x0001389C File Offset: 0x0001289C
		public bool TestArchive(bool testData, TestStrategy strategy, ZipTestResultHandler resultHandler)
		{
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			TestStatus testStatus = new TestStatus(this);
			if (resultHandler != null)
			{
				resultHandler(testStatus, null);
			}
			ZipFile.HeaderTest headerTest = (testData ? (ZipFile.HeaderTest.Extract | ZipFile.HeaderTest.Header) : ZipFile.HeaderTest.Header);
			bool flag = true;
			try
			{
				int num = 0;
				while (flag && (long)num < this.Count)
				{
					if (resultHandler != null)
					{
						testStatus.SetEntry(this[num]);
						testStatus.SetOperation(TestOperation.EntryHeader);
						resultHandler(testStatus, null);
					}
					try
					{
						this.TestLocalHeader(this[num], headerTest);
					}
					catch (ZipException ex)
					{
						testStatus.AddError();
						if (resultHandler != null)
						{
							resultHandler(testStatus, string.Format("Exception during test - '{0}'", ex.Message));
						}
						if (strategy == TestStrategy.FindFirstError)
						{
							flag = false;
						}
					}
					if (flag && testData && this[num].IsFile)
					{
						if (resultHandler != null)
						{
							testStatus.SetOperation(TestOperation.EntryData);
							resultHandler(testStatus, null);
						}
						Crc32 crc = new Crc32();
						using (Stream inputStream = this.GetInputStream(this[num]))
						{
							byte[] array = new byte[4096];
							long num2 = 0L;
							int num3;
							while ((num3 = inputStream.Read(array, 0, array.Length)) > 0)
							{
								crc.Update(array, 0, num3);
								if (resultHandler != null)
								{
									num2 += (long)num3;
									testStatus.SetBytesTested(num2);
									resultHandler(testStatus, null);
								}
							}
						}
						if (this[num].Crc != crc.Value)
						{
							testStatus.AddError();
							if (resultHandler != null)
							{
								resultHandler(testStatus, "CRC mismatch");
							}
							if (strategy == TestStrategy.FindFirstError)
							{
								flag = false;
							}
						}
						if ((this[num].Flags & 8) != 0)
						{
							ZipHelperStream zipHelperStream = new ZipHelperStream(this.baseStream_);
							DescriptorData descriptorData = new DescriptorData();
							zipHelperStream.ReadDataDescriptor(this[num].LocalHeaderRequiresZip64, descriptorData);
							if (this[num].Crc != descriptorData.Crc)
							{
								testStatus.AddError();
							}
							if (this[num].CompressedSize != descriptorData.CompressedSize)
							{
								testStatus.AddError();
							}
							if (this[num].Size != descriptorData.Size)
							{
								testStatus.AddError();
							}
						}
					}
					if (resultHandler != null)
					{
						testStatus.SetOperation(TestOperation.EntryComplete);
						resultHandler(testStatus, null);
					}
					num++;
				}
				if (resultHandler != null)
				{
					testStatus.SetOperation(TestOperation.MiscellaneousTests);
					resultHandler(testStatus, null);
				}
			}
			catch (Exception ex2)
			{
				testStatus.AddError();
				if (resultHandler != null)
				{
					resultHandler(testStatus, string.Format("Exception during test - '{0}'", ex2.Message));
				}
			}
			if (resultHandler != null)
			{
				testStatus.SetOperation(TestOperation.Complete);
				testStatus.SetEntry(null);
				resultHandler(testStatus, null);
			}
			return testStatus.ErrorCount == 0;
		}

		// Token: 0x060003F6 RID: 1014 RVA: 0x00013B60 File Offset: 0x00012B60
		private long TestLocalHeader(ZipEntry entry, ZipFile.HeaderTest tests)
		{
			long num12;
			lock (this.baseStream_)
			{
				bool flag = (tests & ZipFile.HeaderTest.Header) != (ZipFile.HeaderTest)0;
				bool flag2 = (tests & ZipFile.HeaderTest.Extract) != (ZipFile.HeaderTest)0;
				this.baseStream_.Seek(this.offsetOfFirstEntry + entry.Offset, SeekOrigin.Begin);
				if (this.ReadLEUint() != 67324752U)
				{
					throw new ZipException(string.Format("Wrong local header signature @{0:X}", this.offsetOfFirstEntry + entry.Offset));
				}
				short num = (short)this.ReadLEUshort();
				short num2 = (short)this.ReadLEUshort();
				short num3 = (short)this.ReadLEUshort();
				short num4 = (short)this.ReadLEUshort();
				short num5 = (short)this.ReadLEUshort();
				uint num6 = this.ReadLEUint();
				long num7 = (long)((ulong)this.ReadLEUint());
				long num8 = (long)((ulong)this.ReadLEUint());
				int num9 = (int)this.ReadLEUshort();
				int num10 = (int)this.ReadLEUshort();
				byte[] array = new byte[num9];
				StreamUtils.ReadFully(this.baseStream_, array);
				byte[] array2 = new byte[num10];
				StreamUtils.ReadFully(this.baseStream_, array2);
				ZipExtraData zipExtraData = new ZipExtraData(array2);
				if (zipExtraData.Find(1))
				{
					num8 = zipExtraData.ReadLong();
					num7 = zipExtraData.ReadLong();
					if ((num2 & 8) != 0)
					{
						if (num8 != -1L && num8 != entry.Size)
						{
							throw new ZipException("Size invalid for descriptor");
						}
						if (num7 != -1L && num7 != entry.CompressedSize)
						{
							throw new ZipException("Compressed size invalid for descriptor");
						}
					}
				}
				else if (num >= 45 && ((uint)num8 == 4294967295U || (uint)num7 == 4294967295U))
				{
					throw new ZipException("Required Zip64 extended information missing");
				}
				if (flag2 && entry.IsFile)
				{
					if (!entry.IsCompressionMethodSupported())
					{
						throw new ZipException("Compression method not supported");
					}
					if (num > 51 || (num > 20 && num < 45))
					{
						throw new ZipException(string.Format("Version required to extract this entry not supported ({0})", num));
					}
					if ((num2 & 12384) != 0)
					{
						throw new ZipException("The library does not support the zip version required to extract this entry");
					}
				}
				if (flag)
				{
					if (num <= 63 && num != 10 && num != 11 && num != 20 && num != 21 && num != 25 && num != 27 && num != 45 && num != 46 && num != 50 && num != 51 && num != 52 && num != 61 && num != 62 && num != 63)
					{
						throw new ZipException(string.Format("Version required to extract this entry is invalid ({0})", num));
					}
					if (((int)num2 & 49168) != 0)
					{
						throw new ZipException("Reserved bit flags cannot be set.");
					}
					if ((num2 & 1) != 0 && num < 20)
					{
						throw new ZipException(string.Format("Version required to extract this entry is too low for encryption ({0})", num));
					}
					if ((num2 & 64) != 0)
					{
						if ((num2 & 1) == 0)
						{
							throw new ZipException("Strong encryption flag set but encryption flag is not set");
						}
						if (num < 50)
						{
							throw new ZipException(string.Format("Version required to extract this entry is too low for encryption ({0})", num));
						}
					}
					if ((num2 & 32) != 0 && num < 27)
					{
						throw new ZipException(string.Format("Patched data requires higher version than ({0})", num));
					}
					if ((int)num2 != entry.Flags)
					{
						throw new ZipException("Central header/local header flags mismatch");
					}
					if (entry.CompressionMethod != (CompressionMethod)num3)
					{
						throw new ZipException("Central header/local header compression method mismatch");
					}
					if (entry.Version != (int)num)
					{
						throw new ZipException("Extract version mismatch");
					}
					if ((num2 & 64) != 0 && num < 62)
					{
						throw new ZipException("Strong encryption flag set but version not high enough");
					}
					if ((num2 & 8192) != 0 && (num4 != 0 || num5 != 0))
					{
						throw new ZipException("Header masked set but date/time values non-zero");
					}
					if ((num2 & 8) == 0 && num6 != (uint)entry.Crc)
					{
						throw new ZipException("Central header/local header crc mismatch");
					}
					if (num8 == 0L && num7 == 0L && num6 != 0U)
					{
						throw new ZipException("Invalid CRC for empty entry");
					}
					if (entry.Name.Length > num9)
					{
						throw new ZipException("File name length mismatch");
					}
					string text = ZipConstants.ConvertToStringExt((int)num2, array);
					if (text != entry.Name)
					{
						throw new ZipException("Central header and local header file name mismatch");
					}
					if (entry.IsDirectory)
					{
						if (num8 > 0L)
						{
							throw new ZipException("Directory cannot have size");
						}
						if (entry.IsCrypted)
						{
							if (num7 > 14L)
							{
								throw new ZipException("Directory compressed size invalid");
							}
						}
						else if (num7 > 2L)
						{
							throw new ZipException("Directory compressed size invalid");
						}
					}
					if (!ZipNameTransform.IsValidName(text, true))
					{
						throw new ZipException("Name is invalid");
					}
				}
				if ((num2 & 8) == 0 || num8 > 0L || num7 > 0L)
				{
					if (num8 != entry.Size)
					{
						throw new ZipException(string.Format("Size mismatch between central header({0}) and local header({1})", entry.Size, num8));
					}
					if (num7 != entry.CompressedSize && num7 != (long)((ulong)(-1)) && num7 != -1L)
					{
						throw new ZipException(string.Format("Compressed size mismatch between central header({0}) and local header({1})", entry.CompressedSize, num7));
					}
				}
				int num11 = num9 + num10;
				num12 = this.offsetOfFirstEntry + entry.Offset + 30L + (long)num11;
			}
			return num12;
		}

		// Token: 0x170000F2 RID: 242
		// (get) Token: 0x060003F7 RID: 1015 RVA: 0x00014010 File Offset: 0x00013010
		// (set) Token: 0x060003F8 RID: 1016 RVA: 0x0001401D File Offset: 0x0001301D
		public INameTransform NameTransform
		{
			get
			{
				return this.updateEntryFactory_.NameTransform;
			}
			set
			{
				this.updateEntryFactory_.NameTransform = value;
			}
		}

		// Token: 0x170000F3 RID: 243
		// (get) Token: 0x060003F9 RID: 1017 RVA: 0x0001402B File Offset: 0x0001302B
		// (set) Token: 0x060003FA RID: 1018 RVA: 0x00014033 File Offset: 0x00013033
		public IEntryFactory EntryFactory
		{
			get
			{
				return this.updateEntryFactory_;
			}
			set
			{
				if (value == null)
				{
					this.updateEntryFactory_ = new ZipEntryFactory();
					return;
				}
				this.updateEntryFactory_ = value;
			}
		}

		// Token: 0x170000F4 RID: 244
		// (get) Token: 0x060003FB RID: 1019 RVA: 0x0001404B File Offset: 0x0001304B
		// (set) Token: 0x060003FC RID: 1020 RVA: 0x00014053 File Offset: 0x00013053
		public int BufferSize
		{
			get
			{
				return this.bufferSize_;
			}
			set
			{
				if (value < 1024)
				{
					throw new ArgumentOutOfRangeException("value", "cannot be below 1024");
				}
				if (this.bufferSize_ != value)
				{
					this.bufferSize_ = value;
					this.copyBuffer_ = null;
				}
			}
		}

		// Token: 0x170000F5 RID: 245
		// (get) Token: 0x060003FD RID: 1021 RVA: 0x00014084 File Offset: 0x00013084
		public bool IsUpdating
		{
			get
			{
				return this.updates_ != null;
			}
		}

		// Token: 0x170000F6 RID: 246
		// (get) Token: 0x060003FE RID: 1022 RVA: 0x00014092 File Offset: 0x00013092
		// (set) Token: 0x060003FF RID: 1023 RVA: 0x0001409A File Offset: 0x0001309A
		public UseZip64 UseZip64
		{
			get
			{
				return this.useZip64_;
			}
			set
			{
				this.useZip64_ = value;
			}
		}

		// Token: 0x06000400 RID: 1024 RVA: 0x000140A4 File Offset: 0x000130A4
		public void BeginUpdate(IArchiveStorage archiveStorage, IDynamicDataSource dataSource)
		{
			if (archiveStorage == null)
			{
				throw new ArgumentNullException("archiveStorage");
			}
			if (dataSource == null)
			{
				throw new ArgumentNullException("dataSource");
			}
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			if (this.IsEmbeddedArchive)
			{
				throw new ZipException("Cannot update embedded/SFX archives");
			}
			this.archiveStorage_ = archiveStorage;
			this.updateDataSource_ = dataSource;
			this.updateIndex_ = new Hashtable();
			this.updates_ = new ArrayList(this.entries_.Length);
			foreach (ZipEntry zipEntry in this.entries_)
			{
				int num = this.updates_.Add(new ZipFile.ZipUpdate(zipEntry));
				this.updateIndex_.Add(zipEntry.Name, num);
			}
			this.updates_.Sort(new ZipFile.UpdateComparer());
			int num2 = 0;
			foreach (object obj in this.updates_)
			{
				ZipFile.ZipUpdate zipUpdate = (ZipFile.ZipUpdate)obj;
				if (num2 == this.updates_.Count - 1)
				{
					break;
				}
				zipUpdate.OffsetBasedSize = ((ZipFile.ZipUpdate)this.updates_[num2 + 1]).Entry.Offset - zipUpdate.Entry.Offset;
				num2++;
			}
			this.updateCount_ = (long)this.updates_.Count;
			this.contentsEdited_ = false;
			this.commentEdited_ = false;
			this.newComment_ = null;
		}

		// Token: 0x06000401 RID: 1025 RVA: 0x00014234 File Offset: 0x00013234
		public void BeginUpdate(IArchiveStorage archiveStorage)
		{
			this.BeginUpdate(archiveStorage, new DynamicDiskDataSource());
		}

		// Token: 0x06000402 RID: 1026 RVA: 0x00014242 File Offset: 0x00013242
		public void BeginUpdate()
		{
			if (this.Name == null)
			{
				this.BeginUpdate(new MemoryArchiveStorage(), new DynamicDiskDataSource());
				return;
			}
			this.BeginUpdate(new DiskArchiveStorage(this), new DynamicDiskDataSource());
		}

		// Token: 0x06000403 RID: 1027 RVA: 0x00014270 File Offset: 0x00013270
		public void CommitUpdate()
		{
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			this.CheckUpdating();
			try
			{
				this.updateIndex_.Clear();
				this.updateIndex_ = null;
				if (this.contentsEdited_)
				{
					this.RunUpdates();
				}
				else if (this.commentEdited_)
				{
					this.UpdateCommentOnly();
				}
				else if (this.entries_.Length == 0)
				{
					byte[] array = ((this.newComment_ != null) ? this.newComment_.RawComment : ZipConstants.ConvertToArray(this.comment_));
					using (ZipHelperStream zipHelperStream = new ZipHelperStream(this.baseStream_))
					{
						zipHelperStream.WriteEndOfCentralDirectory(0L, 0L, 0L, array);
					}
				}
			}
			finally
			{
				this.PostUpdateCleanup();
			}
		}

		// Token: 0x06000404 RID: 1028 RVA: 0x00014340 File Offset: 0x00013340
		public void AbortUpdate()
		{
			this.PostUpdateCleanup();
		}

		// Token: 0x06000405 RID: 1029 RVA: 0x00014348 File Offset: 0x00013348
		public void SetComment(string comment)
		{
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			this.CheckUpdating();
			this.newComment_ = new ZipFile.ZipString(comment);
			if (this.newComment_.RawLength > 65535)
			{
				this.newComment_ = null;
				throw new ZipException("Comment length exceeds maximum - 65535");
			}
			this.commentEdited_ = true;
		}

		// Token: 0x06000406 RID: 1030 RVA: 0x000143A8 File Offset: 0x000133A8
		private void AddUpdate(ZipFile.ZipUpdate update)
		{
			this.contentsEdited_ = true;
			int num = this.FindExistingUpdate(update.Entry.Name);
			if (num >= 0)
			{
				if (this.updates_[num] == null)
				{
					this.updateCount_ += 1L;
				}
				this.updates_[num] = update;
				return;
			}
			num = this.updates_.Add(update);
			this.updateCount_ += 1L;
			this.updateIndex_.Add(update.Entry.Name, num);
		}

		// Token: 0x06000407 RID: 1031 RVA: 0x00014438 File Offset: 0x00013438
		public void Add(string fileName, CompressionMethod compressionMethod, bool useUnicodeText)
		{
			if (fileName == null)
			{
				throw new ArgumentNullException("fileName");
			}
			if (this.isDisposed_)
			{
				throw new ObjectDisposedException("ZipFile");
			}
			if (!ZipEntry.IsCompressionMethodSupported(compressionMethod))
			{
				throw new ArgumentOutOfRangeException("compressionMethod");
			}
			this.CheckUpdating();
			this.contentsEdited_ = true;
			ZipEntry zipEntry = this.EntryFactory.MakeFileEntry(fileName);
			zipEntry.IsUnicodeText = useUnicodeText;
			zipEntry.CompressionMethod = compressionMethod;
			this.AddUpdate(new ZipFile.ZipUpdate(fileName, zipEntry));
		}

		// Token: 0x06000408 RID: 1032 RVA: 0x000144B0 File Offset: 0x000134B0
		public void Add(string fileName, CompressionMethod compressionMethod)
		{
			if (fileName == null)
			{
				throw new ArgumentNullException("fileName");
			}
			if (!ZipEntry.IsCompressionMethodSupported(compressionMethod))
			{
				throw new ArgumentOutOfRangeException("compressionMethod");
			}
			this.CheckUpdating();
			this.contentsEdited_ = true;
			ZipEntry zipEntry = this.EntryFactory.MakeFileEntry(fileName);
			zipEntry.CompressionMethod = compressionMethod;
			this.AddUpdate(new ZipFile.ZipUpdate(fileName, zipEntry));
		}

		// Token: 0x06000409 RID: 1033 RVA: 0x0001450C File Offset: 0x0001350C
		public void Add(string fileName)
		{
			if (fileName == null)
			{
				throw new ArgumentNullException("fileName");
			}
			this.CheckUpdating();
			this.AddUpdate(new ZipFile.ZipUpdate(fileName, this.EntryFactory.MakeFileEntry(fileName)));
		}

		// Token: 0x0600040A RID: 1034 RVA: 0x0001453A File Offset: 0x0001353A
		public void Add(string fileName, string entryName)
		{
			if (fileName == null)
			{
				throw new ArgumentNullException("fileName");
			}
			if (entryName == null)
			{
				throw new ArgumentNullException("entryName");
			}
			this.CheckUpdating();
			this.AddUpdate(new ZipFile.ZipUpdate(fileName, this.EntryFactory.MakeFileEntry(entryName)));
		}

		// Token: 0x0600040B RID: 1035 RVA: 0x00014576 File Offset: 0x00013576
		public void Add(IStaticDataSource dataSource, string entryName)
		{
			if (dataSource == null)
			{
				throw new ArgumentNullException("dataSource");
			}
			if (entryName == null)
			{
				throw new ArgumentNullException("entryName");
			}
			this.CheckUpdating();
			this.AddUpdate(new ZipFile.ZipUpdate(dataSource, this.EntryFactory.MakeFileEntry(entryName, false)));
		}

		// Token: 0x0600040C RID: 1036 RVA: 0x000145B4 File Offset: 0x000135B4
		public void Add(IStaticDataSource dataSource, string entryName, CompressionMethod compressionMethod)
		{
			if (dataSource == null)
			{
				throw new ArgumentNullException("dataSource");
			}
			if (entryName == null)
			{
				throw new ArgumentNullException("entryName");
			}
			this.CheckUpdating();
			ZipEntry zipEntry = this.EntryFactory.MakeFileEntry(entryName, false);
			zipEntry.CompressionMethod = compressionMethod;
			this.AddUpdate(new ZipFile.ZipUpdate(dataSource, zipEntry));
		}

		// Token: 0x0600040D RID: 1037 RVA: 0x00014608 File Offset: 0x00013608
		public void Add(IStaticDataSource dataSource, string entryName, CompressionMethod compressionMethod, bool useUnicodeText)
		{
			if (dataSource == null)
			{
				throw new ArgumentNullException("dataSource");
			}
			if (entryName == null)
			{
				throw new ArgumentNullException("entryName");
			}
			this.CheckUpdating();
			ZipEntry zipEntry = this.EntryFactory.MakeFileEntry(entryName, false);
			zipEntry.IsUnicodeText = useUnicodeText;
			zipEntry.CompressionMethod = compressionMethod;
			this.AddUpdate(new ZipFile.ZipUpdate(dataSource, zipEntry));
		}

		// Token: 0x0600040E RID: 1038 RVA: 0x00014664 File Offset: 0x00013664
		public void Add(ZipEntry entry)
		{
			if (entry == null)
			{
				throw new ArgumentNullException("entry");
			}
			this.CheckUpdating();
			if (entry.Size != 0L || entry.CompressedSize != 0L)
			{
				throw new ZipException("Entry cannot have any data");
			}
			this.AddUpdate(new ZipFile.ZipUpdate(ZipFile.UpdateCommand.Add, entry));
		}

		// Token: 0x0600040F RID: 1039 RVA: 0x000146B4 File Offset: 0x000136B4
		public void AddDirectory(string directoryName)
		{
			if (directoryName == null)
			{
				throw new ArgumentNullException("directoryName");
			}
			this.CheckUpdating();
			ZipEntry zipEntry = this.EntryFactory.MakeDirectoryEntry(directoryName);
			this.AddUpdate(new ZipFile.ZipUpdate(ZipFile.UpdateCommand.Add, zipEntry));
		}

		// Token: 0x06000410 RID: 1040 RVA: 0x000146F0 File Offset: 0x000136F0
		public bool Delete(string fileName)
		{
			if (fileName == null)
			{
				throw new ArgumentNullException("fileName");
			}
			this.CheckUpdating();
			int num = this.FindExistingUpdate(fileName);
			if (num >= 0 && this.updates_[num] != null)
			{
				bool flag = true;
				this.contentsEdited_ = true;
				this.updates_[num] = null;
				this.updateCount_ -= 1L;
				return flag;
			}
			throw new ZipException("Cannot find entry to delete");
		}

		// Token: 0x06000411 RID: 1041 RVA: 0x00014760 File Offset: 0x00013760
		public void Delete(ZipEntry entry)
		{
			if (entry == null)
			{
				throw new ArgumentNullException("entry");
			}
			this.CheckUpdating();
			int num = this.FindExistingUpdate(entry);
			if (num >= 0)
			{
				this.contentsEdited_ = true;
				this.updates_[num] = null;
				this.updateCount_ -= 1L;
				return;
			}
			throw new ZipException("Cannot find entry to delete");
		}

		// Token: 0x06000412 RID: 1042 RVA: 0x000147BB File Offset: 0x000137BB
		private void WriteLEShort(int value)
		{
			this.baseStream_.WriteByte((byte)(value & 255));
			this.baseStream_.WriteByte((byte)((value >> 8) & 255));
		}

		// Token: 0x06000413 RID: 1043 RVA: 0x000147E5 File Offset: 0x000137E5
		private void WriteLEUshort(ushort value)
		{
			this.baseStream_.WriteByte((byte)(value & 255));
			this.baseStream_.WriteByte((byte)(value >> 8));
		}

		// Token: 0x06000414 RID: 1044 RVA: 0x00014809 File Offset: 0x00013809
		private void WriteLEInt(int value)
		{
			this.WriteLEShort(value & 65535);
			this.WriteLEShort(value >> 16);
		}

		// Token: 0x06000415 RID: 1045 RVA: 0x00014822 File Offset: 0x00013822
		private void WriteLEUint(uint value)
		{
			this.WriteLEUshort((ushort)(value & 65535U));
			this.WriteLEUshort((ushort)(value >> 16));
		}

		// Token: 0x06000416 RID: 1046 RVA: 0x0001483D File Offset: 0x0001383D
		private void WriteLeLong(long value)
		{
			this.WriteLEInt((int)(value & (long)((ulong)(-1))));
			this.WriteLEInt((int)(value >> 32));
		}

		// Token: 0x06000417 RID: 1047 RVA: 0x00014855 File Offset: 0x00013855
		private void WriteLEUlong(ulong value)
		{
			this.WriteLEUint((uint)(value & (ulong)(-1)));
			this.WriteLEUint((uint)(value >> 32));
		}

		// Token: 0x06000418 RID: 1048 RVA: 0x00014870 File Offset: 0x00013870
		private void WriteLocalEntryHeader(ZipFile.ZipUpdate update)
		{
			ZipEntry outEntry = update.OutEntry;
			outEntry.Offset = this.baseStream_.Position;
			if (update.Command != ZipFile.UpdateCommand.Copy)
			{
				if (outEntry.CompressionMethod == CompressionMethod.Deflated)
				{
					if (outEntry.Size == 0L)
					{
						outEntry.CompressedSize = outEntry.Size;
						outEntry.Crc = 0L;
						outEntry.CompressionMethod = CompressionMethod.Stored;
					}
				}
				else if (outEntry.CompressionMethod == CompressionMethod.Stored)
				{
					outEntry.Flags &= -9;
				}
				if (this.HaveKeys)
				{
					outEntry.IsCrypted = true;
					if (outEntry.Crc < 0L)
					{
						outEntry.Flags |= 8;
					}
				}
				else
				{
					outEntry.IsCrypted = false;
				}
				switch (this.useZip64_)
				{
				case UseZip64.On:
					outEntry.ForceZip64();
					break;
				case UseZip64.Dynamic:
					if (outEntry.Size < 0L)
					{
						outEntry.ForceZip64();
					}
					break;
				}
			}
			this.WriteLEInt(67324752);
			this.WriteLEShort(outEntry.Version);
			this.WriteLEShort(outEntry.Flags);
			this.WriteLEShort((int)((byte)outEntry.CompressionMethod));
			this.WriteLEInt((int)outEntry.DosTime);
			if (!outEntry.HasCrc)
			{
				update.CrcPatchOffset = this.baseStream_.Position;
				this.WriteLEInt(0);
			}
			else
			{
				this.WriteLEInt((int)outEntry.Crc);
			}
			if (outEntry.LocalHeaderRequiresZip64)
			{
				this.WriteLEInt(-1);
				this.WriteLEInt(-1);
			}
			else
			{
				if (outEntry.CompressedSize < 0L || outEntry.Size < 0L)
				{
					update.SizePatchOffset = this.baseStream_.Position;
				}
				this.WriteLEInt((int)outEntry.CompressedSize);
				this.WriteLEInt((int)outEntry.Size);
			}
			byte[] array = ZipConstants.ConvertToArray(outEntry.Flags, outEntry.Name);
			if (array.Length > 65535)
			{
				throw new ZipException("Entry name too long.");
			}
			ZipExtraData zipExtraData = new ZipExtraData(outEntry.ExtraData);
			if (outEntry.LocalHeaderRequiresZip64)
			{
				zipExtraData.StartNewEntry();
				zipExtraData.AddLeLong(outEntry.Size);
				zipExtraData.AddLeLong(outEntry.CompressedSize);
				zipExtraData.AddNewEntry(1);
			}
			else
			{
				zipExtraData.Delete(1);
			}
			outEntry.ExtraData = zipExtraData.GetEntryData();
			this.WriteLEShort(array.Length);
			this.WriteLEShort(outEntry.ExtraData.Length);
			if (array.Length > 0)
			{
				this.baseStream_.Write(array, 0, array.Length);
			}
			if (outEntry.LocalHeaderRequiresZip64)
			{
				if (!zipExtraData.Find(1))
				{
					throw new ZipException("Internal error cannot find extra data");
				}
				update.SizePatchOffset = this.baseStream_.Position + (long)zipExtraData.CurrentReadIndex;
			}
			if (outEntry.ExtraData.Length > 0)
			{
				this.baseStream_.Write(outEntry.ExtraData, 0, outEntry.ExtraData.Length);
			}
		}

		// Token: 0x06000419 RID: 1049 RVA: 0x00014B0C File Offset: 0x00013B0C
		private int WriteCentralDirectoryHeader(ZipEntry entry)
		{
			if (entry.CompressedSize < 0L)
			{
				throw new ZipException("Attempt to write central directory entry with unknown csize");
			}
			if (entry.Size < 0L)
			{
				throw new ZipException("Attempt to write central directory entry with unknown size");
			}
			if (entry.Crc < 0L)
			{
				throw new ZipException("Attempt to write central directory entry with unknown crc");
			}
			this.WriteLEInt(33639248);
			this.WriteLEShort(51);
			this.WriteLEShort(entry.Version);
			this.WriteLEShort(entry.Flags);
			this.WriteLEShort((int)((byte)entry.CompressionMethod));
			this.WriteLEInt((int)entry.DosTime);
			this.WriteLEInt((int)entry.Crc);
			if (entry.IsZip64Forced() || entry.CompressedSize >= (long)((ulong)(-1)))
			{
				this.WriteLEInt(-1);
			}
			else
			{
				this.WriteLEInt((int)(entry.CompressedSize & (long)((ulong)(-1))));
			}
			if (entry.IsZip64Forced() || entry.Size >= (long)((ulong)(-1)))
			{
				this.WriteLEInt(-1);
			}
			else
			{
				this.WriteLEInt((int)entry.Size);
			}
			byte[] array = ZipConstants.ConvertToArray(entry.Flags, entry.Name);
			if (array.Length > 65535)
			{
				throw new ZipException("Entry name is too long.");
			}
			this.WriteLEShort(array.Length);
			ZipExtraData zipExtraData = new ZipExtraData(entry.ExtraData);
			if (entry.CentralHeaderRequiresZip64)
			{
				zipExtraData.StartNewEntry();
				if (entry.Size >= (long)((ulong)(-1)) || this.useZip64_ == UseZip64.On)
				{
					zipExtraData.AddLeLong(entry.Size);
				}
				if (entry.CompressedSize >= (long)((ulong)(-1)) || this.useZip64_ == UseZip64.On)
				{
					zipExtraData.AddLeLong(entry.CompressedSize);
				}
				if (entry.Offset >= (long)((ulong)(-1)))
				{
					zipExtraData.AddLeLong(entry.Offset);
				}
				zipExtraData.AddNewEntry(1);
			}
			else
			{
				zipExtraData.Delete(1);
			}
			byte[] entryData = zipExtraData.GetEntryData();
			this.WriteLEShort(entryData.Length);
			this.WriteLEShort((entry.Comment != null) ? entry.Comment.Length : 0);
			this.WriteLEShort(0);
			this.WriteLEShort(0);
			if (entry.ExternalFileAttributes != -1)
			{
				this.WriteLEInt(entry.ExternalFileAttributes);
			}
			else if (entry.IsDirectory)
			{
				this.WriteLEUint(16U);
			}
			else
			{
				this.WriteLEUint(0U);
			}
			if (entry.Offset >= (long)((ulong)(-1)))
			{
				this.WriteLEUint(uint.MaxValue);
			}
			else
			{
				this.WriteLEUint((uint)((int)entry.Offset));
			}
			if (array.Length > 0)
			{
				this.baseStream_.Write(array, 0, array.Length);
			}
			if (entryData.Length > 0)
			{
				this.baseStream_.Write(entryData, 0, entryData.Length);
			}
			byte[] array2 = ((entry.Comment != null) ? Encoding.ASCII.GetBytes(entry.Comment) : new byte[0]);
			if (array2.Length > 0)
			{
				this.baseStream_.Write(array2, 0, array2.Length);
			}
			return 46 + array.Length + entryData.Length + array2.Length;
		}

		// Token: 0x0600041A RID: 1050 RVA: 0x00014DA7 File Offset: 0x00013DA7
		private void PostUpdateCleanup()
		{
			this.updateDataSource_ = null;
			this.updates_ = null;
			this.updateIndex_ = null;
			if (this.archiveStorage_ != null)
			{
				this.archiveStorage_.Dispose();
				this.archiveStorage_ = null;
			}
		}

		// Token: 0x0600041B RID: 1051 RVA: 0x00014DD8 File Offset: 0x00013DD8
		private string GetTransformedFileName(string name)
		{
			INameTransform nameTransform = this.NameTransform;
			if (nameTransform == null)
			{
				return name;
			}
			return nameTransform.TransformFile(name);
		}

		// Token: 0x0600041C RID: 1052 RVA: 0x00014DF8 File Offset: 0x00013DF8
		private string GetTransformedDirectoryName(string name)
		{
			INameTransform nameTransform = this.NameTransform;
			if (nameTransform == null)
			{
				return name;
			}
			return nameTransform.TransformDirectory(name);
		}

		// Token: 0x0600041D RID: 1053 RVA: 0x00014E18 File Offset: 0x00013E18
		private byte[] GetBuffer()
		{
			if (this.copyBuffer_ == null)
			{
				this.copyBuffer_ = new byte[this.bufferSize_];
			}
			return this.copyBuffer_;
		}

		// Token: 0x0600041E RID: 1054 RVA: 0x00014E3C File Offset: 0x00013E3C
		private void CopyDescriptorBytes(ZipFile.ZipUpdate update, Stream dest, Stream source)
		{
			int i = this.GetDescriptorSize(update);
			if (i > 0)
			{
				byte[] buffer = this.GetBuffer();
				while (i > 0)
				{
					int num = Math.Min(buffer.Length, i);
					int num2 = source.Read(buffer, 0, num);
					if (num2 <= 0)
					{
						throw new ZipException("Unxpected end of stream");
					}
					dest.Write(buffer, 0, num2);
					i -= num2;
				}
			}
		}

		// Token: 0x0600041F RID: 1055 RVA: 0x00014E94 File Offset: 0x00013E94
		private void CopyBytes(ZipFile.ZipUpdate update, Stream destination, Stream source, long bytesToCopy, bool updateCrc)
		{
			if (destination == source)
			{
				throw new InvalidOperationException("Destination and source are the same");
			}
			Crc32 crc = new Crc32();
			byte[] buffer = this.GetBuffer();
			long num = bytesToCopy;
			long num2 = 0L;
			int num4;
			do
			{
				int num3 = buffer.Length;
				if (bytesToCopy < (long)num3)
				{
					num3 = (int)bytesToCopy;
				}
				num4 = source.Read(buffer, 0, num3);
				if (num4 > 0)
				{
					if (updateCrc)
					{
						crc.Update(buffer, 0, num4);
					}
					destination.Write(buffer, 0, num4);
					bytesToCopy -= (long)num4;
					num2 += (long)num4;
				}
			}
			while (num4 > 0 && bytesToCopy > 0L);
			if (num2 != num)
			{
				throw new ZipException(string.Format("Failed to copy bytes expected {0} read {1}", num, num2));
			}
			if (updateCrc)
			{
				update.OutEntry.Crc = crc.Value;
			}
		}

		// Token: 0x06000420 RID: 1056 RVA: 0x00014F4C File Offset: 0x00013F4C
		private int GetDescriptorSize(ZipFile.ZipUpdate update)
		{
			int num = 0;
			if ((update.Entry.Flags & 8) != 0)
			{
				num = 12;
				if (update.Entry.LocalHeaderRequiresZip64)
				{
					num = 20;
				}
			}
			return num;
		}

		// Token: 0x06000421 RID: 1057 RVA: 0x00014F80 File Offset: 0x00013F80
		private void CopyDescriptorBytesDirect(ZipFile.ZipUpdate update, Stream stream, ref long destinationPosition, long sourcePosition)
		{
			int i = this.GetDescriptorSize(update);
			while (i > 0)
			{
				int num = i;
				byte[] buffer = this.GetBuffer();
				stream.Position = sourcePosition;
				int num2 = stream.Read(buffer, 0, num);
				if (num2 <= 0)
				{
					throw new ZipException("Unxpected end of stream");
				}
				stream.Position = destinationPosition;
				stream.Write(buffer, 0, num2);
				i -= num2;
				destinationPosition += (long)num2;
				sourcePosition += (long)num2;
			}
		}

		// Token: 0x06000422 RID: 1058 RVA: 0x00014FEC File Offset: 0x00013FEC
		private void CopyEntryDataDirect(ZipFile.ZipUpdate update, Stream stream, bool updateCrc, ref long destinationPosition, ref long sourcePosition)
		{
			long num = update.Entry.CompressedSize;
			Crc32 crc = new Crc32();
			byte[] buffer = this.GetBuffer();
			long num2 = num;
			long num3 = 0L;
			int num5;
			do
			{
				int num4 = buffer.Length;
				if (num < (long)num4)
				{
					num4 = (int)num;
				}
				stream.Position = sourcePosition;
				num5 = stream.Read(buffer, 0, num4);
				if (num5 > 0)
				{
					if (updateCrc)
					{
						crc.Update(buffer, 0, num5);
					}
					stream.Position = destinationPosition;
					stream.Write(buffer, 0, num5);
					destinationPosition += (long)num5;
					sourcePosition += (long)num5;
					num -= (long)num5;
					num3 += (long)num5;
				}
			}
			while (num5 > 0 && num > 0L);
			if (num3 != num2)
			{
				throw new ZipException(string.Format("Failed to copy bytes expected {0} read {1}", num2, num3));
			}
			if (updateCrc)
			{
				update.OutEntry.Crc = crc.Value;
			}
		}

		// Token: 0x06000423 RID: 1059 RVA: 0x000150C4 File Offset: 0x000140C4
		private int FindExistingUpdate(ZipEntry entry)
		{
			int num = -1;
			string transformedFileName = this.GetTransformedFileName(entry.Name);
			if (this.updateIndex_.ContainsKey(transformedFileName))
			{
				num = (int)this.updateIndex_[transformedFileName];
			}
			return num;
		}

		// Token: 0x06000424 RID: 1060 RVA: 0x00015104 File Offset: 0x00014104
		private int FindExistingUpdate(string fileName)
		{
			int num = -1;
			string transformedFileName = this.GetTransformedFileName(fileName);
			if (this.updateIndex_.ContainsKey(transformedFileName))
			{
				num = (int)this.updateIndex_[transformedFileName];
			}
			return num;
		}

		// Token: 0x06000425 RID: 1061 RVA: 0x0001513C File Offset: 0x0001413C
		private Stream GetOutputStream(ZipEntry entry)
		{
			Stream stream = this.baseStream_;
			if (entry.IsCrypted)
			{
				stream = this.CreateAndInitEncryptionStream(stream, entry);
			}
			CompressionMethod compressionMethod = entry.CompressionMethod;
			if (compressionMethod != CompressionMethod.Stored)
			{
				if (compressionMethod != CompressionMethod.Deflated)
				{
					throw new ZipException("Unknown compression method " + entry.CompressionMethod);
				}
				stream = new DeflaterOutputStream(stream, new Deflater(9, true))
				{
					IsStreamOwner = false
				};
			}
			else
			{
				stream = new ZipFile.UncompressedStream(stream);
			}
			return stream;
		}

		// Token: 0x06000426 RID: 1062 RVA: 0x000151B4 File Offset: 0x000141B4
		private void AddEntry(ZipFile workFile, ZipFile.ZipUpdate update)
		{
			Stream stream = null;
			if (update.Entry.IsFile)
			{
				stream = update.GetSource();
				if (stream == null)
				{
					stream = this.updateDataSource_.GetSource(update.Entry, update.Filename);
				}
			}
			if (stream != null)
			{
				using (stream)
				{
					long length = stream.Length;
					if (update.OutEntry.Size < 0L)
					{
						update.OutEntry.Size = length;
					}
					else if (update.OutEntry.Size != length)
					{
						throw new ZipException("Entry size/stream size mismatch");
					}
					workFile.WriteLocalEntryHeader(update);
					long position = workFile.baseStream_.Position;
					using (Stream outputStream = workFile.GetOutputStream(update.OutEntry))
					{
						this.CopyBytes(update, outputStream, stream, length, true);
					}
					long position2 = workFile.baseStream_.Position;
					update.OutEntry.CompressedSize = position2 - position;
					if ((update.OutEntry.Flags & 8) == 8)
					{
						ZipHelperStream zipHelperStream = new ZipHelperStream(workFile.baseStream_);
						zipHelperStream.WriteDataDescriptor(update.OutEntry);
					}
					return;
				}
			}
			workFile.WriteLocalEntryHeader(update);
			update.OutEntry.CompressedSize = 0L;
		}

		// Token: 0x06000427 RID: 1063 RVA: 0x000152F4 File Offset: 0x000142F4
		private void ModifyEntry(ZipFile workFile, ZipFile.ZipUpdate update)
		{
			workFile.WriteLocalEntryHeader(update);
			long position = workFile.baseStream_.Position;
			if (update.Entry.IsFile && update.Filename != null)
			{
				using (Stream outputStream = workFile.GetOutputStream(update.OutEntry))
				{
					using (Stream inputStream = this.GetInputStream(update.Entry))
					{
						this.CopyBytes(update, outputStream, inputStream, inputStream.Length, true);
					}
				}
			}
			long position2 = workFile.baseStream_.Position;
			update.Entry.CompressedSize = position2 - position;
		}

		// Token: 0x06000428 RID: 1064 RVA: 0x000153A4 File Offset: 0x000143A4
		private void CopyEntryDirect(ZipFile workFile, ZipFile.ZipUpdate update, ref long destinationPosition)
		{
			bool flag = false;
			if (update.Entry.Offset == destinationPosition)
			{
				flag = true;
			}
			if (!flag)
			{
				this.baseStream_.Position = destinationPosition;
				workFile.WriteLocalEntryHeader(update);
				destinationPosition = this.baseStream_.Position;
			}
			long num = 0L;
			long num2 = update.Entry.Offset + 26L;
			this.baseStream_.Seek(num2, SeekOrigin.Begin);
			uint num3 = (uint)this.ReadLEUshort();
			uint num4 = (uint)this.ReadLEUshort();
			num = this.baseStream_.Position + (long)((ulong)num3) + (long)((ulong)num4);
			if (!flag)
			{
				if (update.Entry.CompressedSize > 0L)
				{
					this.CopyEntryDataDirect(update, this.baseStream_, false, ref destinationPosition, ref num);
				}
				this.CopyDescriptorBytesDirect(update, this.baseStream_, ref destinationPosition, num);
				return;
			}
			if (update.OffsetBasedSize != -1L)
			{
				destinationPosition += update.OffsetBasedSize;
				return;
			}
			destinationPosition += num - num2 + 26L + update.Entry.CompressedSize + (long)this.GetDescriptorSize(update);
		}

		// Token: 0x06000429 RID: 1065 RVA: 0x00015498 File Offset: 0x00014498
		private void CopyEntry(ZipFile workFile, ZipFile.ZipUpdate update)
		{
			workFile.WriteLocalEntryHeader(update);
			if (update.Entry.CompressedSize > 0L)
			{
				long num = update.Entry.Offset + 26L;
				this.baseStream_.Seek(num, SeekOrigin.Begin);
				uint num2 = (uint)this.ReadLEUshort();
				uint num3 = (uint)this.ReadLEUshort();
				this.baseStream_.Seek((long)((ulong)(num2 + num3)), SeekOrigin.Current);
				this.CopyBytes(update, workFile.baseStream_, this.baseStream_, update.Entry.CompressedSize, false);
			}
			this.CopyDescriptorBytes(update, workFile.baseStream_, this.baseStream_);
		}

		// Token: 0x0600042A RID: 1066 RVA: 0x0001552A File Offset: 0x0001452A
		private void Reopen(Stream source)
		{
			if (source == null)
			{
				throw new ZipException("Failed to reopen archive - no source");
			}
			this.isNewArchive_ = false;
			this.baseStream_ = source;
			this.ReadEntries();
		}

		// Token: 0x0600042B RID: 1067 RVA: 0x0001554E File Offset: 0x0001454E
		private void Reopen()
		{
			if (this.Name == null)
			{
				throw new InvalidOperationException("Name is not known cannot Reopen");
			}
			this.Reopen(File.Open(this.Name, FileMode.Open, FileAccess.Read, FileShare.Read));
		}

		// Token: 0x0600042C RID: 1068 RVA: 0x00015578 File Offset: 0x00014578
		private void UpdateCommentOnly()
		{
			long length = this.baseStream_.Length;
			ZipHelperStream zipHelperStream;
			if (this.archiveStorage_.UpdateMode == FileUpdateMode.Safe)
			{
				Stream stream = this.archiveStorage_.MakeTemporaryCopy(this.baseStream_);
				zipHelperStream = new ZipHelperStream(stream);
				zipHelperStream.IsStreamOwner = true;
				this.baseStream_.Close();
				this.baseStream_ = null;
			}
			else if (this.archiveStorage_.UpdateMode == FileUpdateMode.Direct)
			{
				this.baseStream_ = this.archiveStorage_.OpenForDirectUpdate(this.baseStream_);
				zipHelperStream = new ZipHelperStream(this.baseStream_);
			}
			else
			{
				this.baseStream_.Close();
				this.baseStream_ = null;
				zipHelperStream = new ZipHelperStream(this.Name);
			}
			using (zipHelperStream)
			{
				long num = zipHelperStream.LocateBlockWithSignature(101010256, length, 22, 65535);
				if (num < 0L)
				{
					throw new ZipException("Cannot find central directory");
				}
				zipHelperStream.Position += 16L;
				byte[] rawComment = this.newComment_.RawComment;
				zipHelperStream.WriteLEShort(rawComment.Length);
				zipHelperStream.Write(rawComment, 0, rawComment.Length);
				zipHelperStream.SetLength(zipHelperStream.Position);
			}
			if (this.archiveStorage_.UpdateMode == FileUpdateMode.Safe)
			{
				this.Reopen(this.archiveStorage_.ConvertTemporaryToFinal());
				return;
			}
			this.ReadEntries();
		}

		// Token: 0x0600042D RID: 1069 RVA: 0x000156D0 File Offset: 0x000146D0
		private void RunUpdates()
		{
			long num = 0L;
			long num2 = 0L;
			bool flag = false;
			long num3 = 0L;
			ZipFile zipFile;
			if (this.IsNewArchive)
			{
				zipFile = this;
				zipFile.baseStream_.Position = 0L;
				flag = true;
			}
			else if (this.archiveStorage_.UpdateMode == FileUpdateMode.Direct)
			{
				zipFile = this;
				zipFile.baseStream_.Position = 0L;
				flag = true;
				this.updates_.Sort(new ZipFile.UpdateComparer());
			}
			else
			{
				zipFile = ZipFile.Create(this.archiveStorage_.GetTemporaryOutput());
				zipFile.UseZip64 = this.UseZip64;
				if (this.key != null)
				{
					zipFile.key = (byte[])this.key.Clone();
				}
			}
			try
			{
				foreach (object obj in this.updates_)
				{
					ZipFile.ZipUpdate zipUpdate = (ZipFile.ZipUpdate)obj;
					if (zipUpdate != null)
					{
						switch (zipUpdate.Command)
						{
						case ZipFile.UpdateCommand.Copy:
							if (flag)
							{
								this.CopyEntryDirect(zipFile, zipUpdate, ref num3);
							}
							else
							{
								this.CopyEntry(zipFile, zipUpdate);
							}
							break;
						case ZipFile.UpdateCommand.Modify:
							this.ModifyEntry(zipFile, zipUpdate);
							break;
						case ZipFile.UpdateCommand.Add:
							if (!this.IsNewArchive && flag)
							{
								zipFile.baseStream_.Position = num3;
							}
							this.AddEntry(zipFile, zipUpdate);
							if (flag)
							{
								num3 = zipFile.baseStream_.Position;
							}
							break;
						}
					}
				}
				if (!this.IsNewArchive && flag)
				{
					zipFile.baseStream_.Position = num3;
				}
				long position = zipFile.baseStream_.Position;
				foreach (object obj2 in this.updates_)
				{
					ZipFile.ZipUpdate zipUpdate2 = (ZipFile.ZipUpdate)obj2;
					if (zipUpdate2 != null)
					{
						num += (long)zipFile.WriteCentralDirectoryHeader(zipUpdate2.OutEntry);
					}
				}
				byte[] array = ((this.newComment_ != null) ? this.newComment_.RawComment : ZipConstants.ConvertToArray(this.comment_));
				using (ZipHelperStream zipHelperStream = new ZipHelperStream(zipFile.baseStream_))
				{
					zipHelperStream.WriteEndOfCentralDirectory(this.updateCount_, num, position, array);
				}
				num2 = zipFile.baseStream_.Position;
				foreach (object obj3 in this.updates_)
				{
					ZipFile.ZipUpdate zipUpdate3 = (ZipFile.ZipUpdate)obj3;
					if (zipUpdate3 != null)
					{
						if (zipUpdate3.CrcPatchOffset > 0L && zipUpdate3.OutEntry.CompressedSize > 0L)
						{
							zipFile.baseStream_.Position = zipUpdate3.CrcPatchOffset;
							zipFile.WriteLEInt((int)zipUpdate3.OutEntry.Crc);
						}
						if (zipUpdate3.SizePatchOffset > 0L)
						{
							zipFile.baseStream_.Position = zipUpdate3.SizePatchOffset;
							if (zipUpdate3.OutEntry.LocalHeaderRequiresZip64)
							{
								zipFile.WriteLeLong(zipUpdate3.OutEntry.Size);
								zipFile.WriteLeLong(zipUpdate3.OutEntry.CompressedSize);
							}
							else
							{
								zipFile.WriteLEInt((int)zipUpdate3.OutEntry.CompressedSize);
								zipFile.WriteLEInt((int)zipUpdate3.OutEntry.Size);
							}
						}
					}
				}
			}
			catch
			{
				zipFile.Close();
				if (!flag && zipFile.Name != null)
				{
					File.Delete(zipFile.Name);
				}
				throw;
			}
			if (flag)
			{
				zipFile.baseStream_.SetLength(num2);
				zipFile.baseStream_.Flush();
				this.isNewArchive_ = false;
				this.ReadEntries();
				return;
			}
			this.baseStream_.Close();
			this.Reopen(this.archiveStorage_.ConvertTemporaryToFinal());
		}

		// Token: 0x0600042E RID: 1070 RVA: 0x00015AFC File Offset: 0x00014AFC
		private void CheckUpdating()
		{
			if (this.updates_ == null)
			{
				throw new InvalidOperationException("BeginUpdate has not been called");
			}
		}

		// Token: 0x0600042F RID: 1071 RVA: 0x00015B11 File Offset: 0x00014B11
		void IDisposable.Dispose()
		{
			this.Close();
		}

		// Token: 0x06000430 RID: 1072 RVA: 0x00015B1C File Offset: 0x00014B1C
		private void DisposeInternal(bool disposing)
		{
			if (!this.isDisposed_)
			{
				this.isDisposed_ = true;
				this.entries_ = new ZipEntry[0];
				if (this.IsStreamOwner && this.baseStream_ != null)
				{
					lock (this.baseStream_)
					{
						this.baseStream_.Close();
					}
				}
				this.PostUpdateCleanup();
			}
		}

		// Token: 0x06000431 RID: 1073 RVA: 0x00015B8C File Offset: 0x00014B8C
		protected virtual void Dispose(bool disposing)
		{
			this.DisposeInternal(disposing);
		}

		// Token: 0x06000432 RID: 1074 RVA: 0x00015B98 File Offset: 0x00014B98
		private ushort ReadLEUshort()
		{
			int num = this.baseStream_.ReadByte();
			if (num < 0)
			{
				throw new EndOfStreamException("End of stream");
			}
			int num2 = this.baseStream_.ReadByte();
			if (num2 < 0)
			{
				throw new EndOfStreamException("End of stream");
			}
			return (ushort)num | (ushort)(num2 << 8);
		}

		// Token: 0x06000433 RID: 1075 RVA: 0x00015BE3 File Offset: 0x00014BE3
		private uint ReadLEUint()
		{
			return (uint)((int)this.ReadLEUshort() | ((int)this.ReadLEUshort() << 16));
		}

		// Token: 0x06000434 RID: 1076 RVA: 0x00015BF5 File Offset: 0x00014BF5
		private ulong ReadLEUlong()
		{
			return (ulong)this.ReadLEUint() | ((ulong)this.ReadLEUint() << 32);
		}

		// Token: 0x06000435 RID: 1077 RVA: 0x00015C0C File Offset: 0x00014C0C
		private long LocateBlockWithSignature(int signature, long endLocation, int minimumBlockSize, int maximumVariableData)
		{
			long num;
			using (ZipHelperStream zipHelperStream = new ZipHelperStream(this.baseStream_))
			{
				num = zipHelperStream.LocateBlockWithSignature(signature, endLocation, minimumBlockSize, maximumVariableData);
			}
			return num;
		}

		// Token: 0x06000436 RID: 1078 RVA: 0x00015C50 File Offset: 0x00014C50
		private void ReadEntries()
		{
			if (!this.baseStream_.CanSeek)
			{
				throw new ZipException("ZipFile stream must be seekable");
			}
			long num = this.LocateBlockWithSignature(101010256, this.baseStream_.Length, 22, 65535);
			if (num < 0L)
			{
				throw new ZipException("Cannot find central directory");
			}
			ushort num2 = this.ReadLEUshort();
			ushort num3 = this.ReadLEUshort();
			ulong num4 = (ulong)this.ReadLEUshort();
			ulong num5 = (ulong)this.ReadLEUshort();
			ulong num6 = (ulong)this.ReadLEUint();
			long num7 = (long)((ulong)this.ReadLEUint());
			uint num8 = (uint)this.ReadLEUshort();
			if (num8 > 0U)
			{
				byte[] array = new byte[num8];
				StreamUtils.ReadFully(this.baseStream_, array);
				this.comment_ = ZipConstants.ConvertToString(array);
			}
			else
			{
				this.comment_ = string.Empty;
			}
			bool flag = false;
			if (num2 == 65535 || num3 == 65535 || num4 == 65535UL || num5 == 65535UL || num6 == (ulong)(-1) || num7 == (long)((ulong)(-1)))
			{
				flag = true;
				long num9 = this.LocateBlockWithSignature(117853008, num, 0, 4096);
				if (num9 < 0L)
				{
					throw new ZipException("Cannot find Zip64 locator");
				}
				this.ReadLEUint();
				ulong num10 = this.ReadLEUlong();
				this.ReadLEUint();
				this.baseStream_.Position = (long)num10;
				long num11 = (long)((ulong)this.ReadLEUint());
				if (num11 != 101075792L)
				{
					throw new ZipException(string.Format("Invalid Zip64 Central directory signature at {0:X}", num10));
				}
				this.ReadLEUlong();
				this.ReadLEUshort();
				this.ReadLEUshort();
				this.ReadLEUint();
				this.ReadLEUint();
				num4 = this.ReadLEUlong();
				num5 = this.ReadLEUlong();
				num6 = this.ReadLEUlong();
				num7 = (long)this.ReadLEUlong();
			}
			this.entries_ = new ZipEntry[num4];
			if (!flag && num7 < num - (long)(4UL + num6))
			{
				this.offsetOfFirstEntry = num - (long)(4UL + num6 + (ulong)num7);
				if (this.offsetOfFirstEntry <= 0L)
				{
					throw new ZipException("Invalid embedded zip archive");
				}
			}
			this.baseStream_.Seek(this.offsetOfFirstEntry + num7, SeekOrigin.Begin);
			for (ulong num12 = 0UL; num12 < num4; num12 += 1UL)
			{
				if (this.ReadLEUint() != 33639248U)
				{
					throw new ZipException("Wrong Central Directory signature");
				}
				int num13 = (int)this.ReadLEUshort();
				int num14 = (int)this.ReadLEUshort();
				int num15 = (int)this.ReadLEUshort();
				int num16 = (int)this.ReadLEUshort();
				uint num17 = this.ReadLEUint();
				uint num18 = this.ReadLEUint();
				long num19 = (long)((ulong)this.ReadLEUint());
				long num20 = (long)((ulong)this.ReadLEUint());
				int num21 = (int)this.ReadLEUshort();
				int num22 = (int)this.ReadLEUshort();
				int num23 = (int)this.ReadLEUshort();
				this.ReadLEUshort();
				this.ReadLEUshort();
				uint num24 = this.ReadLEUint();
				long num25 = (long)((ulong)this.ReadLEUint());
				byte[] array2 = new byte[Math.Max(num21, num23)];
				StreamUtils.ReadFully(this.baseStream_, array2, 0, num21);
				string text = ZipConstants.ConvertToStringExt(num15, array2, num21);
				ZipEntry zipEntry = new ZipEntry(text, num14, num13, (CompressionMethod)num16);
				zipEntry.Crc = (long)((ulong)num18 & (ulong)(-1));
				zipEntry.Size = num20 & (long)((ulong)(-1));
				zipEntry.CompressedSize = num19 & (long)((ulong)(-1));
				zipEntry.Flags = num15;
				zipEntry.DosTime = (long)((ulong)num17);
				zipEntry.ZipFileIndex = (long)num12;
				zipEntry.Offset = num25;
				zipEntry.ExternalFileAttributes = (int)num24;
				if ((num15 & 8) == 0)
				{
					zipEntry.CryptoCheckValue = (byte)(num18 >> 24);
				}
				else
				{
					zipEntry.CryptoCheckValue = (byte)((num17 >> 8) & 255U);
				}
				if (num22 > 0)
				{
					byte[] array3 = new byte[num22];
					StreamUtils.ReadFully(this.baseStream_, array3);
					zipEntry.ExtraData = array3;
				}
				zipEntry.ProcessExtraData(false);
				if (num23 > 0)
				{
					StreamUtils.ReadFully(this.baseStream_, array2, 0, num23);
					zipEntry.Comment = ZipConstants.ConvertToStringExt(num15, array2, num23);
				}
				this.entries_[(int)(checked((IntPtr)num12))] = zipEntry;
			}
		}

		// Token: 0x06000437 RID: 1079 RVA: 0x00016013 File Offset: 0x00015013
		private long LocateEntry(ZipEntry entry)
		{
			return this.TestLocalHeader(entry, ZipFile.HeaderTest.Extract);
		}

		// Token: 0x06000438 RID: 1080 RVA: 0x00016020 File Offset: 0x00015020
		private Stream CreateAndInitDecryptionStream(Stream baseStream, ZipEntry entry)
		{
			CryptoStream cryptoStream;
			if (entry.Version < 50 || (entry.Flags & 64) == 0)
			{
				PkzipClassicManaged pkzipClassicManaged = new PkzipClassicManaged();
				this.OnKeysRequired(entry.Name);
				if (!this.HaveKeys)
				{
					throw new ZipException("No password available for encrypted stream");
				}
				cryptoStream = new CryptoStream(baseStream, pkzipClassicManaged.CreateDecryptor(this.key, null), CryptoStreamMode.Read);
				ZipFile.CheckClassicPassword(cryptoStream, entry);
			}
			else
			{
				if (entry.Version != 51)
				{
					throw new ZipException("Decryption method not supported");
				}
				this.OnKeysRequired(entry.Name);
				if (!this.HaveKeys)
				{
					throw new ZipException("No password available for AES encrypted stream");
				}
				int aessaltLen = entry.AESSaltLen;
				byte[] array = new byte[aessaltLen];
				int num = baseStream.Read(array, 0, aessaltLen);
				if (num != aessaltLen)
				{
					throw new ZipException(string.Concat(new object[] { "AES Salt expected ", aessaltLen, " got ", num }));
				}
				byte[] array2 = new byte[2];
				baseStream.Read(array2, 0, 2);
				int num2 = entry.AESKeySize / 8;
				ZipAESTransform zipAESTransform = new ZipAESTransform(this.rawPassword_, array, num2, false);
				byte[] pwdVerifier = zipAESTransform.PwdVerifier;
				if (pwdVerifier[0] != array2[0] || pwdVerifier[1] != array2[1])
				{
					throw new Exception("Invalid password for AES");
				}
				cryptoStream = new ZipAESStream(baseStream, zipAESTransform, CryptoStreamMode.Read);
			}
			return cryptoStream;
		}

		// Token: 0x06000439 RID: 1081 RVA: 0x00016180 File Offset: 0x00015180
		private Stream CreateAndInitEncryptionStream(Stream baseStream, ZipEntry entry)
		{
			CryptoStream cryptoStream = null;
			if (entry.Version < 50 || (entry.Flags & 64) == 0)
			{
				PkzipClassicManaged pkzipClassicManaged = new PkzipClassicManaged();
				this.OnKeysRequired(entry.Name);
				if (!this.HaveKeys)
				{
					throw new ZipException("No password available for encrypted stream");
				}
				cryptoStream = new CryptoStream(new ZipFile.UncompressedStream(baseStream), pkzipClassicManaged.CreateEncryptor(this.key, null), CryptoStreamMode.Write);
				if (entry.Crc < 0L || (entry.Flags & 8) != 0)
				{
					ZipFile.WriteEncryptionHeader(cryptoStream, entry.DosTime << 16);
				}
				else
				{
					ZipFile.WriteEncryptionHeader(cryptoStream, entry.Crc);
				}
			}
			return cryptoStream;
		}

		// Token: 0x0600043A RID: 1082 RVA: 0x00016218 File Offset: 0x00015218
		private static void CheckClassicPassword(CryptoStream classicCryptoStream, ZipEntry entry)
		{
			byte[] array = new byte[12];
			StreamUtils.ReadFully(classicCryptoStream, array);
			if (array[11] != entry.CryptoCheckValue)
			{
				throw new ZipException("Invalid password");
			}
		}

		// Token: 0x0600043B RID: 1083 RVA: 0x0001624C File Offset: 0x0001524C
		private static void WriteEncryptionHeader(Stream stream, long crcValue)
		{
			byte[] array = new byte[12];
			Random random = new Random();
			random.NextBytes(array);
			array[11] = (byte)(crcValue >> 24);
			stream.Write(array, 0, array.Length);
		}

		// Token: 0x040002D5 RID: 725
		private const int DefaultBufferSize = 4096;

		// Token: 0x040002D6 RID: 726
		public ZipFile.KeysRequiredEventHandler KeysRequired;

		// Token: 0x040002D7 RID: 727
		private bool isDisposed_;

		// Token: 0x040002D8 RID: 728
		private string name_;

		// Token: 0x040002D9 RID: 729
		private string comment_;

		// Token: 0x040002DA RID: 730
		private string rawPassword_;

		// Token: 0x040002DB RID: 731
		private Stream baseStream_;

		// Token: 0x040002DC RID: 732
		private bool isStreamOwner;

		// Token: 0x040002DD RID: 733
		private long offsetOfFirstEntry;

		// Token: 0x040002DE RID: 734
		private ZipEntry[] entries_;

		// Token: 0x040002DF RID: 735
		private byte[] key;

		// Token: 0x040002E0 RID: 736
		private bool isNewArchive_;

		// Token: 0x040002E1 RID: 737
		private UseZip64 useZip64_ = UseZip64.Dynamic;

		// Token: 0x040002E2 RID: 738
		private ArrayList updates_;

		// Token: 0x040002E3 RID: 739
		private long updateCount_;

		// Token: 0x040002E4 RID: 740
		private Hashtable updateIndex_;

		// Token: 0x040002E5 RID: 741
		private IArchiveStorage archiveStorage_;

		// Token: 0x040002E6 RID: 742
		private IDynamicDataSource updateDataSource_;

		// Token: 0x040002E7 RID: 743
		private bool contentsEdited_;

		// Token: 0x040002E8 RID: 744
		private int bufferSize_ = 4096;

		// Token: 0x040002E9 RID: 745
		private byte[] copyBuffer_;

		// Token: 0x040002EA RID: 746
		private ZipFile.ZipString newComment_;

		// Token: 0x040002EB RID: 747
		private bool commentEdited_;

		// Token: 0x040002EC RID: 748
		private IEntryFactory updateEntryFactory_ = new ZipEntryFactory();

		// Token: 0x02000069 RID: 105
		// (Invoke) Token: 0x0600043D RID: 1085
		public delegate void KeysRequiredEventHandler(object sender, KeysRequiredEventArgs e);

		// Token: 0x0200006A RID: 106
		[Flags]
		private enum HeaderTest
		{
			// Token: 0x040002EE RID: 750
			Extract = 1,
			// Token: 0x040002EF RID: 751
			Header = 2
		}

		// Token: 0x0200006B RID: 107
		private enum UpdateCommand
		{
			// Token: 0x040002F1 RID: 753
			Copy,
			// Token: 0x040002F2 RID: 754
			Modify,
			// Token: 0x040002F3 RID: 755
			Add
		}

		// Token: 0x0200006C RID: 108
		private class UpdateComparer : IComparer
		{
			// Token: 0x06000440 RID: 1088 RVA: 0x00016284 File Offset: 0x00015284
			public int Compare(object x, object y)
			{
				ZipFile.ZipUpdate zipUpdate = x as ZipFile.ZipUpdate;
				ZipFile.ZipUpdate zipUpdate2 = y as ZipFile.ZipUpdate;
				int num;
				if (zipUpdate == null)
				{
					if (zipUpdate2 == null)
					{
						num = 0;
					}
					else
					{
						num = -1;
					}
				}
				else if (zipUpdate2 == null)
				{
					num = 1;
				}
				else
				{
					int num2 = ((zipUpdate.Command == ZipFile.UpdateCommand.Copy || zipUpdate.Command == ZipFile.UpdateCommand.Modify) ? 0 : 1);
					int num3 = ((zipUpdate2.Command == ZipFile.UpdateCommand.Copy || zipUpdate2.Command == ZipFile.UpdateCommand.Modify) ? 0 : 1);
					num = num2 - num3;
					if (num == 0)
					{
						long num4 = zipUpdate.Entry.Offset - zipUpdate2.Entry.Offset;
						if (num4 < 0L)
						{
							num = -1;
						}
						else if (num4 == 0L)
						{
							num = 0;
						}
						else
						{
							num = 1;
						}
					}
				}
				return num;
			}
		}

		// Token: 0x0200006D RID: 109
		private class ZipUpdate
		{
			// Token: 0x06000442 RID: 1090 RVA: 0x00016321 File Offset: 0x00015321
			public ZipUpdate(string fileName, ZipEntry entry)
			{
				this.command_ = ZipFile.UpdateCommand.Add;
				this.entry_ = entry;
				this.filename_ = fileName;
			}

			// Token: 0x06000443 RID: 1091 RVA: 0x00016358 File Offset: 0x00015358
			[Obsolete]
			public ZipUpdate(string fileName, string entryName, CompressionMethod compressionMethod)
			{
				this.command_ = ZipFile.UpdateCommand.Add;
				this.entry_ = new ZipEntry(entryName);
				this.entry_.CompressionMethod = compressionMethod;
				this.filename_ = fileName;
			}

			// Token: 0x06000444 RID: 1092 RVA: 0x000163A9 File Offset: 0x000153A9
			[Obsolete]
			public ZipUpdate(string fileName, string entryName)
				: this(fileName, entryName, CompressionMethod.Deflated)
			{
			}

			// Token: 0x06000445 RID: 1093 RVA: 0x000163B4 File Offset: 0x000153B4
			[Obsolete]
			public ZipUpdate(IStaticDataSource dataSource, string entryName, CompressionMethod compressionMethod)
			{
				this.command_ = ZipFile.UpdateCommand.Add;
				this.entry_ = new ZipEntry(entryName);
				this.entry_.CompressionMethod = compressionMethod;
				this.dataSource_ = dataSource;
			}

			// Token: 0x06000446 RID: 1094 RVA: 0x00016405 File Offset: 0x00015405
			public ZipUpdate(IStaticDataSource dataSource, ZipEntry entry)
			{
				this.command_ = ZipFile.UpdateCommand.Add;
				this.entry_ = entry;
				this.dataSource_ = dataSource;
			}

			// Token: 0x06000447 RID: 1095 RVA: 0x0001643A File Offset: 0x0001543A
			public ZipUpdate(ZipEntry original, ZipEntry updated)
			{
				throw new ZipException("Modify not currently supported");
			}

			// Token: 0x06000448 RID: 1096 RVA: 0x00016464 File Offset: 0x00015464
			public ZipUpdate(ZipFile.UpdateCommand command, ZipEntry entry)
			{
				this.command_ = command;
				this.entry_ = (ZipEntry)entry.Clone();
			}

			// Token: 0x06000449 RID: 1097 RVA: 0x0001649C File Offset: 0x0001549C
			public ZipUpdate(ZipEntry entry)
				: this(ZipFile.UpdateCommand.Copy, entry)
			{
			}

			// Token: 0x170000F7 RID: 247
			// (get) Token: 0x0600044A RID: 1098 RVA: 0x000164A6 File Offset: 0x000154A6
			public ZipEntry Entry
			{
				get
				{
					return this.entry_;
				}
			}

			// Token: 0x170000F8 RID: 248
			// (get) Token: 0x0600044B RID: 1099 RVA: 0x000164AE File Offset: 0x000154AE
			public ZipEntry OutEntry
			{
				get
				{
					if (this.outEntry_ == null)
					{
						this.outEntry_ = (ZipEntry)this.entry_.Clone();
					}
					return this.outEntry_;
				}
			}

			// Token: 0x170000F9 RID: 249
			// (get) Token: 0x0600044C RID: 1100 RVA: 0x000164D4 File Offset: 0x000154D4
			public ZipFile.UpdateCommand Command
			{
				get
				{
					return this.command_;
				}
			}

			// Token: 0x170000FA RID: 250
			// (get) Token: 0x0600044D RID: 1101 RVA: 0x000164DC File Offset: 0x000154DC
			public string Filename
			{
				get
				{
					return this.filename_;
				}
			}

			// Token: 0x170000FB RID: 251
			// (get) Token: 0x0600044E RID: 1102 RVA: 0x000164E4 File Offset: 0x000154E4
			// (set) Token: 0x0600044F RID: 1103 RVA: 0x000164EC File Offset: 0x000154EC
			public long SizePatchOffset
			{
				get
				{
					return this.sizePatchOffset_;
				}
				set
				{
					this.sizePatchOffset_ = value;
				}
			}

			// Token: 0x170000FC RID: 252
			// (get) Token: 0x06000450 RID: 1104 RVA: 0x000164F5 File Offset: 0x000154F5
			// (set) Token: 0x06000451 RID: 1105 RVA: 0x000164FD File Offset: 0x000154FD
			public long CrcPatchOffset
			{
				get
				{
					return this.crcPatchOffset_;
				}
				set
				{
					this.crcPatchOffset_ = value;
				}
			}

			// Token: 0x170000FD RID: 253
			// (get) Token: 0x06000452 RID: 1106 RVA: 0x00016506 File Offset: 0x00015506
			// (set) Token: 0x06000453 RID: 1107 RVA: 0x0001650E File Offset: 0x0001550E
			public long OffsetBasedSize
			{
				get
				{
					return this._offsetBasedSize;
				}
				set
				{
					this._offsetBasedSize = value;
				}
			}

			// Token: 0x06000454 RID: 1108 RVA: 0x00016518 File Offset: 0x00015518
			public Stream GetSource()
			{
				Stream stream = null;
				if (this.dataSource_ != null)
				{
					stream = this.dataSource_.GetSource();
				}
				return stream;
			}

			// Token: 0x040002F4 RID: 756
			private ZipEntry entry_;

			// Token: 0x040002F5 RID: 757
			private ZipEntry outEntry_;

			// Token: 0x040002F6 RID: 758
			private ZipFile.UpdateCommand command_;

			// Token: 0x040002F7 RID: 759
			private IStaticDataSource dataSource_;

			// Token: 0x040002F8 RID: 760
			private string filename_;

			// Token: 0x040002F9 RID: 761
			private long sizePatchOffset_ = -1L;

			// Token: 0x040002FA RID: 762
			private long crcPatchOffset_ = -1L;

			// Token: 0x040002FB RID: 763
			private long _offsetBasedSize = -1L;
		}

		// Token: 0x0200006E RID: 110
		private class ZipString
		{
			// Token: 0x06000455 RID: 1109 RVA: 0x0001653C File Offset: 0x0001553C
			public ZipString(string comment)
			{
				this.comment_ = comment;
				this.isSourceString_ = true;
			}

			// Token: 0x06000456 RID: 1110 RVA: 0x00016552 File Offset: 0x00015552
			public ZipString(byte[] rawString)
			{
				this.rawComment_ = rawString;
			}

			// Token: 0x170000FE RID: 254
			// (get) Token: 0x06000457 RID: 1111 RVA: 0x00016561 File Offset: 0x00015561
			public bool IsSourceString
			{
				get
				{
					return this.isSourceString_;
				}
			}

			// Token: 0x170000FF RID: 255
			// (get) Token: 0x06000458 RID: 1112 RVA: 0x00016569 File Offset: 0x00015569
			public int RawLength
			{
				get
				{
					this.MakeBytesAvailable();
					return this.rawComment_.Length;
				}
			}

			// Token: 0x17000100 RID: 256
			// (get) Token: 0x06000459 RID: 1113 RVA: 0x00016579 File Offset: 0x00015579
			public byte[] RawComment
			{
				get
				{
					this.MakeBytesAvailable();
					return (byte[])this.rawComment_.Clone();
				}
			}

			// Token: 0x0600045A RID: 1114 RVA: 0x00016591 File Offset: 0x00015591
			public void Reset()
			{
				if (this.isSourceString_)
				{
					this.rawComment_ = null;
					return;
				}
				this.comment_ = null;
			}

			// Token: 0x0600045B RID: 1115 RVA: 0x000165AA File Offset: 0x000155AA
			private void MakeTextAvailable()
			{
				if (this.comment_ == null)
				{
					this.comment_ = ZipConstants.ConvertToString(this.rawComment_);
				}
			}

			// Token: 0x0600045C RID: 1116 RVA: 0x000165C5 File Offset: 0x000155C5
			private void MakeBytesAvailable()
			{
				if (this.rawComment_ == null)
				{
					this.rawComment_ = ZipConstants.ConvertToArray(this.comment_);
				}
			}

			// Token: 0x0600045D RID: 1117 RVA: 0x000165E0 File Offset: 0x000155E0
			public static implicit operator string(ZipFile.ZipString zipString)
			{
				zipString.MakeTextAvailable();
				return zipString.comment_;
			}

			// Token: 0x040002FC RID: 764
			private string comment_;

			// Token: 0x040002FD RID: 765
			private byte[] rawComment_;

			// Token: 0x040002FE RID: 766
			private bool isSourceString_;
		}

		// Token: 0x0200006F RID: 111
		private class ZipEntryEnumerator : IEnumerator
		{
			// Token: 0x0600045E RID: 1118 RVA: 0x000165EE File Offset: 0x000155EE
			public ZipEntryEnumerator(ZipEntry[] entries)
			{
				this.array = entries;
			}

			// Token: 0x17000101 RID: 257
			// (get) Token: 0x0600045F RID: 1119 RVA: 0x00016604 File Offset: 0x00015604
			public object Current
			{
				get
				{
					return this.array[this.index];
				}
			}

			// Token: 0x06000460 RID: 1120 RVA: 0x00016613 File Offset: 0x00015613
			public void Reset()
			{
				this.index = -1;
			}

			// Token: 0x06000461 RID: 1121 RVA: 0x0001661C File Offset: 0x0001561C
			public bool MoveNext()
			{
				return ++this.index < this.array.Length;
			}

			// Token: 0x040002FF RID: 767
			private ZipEntry[] array;

			// Token: 0x04000300 RID: 768
			private int index = -1;
		}

		// Token: 0x02000070 RID: 112
		private class UncompressedStream : Stream
		{
			// Token: 0x06000462 RID: 1122 RVA: 0x00016644 File Offset: 0x00015644
			public UncompressedStream(Stream baseStream)
			{
				this.baseStream_ = baseStream;
			}

			// Token: 0x06000463 RID: 1123 RVA: 0x00016653 File Offset: 0x00015653
			public override void Close()
			{
			}

			// Token: 0x17000102 RID: 258
			// (get) Token: 0x06000464 RID: 1124 RVA: 0x00016655 File Offset: 0x00015655
			public override bool CanRead
			{
				get
				{
					return false;
				}
			}

			// Token: 0x06000465 RID: 1125 RVA: 0x00016658 File Offset: 0x00015658
			public override void Flush()
			{
				this.baseStream_.Flush();
			}

			// Token: 0x17000103 RID: 259
			// (get) Token: 0x06000466 RID: 1126 RVA: 0x00016665 File Offset: 0x00015665
			public override bool CanWrite
			{
				get
				{
					return this.baseStream_.CanWrite;
				}
			}

			// Token: 0x17000104 RID: 260
			// (get) Token: 0x06000467 RID: 1127 RVA: 0x00016672 File Offset: 0x00015672
			public override bool CanSeek
			{
				get
				{
					return false;
				}
			}

			// Token: 0x17000105 RID: 261
			// (get) Token: 0x06000468 RID: 1128 RVA: 0x00016675 File Offset: 0x00015675
			public override long Length
			{
				get
				{
					return 0L;
				}
			}

			// Token: 0x17000106 RID: 262
			// (get) Token: 0x06000469 RID: 1129 RVA: 0x00016679 File Offset: 0x00015679
			// (set) Token: 0x0600046A RID: 1130 RVA: 0x00016686 File Offset: 0x00015686
			public override long Position
			{
				get
				{
					return this.baseStream_.Position;
				}
				set
				{
				}
			}

			// Token: 0x0600046B RID: 1131 RVA: 0x00016688 File Offset: 0x00015688
			public override int Read(byte[] buffer, int offset, int count)
			{
				return 0;
			}

			// Token: 0x0600046C RID: 1132 RVA: 0x0001668B File Offset: 0x0001568B
			public override long Seek(long offset, SeekOrigin origin)
			{
				return 0L;
			}

			// Token: 0x0600046D RID: 1133 RVA: 0x0001668F File Offset: 0x0001568F
			public override void SetLength(long value)
			{
			}

			// Token: 0x0600046E RID: 1134 RVA: 0x00016691 File Offset: 0x00015691
			public override void Write(byte[] buffer, int offset, int count)
			{
				this.baseStream_.Write(buffer, offset, count);
			}

			// Token: 0x04000301 RID: 769
			private Stream baseStream_;
		}

		// Token: 0x02000071 RID: 113
		private class PartialInputStream : Stream
		{
			// Token: 0x0600046F RID: 1135 RVA: 0x000166A1 File Offset: 0x000156A1
			public PartialInputStream(ZipFile zipFile, long start, long length)
			{
				this.start_ = start;
				this.length_ = length;
				this.zipFile_ = zipFile;
				this.baseStream_ = this.zipFile_.baseStream_;
				this.readPos_ = start;
				this.end_ = start + length;
			}

			// Token: 0x06000470 RID: 1136 RVA: 0x000166E0 File Offset: 0x000156E0
			public override int ReadByte()
			{
				if (this.readPos_ >= this.end_)
				{
					return -1;
				}
				int num2;
				lock (this.baseStream_)
				{
					Stream stream2 = this.baseStream_;
					long num;
					this.readPos_ = (num = this.readPos_) + 1L;
					stream2.Seek(num, SeekOrigin.Begin);
					num2 = this.baseStream_.ReadByte();
				}
				return num2;
			}

			// Token: 0x06000471 RID: 1137 RVA: 0x00016750 File Offset: 0x00015750
			public override void Close()
			{
			}

			// Token: 0x06000472 RID: 1138 RVA: 0x00016754 File Offset: 0x00015754
			public override int Read(byte[] buffer, int offset, int count)
			{
				int num2;
				lock (this.baseStream_)
				{
					if ((long)count > this.end_ - this.readPos_)
					{
						count = (int)(this.end_ - this.readPos_);
						if (count == 0)
						{
							return 0;
						}
					}
					this.baseStream_.Seek(this.readPos_, SeekOrigin.Begin);
					int num = this.baseStream_.Read(buffer, offset, count);
					if (num > 0)
					{
						this.readPos_ += (long)num;
					}
					num2 = num;
				}
				return num2;
			}

			// Token: 0x06000473 RID: 1139 RVA: 0x000167E8 File Offset: 0x000157E8
			public override void Write(byte[] buffer, int offset, int count)
			{
				throw new NotSupportedException();
			}

			// Token: 0x06000474 RID: 1140 RVA: 0x000167EF File Offset: 0x000157EF
			public override void SetLength(long value)
			{
				throw new NotSupportedException();
			}

			// Token: 0x06000475 RID: 1141 RVA: 0x000167F8 File Offset: 0x000157F8
			public override long Seek(long offset, SeekOrigin origin)
			{
				long num = this.readPos_;
				switch (origin)
				{
				case SeekOrigin.Begin:
					num = this.start_ + offset;
					break;
				case SeekOrigin.Current:
					num = this.readPos_ + offset;
					break;
				case SeekOrigin.End:
					num = this.end_ + offset;
					break;
				}
				if (num < this.start_)
				{
					throw new ArgumentException("Negative position is invalid");
				}
				if (num >= this.end_)
				{
					throw new IOException("Cannot seek past end");
				}
				this.readPos_ = num;
				return this.readPos_;
			}

			// Token: 0x06000476 RID: 1142 RVA: 0x00016876 File Offset: 0x00015876
			public override void Flush()
			{
			}

			// Token: 0x17000107 RID: 263
			// (get) Token: 0x06000477 RID: 1143 RVA: 0x00016878 File Offset: 0x00015878
			// (set) Token: 0x06000478 RID: 1144 RVA: 0x00016888 File Offset: 0x00015888
			public override long Position
			{
				get
				{
					return this.readPos_ - this.start_;
				}
				set
				{
					long num = this.start_ + value;
					if (num < this.start_)
					{
						throw new ArgumentException("Negative position is invalid");
					}
					if (num >= this.end_)
					{
						throw new InvalidOperationException("Cannot seek past end");
					}
					this.readPos_ = num;
				}
			}

			// Token: 0x17000108 RID: 264
			// (get) Token: 0x06000479 RID: 1145 RVA: 0x000168CD File Offset: 0x000158CD
			public override long Length
			{
				get
				{
					return this.length_;
				}
			}

			// Token: 0x17000109 RID: 265
			// (get) Token: 0x0600047A RID: 1146 RVA: 0x000168D5 File Offset: 0x000158D5
			public override bool CanWrite
			{
				get
				{
					return false;
				}
			}

			// Token: 0x1700010A RID: 266
			// (get) Token: 0x0600047B RID: 1147 RVA: 0x000168D8 File Offset: 0x000158D8
			public override bool CanSeek
			{
				get
				{
					return true;
				}
			}

			// Token: 0x1700010B RID: 267
			// (get) Token: 0x0600047C RID: 1148 RVA: 0x000168DB File Offset: 0x000158DB
			public override bool CanRead
			{
				get
				{
					return true;
				}
			}

			// Token: 0x1700010C RID: 268
			// (get) Token: 0x0600047D RID: 1149 RVA: 0x000168DE File Offset: 0x000158DE
			public override bool CanTimeout
			{
				get
				{
					return this.baseStream_.CanTimeout;
				}
			}

			// Token: 0x04000302 RID: 770
			private ZipFile zipFile_;

			// Token: 0x04000303 RID: 771
			private Stream baseStream_;

			// Token: 0x04000304 RID: 772
			private long start_;

			// Token: 0x04000305 RID: 773
			private long length_;

			// Token: 0x04000306 RID: 774
			private long readPos_;

			// Token: 0x04000307 RID: 775
			private long end_;
		}
	}
}