Files
mono/mcs/class/System/System.IO.Compression/DeflateStream.cs
T
Gert Driesen 6b10903f70 * DeflateStreamTest.cs: Improved CanRead, CanSeek and CanWrite tests.
Added test for bug #327480. Code formatting.
* GzipStreamTest.cs: Improved CanRead, CanSeek and CanWrite tests.
Code formatting.
* DeflateStream.cs: Avoid double free. Fixes bug #327480.

svn path=/trunk/mcs/; revision=86218
2007-09-22 16:50:02 +00:00

440 lines
12 KiB
C#

/* -*- Mode: csharp; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
//
// DeflateStream.cs
//
// Authors:
// Christopher James Lahey <[email protected]>
//
// (c) 2004 Novell, Inc. <http://www.novell.com>
//
#if NET_2_0
using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.Remoting.Messaging;
namespace System.IO.Compression {
public class DeflateStream : Stream
{
private Stream compressedStream;
private CompressionMode mode;
private bool leaveOpen;
private bool open;
private IntPtr z_stream;
private const int BUFFER_SIZE = 4096;
private IntPtr sized_buffer;
static int bytes_read = 0;
private bool finished = false;
private enum ZReturnConsts {
Z_OK = 0,
Z_STREAM_END = 1,
Z_NEED_DICT = 2,
Z_STREAM_ERROR = -2,
Z_DATA_ERROR = -3,
Z_MEM_ERROR = -4,
Z_BUF_ERROR = -5,
}
private enum ZFlushConsts {
Z_NO_FLUSH = 0,
Z_PARTIAL_FLUSH = 1, /* will be removed, use Z_SYNC_FLUSH instead */
Z_SYNC_FLUSH = 2,
Z_FULL_FLUSH = 3,
Z_FINISH = 4,
Z_BLOCK = 5,
};
[DllImport("MonoPosixHelper")]
static extern IntPtr create_z_stream(CompressionMode compress, bool gzip);
[DllImport("MonoPosixHelper")]
static extern void free_z_stream(IntPtr z_stream, CompressionMode compress );
[DllImport("MonoPosixHelper")]
static extern void z_stream_set_next_in(IntPtr z_stream, IntPtr next_in);
[DllImport("MonoPosixHelper")]
static extern void z_stream_set_avail_in(IntPtr z_stream, int avail_in);
[DllImport("MonoPosixHelper")]
static extern int z_stream_get_avail_in(IntPtr z_stream);
[DllImport("MonoPosixHelper")]
static extern void z_stream_set_next_out(IntPtr z_stream, IntPtr next_out);
//[DllImport("MonoPosixHelper")]
//static extern void z_stream_set_avail_out(IntPtr z_stream, int avail_out);
[DllImport("MonoPosixHelper")]
static extern ZReturnConsts z_stream_inflate(IntPtr z_stream, ref int avail_out);
[DllImport("MonoPosixHelper")]
static extern ZReturnConsts z_stream_deflate(IntPtr z_stream, ZFlushConsts flush, IntPtr next_out, ref int avail_out);
delegate int ReadMethod (byte[] array, int offset, int count);
delegate void WriteMethod(byte[] array, int offset, int count);
internal DeflateStream (Stream compressedStream, CompressionMode mode, bool leaveOpen, bool gzip)
{
if (compressedStream == null)
throw new ArgumentNullException ("compressedStream");
switch (mode) {
case CompressionMode.Compress:
case CompressionMode.Decompress:
break;
default:
throw new ArgumentException ("mode");
}
this.compressedStream = compressedStream;
this.mode = mode;
this.leaveOpen = leaveOpen;
this.sized_buffer = Marshal.AllocHGlobal (BUFFER_SIZE);
this.z_stream = create_z_stream (mode, gzip);
if (z_stream == IntPtr.Zero) {
throw new NotImplementedException ("Failed to initialize zlib. You probably have an old zlib installed. Version 1.2.0.4 or later is required.");
}
this.open = true;
if (mode == CompressionMode.Compress) {
Flush();
}
}
public DeflateStream (Stream compressedStream, CompressionMode mode) :
this (compressedStream, mode, false, false) { }
public DeflateStream (Stream compressedStream, CompressionMode mode, bool leaveOpen) :
this (compressedStream, mode, leaveOpen, false) { }
protected override void Dispose (bool disposing)
{
if (!open) {
base.Dispose (disposing);
return;
}
try {
FlushInternal (true);
base.Dispose (disposing);
} finally {
try {
DisposeCore ();
} finally {
if (disposing)
Marshal.FreeHGlobal (sized_buffer);
}
}
}
void DisposeCore ()
{
if (/*mode == CompressionMode.Decompress &&*/ compressedStream.CanSeek) {
int avail_in = z_stream_get_avail_in (z_stream);
if (avail_in != 0) {
compressedStream.Seek (- avail_in, SeekOrigin.Current);
z_stream_set_avail_in (z_stream, 0);
}
}
free_z_stream (z_stream,mode);
z_stream = IntPtr.Zero;
if (!leaveOpen) {
compressedStream.Close();
}
open = false;
}
private int ReadInternal(byte[] array, int offset, int count) {
int buffer_size;
if (finished)
return 0;
if (compressedStream.CanSeek)
buffer_size = BUFFER_SIZE;
else
buffer_size = 1;
IntPtr buffer = Marshal.AllocHGlobal(count);
try {
int avail_out;
avail_out = count;
z_stream_set_next_out (z_stream, buffer);
while (avail_out != 0 && !finished) {
if (z_stream_get_avail_in (z_stream) == 0) {
byte[] read_buf = new byte[buffer_size];
int length_read = compressedStream.Read (read_buf, 0, buffer_size);
bytes_read += length_read;
if (length_read == 0) {
break;
}
Marshal.Copy (read_buf, 0, sized_buffer, length_read);
z_stream_set_next_in (z_stream, sized_buffer);
z_stream_set_avail_in (z_stream, length_read);
}
ZReturnConsts ret_val = z_stream_inflate(z_stream, ref avail_out);
switch (ret_val) {
case ZReturnConsts.Z_OK:
break;
case ZReturnConsts.Z_STREAM_END:
finished = true;
break;
case ZReturnConsts.Z_NEED_DICT:
throw new InvalidDataException ("ZLib stream requires a dictionary.");
case ZReturnConsts.Z_DATA_ERROR:
throw new InvalidDataException ("Invalid ZLib data.");
case ZReturnConsts.Z_STREAM_ERROR:
throw new InvalidOperationException ("Internal DeflateStream error.");
case ZReturnConsts.Z_MEM_ERROR:
throw new OutOfMemoryException ();
case ZReturnConsts.Z_BUF_ERROR:
throw new InvalidOperationException ("Internal DeflateStream error: Buf error.");
}
}
if (count != avail_out)
Marshal.Copy (buffer, array, offset, count - avail_out);
return count - avail_out;
} finally {
Marshal.FreeHGlobal(buffer);
}
}
public override int Read (byte[] dest, int dest_offset, int count)
{
if (!open)
throw new ObjectDisposedException ("DeflateStream");
if (dest == null)
throw new ArgumentNullException ("Destination array is null.");
if (!CanRead)
throw new InvalidOperationException ("Stream does not support reading.");
int len = dest.Length;
if (dest_offset < 0 || count < 0)
throw new ArgumentException ("Dest or count is negative.");
if (dest_offset > len)
throw new ArgumentException ("destination offset is beyond array size");
if ((dest_offset + count) > len)
throw new ArgumentException ("Reading would overrun buffer");
return ReadInternal (dest, dest_offset, count);
}
private ZReturnConsts do_deflate (ZFlushConsts flush, out int avail_out) {
avail_out = BUFFER_SIZE;
ZReturnConsts ret_val = z_stream_deflate (z_stream, flush, sized_buffer, ref avail_out);
switch (ret_val) {
case ZReturnConsts.Z_STREAM_ERROR:
throw new InvalidOperationException ("Internal error.");
case ZReturnConsts.Z_MEM_ERROR:
throw new InvalidOperationException ("Memory error.");
}
return ret_val;
}
private void WriteInternal(byte[] array, int offset, int count) {
IntPtr buffer = Marshal.AllocHGlobal(count);
try {
int avail_in;
avail_in = count;
Marshal.Copy (array, offset, buffer, count);
z_stream_set_next_in (z_stream, buffer);
z_stream_set_avail_in (z_stream, avail_in);
while (avail_in != 0) {
int avail_out;
do_deflate (ZFlushConsts.Z_NO_FLUSH, out avail_out);
if (avail_out != BUFFER_SIZE) {
byte[] output = new byte[BUFFER_SIZE - avail_out];
Marshal.Copy (sized_buffer, output, 0, BUFFER_SIZE - avail_out);
compressedStream.Write(output, 0, BUFFER_SIZE - avail_out);
}
avail_in = z_stream_get_avail_in (z_stream);
}
} finally {
Marshal.FreeHGlobal(buffer);
}
}
public override void Write (byte[] src, int src_offset, int count)
{
if (!open)
throw new ObjectDisposedException ("DeflateStream");
if (src == null)
throw new ArgumentNullException ("src");
if (src_offset < 0)
throw new ArgumentOutOfRangeException ("src_offset");
if (count < 0)
throw new ArgumentOutOfRangeException ("count");
if (!CanWrite)
throw new NotSupportedException ("Stream does not support writing");
WriteInternal (src, src_offset, count);
}
private void FlushInternal (bool finish)
{
if (!open)
throw new ObjectDisposedException ("DeflateStream");
int avail_out;
ZReturnConsts ret_val;
if (!(open && mode == CompressionMode.Compress && compressedStream.CanWrite))
return;
z_stream_set_next_in (z_stream, IntPtr.Zero);
z_stream_set_avail_in (z_stream, 0);
while (true) {
ret_val = do_deflate (finish ? ZFlushConsts.Z_FINISH : ZFlushConsts.Z_SYNC_FLUSH, out avail_out);
if (BUFFER_SIZE != avail_out) {
byte[] output = new byte[BUFFER_SIZE - avail_out];
Marshal.Copy (sized_buffer, output, 0, BUFFER_SIZE - avail_out);
compressedStream.Write(output, 0, BUFFER_SIZE - avail_out);
} else {
if (!finish)
break;
}
if (ret_val == ZReturnConsts.Z_STREAM_END)
break;
}
compressedStream.Flush();
}
public override void Flush () {
FlushInternal (false);
}
public override long Seek (long offset, SeekOrigin origin) {
throw new System.NotSupportedException();
}
public override void SetLength (long value) {
throw new System.NotSupportedException();
}
public override IAsyncResult BeginRead (byte [] buffer, int offset, int count,
AsyncCallback cback, object state)
{
if (!open)
throw new ObjectDisposedException ("DeflateStream");
if (!CanRead)
throw new NotSupportedException ("This stream does not support reading");
if (buffer == null)
throw new ArgumentNullException ("buffer");
if (count < 0)
throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
if (count + offset > buffer.Length)
throw new ArgumentException ("Buffer too small. count/offset wrong.");
ReadMethod r = new ReadMethod (ReadInternal);
return r.BeginInvoke (buffer, offset, count, cback, state);
}
public override IAsyncResult BeginWrite (byte [] buffer, int offset, int count,
AsyncCallback cback, object state)
{
if (!open)
throw new ObjectDisposedException ("DeflateStream");
if (!CanWrite)
throw new InvalidOperationException ("This stream does not support writing");
if (buffer == null)
throw new ArgumentNullException ("buffer");
if (count < 0)
throw new ArgumentOutOfRangeException ("count", "Must be >= 0");
if (offset < 0)
throw new ArgumentOutOfRangeException ("offset", "Must be >= 0");
if (count + offset > buffer.Length)
throw new ArgumentException ("Buffer too small. count/offset wrong.");
WriteMethod w = new WriteMethod (WriteInternal);
return w.BeginInvoke (buffer, offset, count, cback, state);
}
public override int EndRead(IAsyncResult async_result) {
if (async_result == null)
throw new ArgumentNullException ("async_result");
AsyncResult ares = async_result as AsyncResult;
if (ares == null)
throw new ArgumentException ("Invalid IAsyncResult", "async_result");
ReadMethod r = ares.AsyncDelegate as ReadMethod;
if (r == null)
throw new ArgumentException ("Invalid IAsyncResult", "async_result");
return r.EndInvoke (async_result);
}
public override void EndWrite (IAsyncResult async_result)
{
if (async_result == null)
throw new ArgumentNullException ("async_result");
AsyncResult ares = async_result as AsyncResult;
if (ares == null)
throw new ArgumentException ("Invalid IAsyncResult", "async_result");
WriteMethod w = ares.AsyncDelegate as WriteMethod;
if (w == null)
throw new ArgumentException ("Invalid IAsyncResult", "async_result");
w.EndInvoke (async_result);
return;
}
public Stream BaseStream {
get {
return compressedStream;
}
}
public override bool CanRead {
get {
return open && mode == CompressionMode.Decompress && compressedStream.CanRead;
}
}
public override bool CanSeek {
get {
return false;
}
}
public override bool CanWrite {
get {
return open && mode == CompressionMode.Compress && compressedStream.CanWrite;
}
}
public override long Length {
get {
throw new System.NotSupportedException();
}
}
public override long Position {
get {
throw new System.NotSupportedException();
}
set {
throw new System.NotSupportedException();
}
}
}
}
#endif