Merge PR #225: Fix flushing of GZipOutputStream

* Fix flushing a GZipOutputStream

When flushing a GZipOutputStream, ensure we deflate
all data in the input buffer and write it to the
underlying stream before we flush the underlying stream.

* Fix infinite loop when flushing DeflaterOutputStream with no compression

DeflaterEngine.DeflateStored would always write more output even if
there was no more input data to write, resulting in an infinite loop.

Author: adamreeve

src/ICSharpCode.SharpZipLib/GZip/GzipInputStream.cs

@@ -139,6 +139,9 @@ public override int Read(byte[] buffer, int offset, int count)
 				if (inf.IsFinished)
 				{
 					ReadFooter();
+				} else if (inf.RemainingInput == 0) {
+					// If the stream is not finished but we have no more data to read, don't keep looping forever
+					throw new GZipException("Unexpected EOF");
 				}
 
 				if (bytesRead > 0)

src/ICSharpCode.SharpZipLib/Zip/Compression/DeflaterEngine.cs

@@ -643,7 +643,7 @@ private bool DeflateStored(bool flush, bool finish)
 
 				huffman.FlushStoredBlock(window, blockStart, storedLength, lastBlock);
 				blockStart += storedLength;
-				return !lastBlock;
+				return !(lastBlock || storedLength == 0);
 			}
 			return true;
 		}

src/ICSharpCode.SharpZipLib/Zip/Compression/Streams/DeflaterOutputStream.cs

@@ -241,7 +241,12 @@ protected void InitializeAESPassword(ZipEntry entry, string rawPassword,
 		/// </summary>
 		protected void Deflate()
 		{
-			while (!deflater_.IsNeedingInput)
+			Deflate(false);
+		}
+
+		private void Deflate(bool flushing)
+		{
+			while (flushing || !deflater_.IsNeedingInput)
 			{
 				int deflateCount = deflater_.Deflate(buffer_, 0, buffer_.Length);
 
@@ -380,7 +385,7 @@ public override int Read(byte[] buffer, int offset, int count)
 		public override void Flush()
 		{
 			deflater_.Flush();
-			Deflate();
+			Deflate(true);
 			baseOutputStream_.Flush();
 		}
 

test/ICSharpCode.SharpZipLib.Tests/GZip/GZipTests.cs

@@ -289,6 +289,61 @@ public void TrailingGarbage()
 			}
 		}
 
+		/// <summary>
+		/// Test that if we flush a GZip output stream then all data that has been written
+		/// is flushed through to the underlying stream and can be successfully read back
+		/// even if the stream is not yet finished.
+		/// </summary>
+		[Test]
+		[Category("GZip")]
+		public void FlushToUnderlyingStream()
+		{
+			var ms = new MemoryStream();
+			var outStream = new GZipOutputStream(ms);
+
+			byte[] buf = new byte[100000];
+			var rnd = new Random();
+			rnd.NextBytes(buf);
+
+			outStream.Write(buf, 0, buf.Length);
+			// Flush output stream but don't finish it yet
+			outStream.Flush();
+
+			ms.Seek(0, SeekOrigin.Begin);
+
+			var inStream = new GZipInputStream(ms);
+			byte[] buf2 = new byte[buf.Length];
+			int currentIndex = 0;
+			int count = buf2.Length;
+
+			while (true)
+			{
+				try
+				{
+					int numRead = inStream.Read(buf2, currentIndex, count);
+					if (numRead <= 0)
+					{
+						break;
+					}
+					currentIndex += numRead;
+					count -= numRead;
+				}
+				catch (GZipException)
+				{
+					// We should get an unexpected EOF exception once we've read all
+					// data as the stream isn't yet finished.
+					break;
+				}
+			}
+
+			Assert.AreEqual(0, count);
+
+			for (int i = 0; i < buf.Length; ++i)
+			{
+				Assert.AreEqual(buf2[i], buf[i]);
+			}
+		}
+
 		[Test]
 		[Category("GZip")]
 		[Category("Performance")]