rework

Author: dellis1972

LibZipSharp/Xamarin.Tools.Zip/ZipArchive.cs

@@ -40,6 +40,33 @@ namespace Xamarin.Tools.Zip
 	/// </summary>
 	public abstract partial class ZipArchive : IDisposable, IEnumerable <ZipEntry>
 	{
+		internal class CallbackContext : IDisposable {
+			bool disposed;
+			public Stream Source = null;
+			public Stream Destination = null;
+
+			protected virtual void Dispose (bool disposing)
+			{
+				if (!disposed) {
+					if (disposing) {
+						if (Source != null) {
+							Source.Dispose ();
+							Source = null;
+						}
+						if (Destination != null) {
+							Destination.Dispose ();
+							Destination = null;
+						}
+					}
+					disposed = true;
+				}
+			}
+			public void Dispose ()
+			{
+				Dispose (true);
+				GC.SuppressFinalize (this);
+			}
+		}
 		public const EntryPermissions DefaultFilePermissions = EntryPermissions.OwnerRead | EntryPermissions.OwnerWrite | EntryPermissions.GroupRead | EntryPermissions.WorldRead;
 		public const EntryPermissions DefaultDirectoryPermissions = EntryPermissions.OwnerAll | EntryPermissions.GroupRead | EntryPermissions.GroupExecute |  EntryPermissions.WorldRead | EntryPermissions.WorldExecute;
 
@@ -87,9 +114,12 @@ internal ZipArchive (Stream stream, IPlatformOptions options, OpenFlags flags =
 				throw new ArgumentNullException (nameof (options));
 			Options = options;
 			Native.zip_error_t errorp;
-			var streamHandle = GCHandle.Alloc (stream, GCHandleType.Normal);
-			IntPtr h = GCHandle.ToIntPtr (streamHandle);
-			IntPtr source = Native.zip_source_function_create (callback, h, out errorp);
+			CallbackContext context = new CallbackContext () {
+				Source = stream,
+				Destination = null,
+			};
+			var contextHandle = GCHandle.Alloc (context, GCHandleType.Normal);
+			IntPtr source = Native.zip_source_function_create (callback, GCHandle.ToIntPtr (contextHandle), out errorp);
 			archive = Native.zip_open_from_source (source, flags, out errorp);
 			if (archive == IntPtr.Zero) {
 				// error;
@@ -323,7 +353,10 @@ public ZipEntry AddStream (Stream stream, string archivePath, EntryPermissions p
 				throw new ArgumentNullException (nameof (stream));
 			sources.Add (stream);
 			string destPath = EnsureArchivePath (archivePath);
-			var handle = GCHandle.Alloc (stream, GCHandleType.Normal);
+			var context = new CallbackContext () {
+				Source = stream,
+			};
+			var handle = GCHandle.Alloc (context, GCHandleType.Normal);
 			IntPtr h = GCHandle.ToIntPtr (handle);
 			IntPtr source = Native.zip_source_function (archive, callback, h);
 			long index = Native.zip_file_add (archive, destPath, source, overwriteExisting ? OperationFlags.Overwrite : OperationFlags.None);
@@ -758,9 +791,13 @@ internal static unsafe Int64 stream_callback (IntPtr state, IntPtr data, UInt64
 			var handle = GCHandle.FromIntPtr (state);
 			if (!handle.IsAllocated)
 				return -1;
-			var stream = handle.Target as Stream;
+			var context = handle.Target as CallbackContext;
+			if (context == null)
+				return -1;
+			var stream = context.Source;
 			if (stream == null)
 				return -1;
+			var destination = context.Destination ?? context.Source;
 			switch (cmd) {
 				case SourceCommand.Stat:
 					if (len < (UInt64)sizeof (Native.zip_stat_t))
@@ -773,36 +810,56 @@ internal static unsafe Int64 stream_callback (IntPtr state, IntPtr data, UInt64
 					return (Int64)sizeof (Native.zip_stat_t);
 
 				case SourceCommand.Tell:
-				case SourceCommand.TellWrite:
 					return (Int64)stream.Position;
+				case SourceCommand.TellWrite:
+					return (Int64)destination.Position;
 
 				case SourceCommand.Write:
 					buffer = ArrayPool<byte>.Shared.Rent (length);
 					try {
 						Marshal.Copy (data, buffer, 0, length);
-						stream.Write (buffer, 0, length);
+						destination.Write (buffer, 0, length);
 						return length;
 					} finally {
 						ArrayPool<byte>.Shared.Return (buffer);
 					}
 
 				case SourceCommand.SeekWrite:
-				case SourceCommand.Seek:
 					Native.zip_error_t error;
-					Int64 offset = Native.zip_source_seek_compute_offset ((UInt64)stream.Position, (UInt64)stream.Length, data, len, out error);
-					if (offset < 0)
+					Int64 offset = Native.zip_source_seek_compute_offset ((UInt64)destination.Position, (UInt64)destination.Length, data, len, out error);
+					if (offset < 0) {
+						return offset;
+					}
+					if (offset != stream.Seek (offset, SeekOrigin.Begin)) {
+						return -1;
+					}
+					break;
+				case SourceCommand.Seek:
+					offset = Native.zip_source_seek_compute_offset ((UInt64)stream.Position, (UInt64)stream.Length, data, len, out error);
+					if (offset < 0) {
 						return offset;
-					stream.Seek ((long)offset, SeekOrigin.Begin);
+					}
+					if (offset != stream.Seek (offset, SeekOrigin.Begin)) {
+						return -1;
+					}
 					break;
 
 				case SourceCommand.CommitWrite:
-					stream.Flush ();
+					destination.Flush ();
+					stream.Position = 0;
+					destination.Position = 0;
+					stream.SetLength (destination.Length);
+					destination.CopyTo (stream);
+					stream.Position = 0;
+					destination.Dispose ();
+					context.Destination = null;
+					break;
+				case SourceCommand.RollbackWrite:
+					// err do something?
 					break;
 
 				case SourceCommand.Read:
-					if (length > stream.Length - stream.Position) {
-						length = (int)(stream.Length - stream.Position);
-					}
+					length = (int)Math.Min (stream.Length - stream.Position, length);
 					buffer = ArrayPool<byte>.Shared.Rent (length);
 					try {
 						int bytesRead = stream.Read (buffer, 0, length);
@@ -811,8 +868,11 @@ internal static unsafe Int64 stream_callback (IntPtr state, IntPtr data, UInt64
 					} finally {
 						ArrayPool<byte>.Shared.Return (buffer);
 					}
-
 				case SourceCommand.BeginWrite:
+					context.Destination = new MemoryStream ();
+					destination = context.Destination;
+					destination.Position = 0;
+					break;
 				case SourceCommand.Open:
 					stream.Position = 0;
 					return 0;
@@ -826,6 +886,12 @@ internal static unsafe Int64 stream_callback (IntPtr state, IntPtr data, UInt64
 						handle.Free ();
 					break;
 
+				case SourceCommand.Error:
+					break;
+
+				case SourceCommand.Remove:
+					break;
+
 				case SourceCommand.Supports:
 					var supports = (Int64)Native.zip_source_make_command_bitmap (
 						SourceCommand.Open,