private Stream Decode()
{
Stream stream;
if (Encoding != "base64")
throw new Exception("TmxMapperPCL.Data: Only Base64-encoded data is supported.");
var rawData = Convert.FromBase64String(Value);
var memStream = new MemoryStream(rawData);
if (Compression == "gzip")
stream = new GZipInputStream(memStream);
else if (Compression == "zlib")
stream = new InflaterInputStream(memStream);
else if (Compression != null)
throw new Exception("TmxMapperPCL.Data: Unknown compression.");
else
stream = memStream;
var outputStream = new MemoryStream();
stream.CopyTo(outputStream);
stream = outputStream;
return stream;
}
public void CloseInflatorWithNestedUsing()
{
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
string tempFile = Environment.TickCount.ToString();
store.CreateDirectory(tempFile);
tempFile = Path.Combine(tempFile, "SharpZipTest.Zip");
using (IsolatedStorageFileStream diskFile = store.CreateFile(tempFile))
using (DeflaterOutputStream deflator = new DeflaterOutputStream(diskFile))
using (StreamWriter textWriter = new StreamWriter(deflator))
{
textWriter.Write("Hello");
textWriter.Flush();
}
using (IsolatedStorageFileStream diskFile = store.OpenFile(tempFile, FileMode.Open))
using (InflaterInputStream deflator = new InflaterInputStream(diskFile))
using (StreamReader textReader = new StreamReader(deflator))
{
char[] buffer = new char[5];
int readCount = textReader.Read(buffer, 0, 5);
Assert.AreEqual(5, readCount);
StringBuilder b = new StringBuilder();
b.Append(buffer);
Assert.AreEqual("Hello", b.ToString());
}
store.CreateFile(tempFile);
}
}
public static void Deserialize(Stream stream, PiaFile piaFile)
{
if (stream == null)
throw new ArgumentNullException("Stream");
if (piaFile == null)
throw new ArgumentNullException("PiaFile");
try
{
// Header
var headerBytes = new Byte[48]; // Ignore 12 byte checksum
stream.Read(headerBytes, 0, headerBytes.Length);
var headerString = Encoding.Default.GetString(headerBytes);
piaFile.Header = new PiaHeader(headerString);
// Inflation
string inflatedString;
stream.Seek(60, SeekOrigin.Begin);
using (var zStream = new InflaterInputStream(stream))
{
var sr = new StreamReader(zStream, Encoding.Default);
inflatedString = sr.ReadToEnd();
}
// Nodes
piaFile.Owner = piaFile;
_deserializeNode(piaFile, inflatedString);
}
catch (Exception)
{
throw;
}
}
public void Decompress(Stream source, Stream destination)
{
var inflater = new InflaterInputStream(source, new Inflater(true));
var dataBuffer = new byte[CopyBufferSize];
StreamUtils.Copy(inflater, destination, dataBuffer);
}
/// <summary>
/// Expands (de-compresses) a string.
/// </summary>
/// <param name="value">The string to expanded.</param>
/// <returns>The expanded string.</returns>
public string ExpandString(string value)
{
// The input value must be non-null
if (value == null)
{
throw new ArgumentNullException("value");
}
var outputData = string.Empty;
var inputData = Convert.FromBase64String(value);
using (var inputStream = new MemoryStream(inputData))
{
using (var outputStream = new MemoryStream())
{
// Zip the string
using (var zipStream = new InflaterInputStream(inputStream))
{
zipStream.IsStreamOwner = false;
StreamUtils.Copy(zipStream, outputStream, new byte[4096]);
}
// Convert to a string
outputData = UTF8Encoding.UTF8.GetString(outputStream.GetBuffer(), 0, Convert.ToInt32(outputStream.Length));
}
}
// Return the compressed string
return outputData;
}
public void CloseInflatorWithNestedUsing()
{
string tempFile = null;
try {
tempFile = Path.GetTempPath();
} catch (SecurityException) {
}
Assert.IsNotNull(tempFile, "No permission to execute this test?");
tempFile = Path.Combine(tempFile, "SharpZipTest.Zip");
using (FileStream diskFile = File.Create(tempFile))
using (DeflaterOutputStream deflator = new DeflaterOutputStream(diskFile))
using (StreamWriter textWriter = new StreamWriter(deflator)) {
textWriter.Write("Hello");
textWriter.Flush();
}
using (FileStream diskFile = File.OpenRead(tempFile))
using (InflaterInputStream deflator = new InflaterInputStream(diskFile))
using (StreamReader textReader = new StreamReader(deflator)) {
char[] buffer = new char[5];
int readCount = textReader.Read(buffer, 0, 5);
Assert.AreEqual(5, readCount);
var b = new StringBuilder();
b.Append(buffer);
Assert.AreEqual("Hello", b.ToString());
}
File.Delete(tempFile);
}
internal static byte[] Inflate(byte[] buffer)
{
InflaterInputStream inflaterStream = new InflaterInputStream(new MemoryStream(buffer));
MemoryStream outputStream = new MemoryStream();
inflaterStream.CopyTo(outputStream);
return outputStream.ToArray();
}
/// <summary>
/// Decompresses an array of bytes.
/// </summary>
/// <param name="_pBytes">An array of bytes to be decompressed.</param>
/// <returns>Decompressed bytes</returns>
public static byte[] DeCompress(byte[] _pBytes)
{
InflaterInputStream inputStream = new InflaterInputStream(new MemoryStream(_pBytes));
MemoryStream ms = new MemoryStream();
Int32 mSize;
byte[] mWriteData = new byte[4096];
while (true)
{
mSize = inputStream.Read(mWriteData, 0, mWriteData.Length);
if (mSize > 0)
{
ms.Write(mWriteData, 0, mSize);
}
else
{
break;
}
}
inputStream.Close();
return ms.ToArray();
}
public string Decompress(string compressedString)
{
var uncompressedString = string.Empty;
var totalLength = 0;
var inputAsBytes = Convert.FromBase64String(compressedString);;
var writeData = new byte[4096];
var inputStream = new InflaterInputStream(new MemoryStream(inputAsBytes));
for(;;)
{
var size = inputStream.Read(writeData, 0, writeData.Length);
if (size > 0)
{
totalLength += size;
uncompressedString += Encoding.UTF8.GetString(writeData, 0, size);
}
else
{
break;
}
}
inputStream.Close();
return uncompressedString;
}
public Rectangle GetDimensions(Stream stream)
{
Stream inputStream = null;
byte[] signature = new byte[8];
byte[] rect = new byte[8];
stream.Read(signature, 0, 8);
if ("CWS" == System.Text.Encoding.ASCII.GetString(signature, 0, 3))
{
inputStream = new InflaterInputStream(stream);
}
else
{
inputStream = stream;
}
inputStream.Read(rect, 0, 8);
int nbits = rect[0] >> 3;
rect[0] = (byte)(rect[0] & 0x07);
String bits = ByteArrayToBitString(rect);
bits = bits.Remove(0, 5);
int[] dims = new int[4];
for (int i = 0; i < 4; i++)
{
char[] dest = new char[nbits];
bits.CopyTo(0, dest, 0, bits.Length > nbits ? nbits : bits.Length);
bits = bits.Remove(0, bits.Length > nbits ? nbits : bits.Length);
dims[i] = BitStringToInteger(new String(dest)) / 20;
}
return new Rectangle(0, 0, dims[1] - dims[0], dims[3] - dims[2]);
}
public static byte[] DecompressGzipBytes(byte[] Bytes)
{
ICSharpCode.SharpZipLib.Zip.Compression.Streams.InflaterInputStream stream =
new ICSharpCode.SharpZipLib.Zip.Compression.Streams.InflaterInputStream(new MemoryStream(Bytes));
MemoryStream memory = new MemoryStream();
byte[] writeData = new byte[4096];
int size;
while (true)
{
size = stream.Read(writeData, 0, writeData.Length);
if (size > 0)
{
memory.Write(writeData, 0, size);
}
else
{
break;
}
}
stream.Close();
return(memory.ToArray());
}
public void TestInflateDeflate()
{
MemoryStream ms = new MemoryStream();
Deflater deflater = new Deflater(6);
DeflaterOutputStream outStream = new DeflaterOutputStream(ms, deflater);
byte[] buf = new byte[1000000];
System.Random rnd = new Random();
rnd.NextBytes(buf);
outStream.Write(buf, 0, buf.Length);
outStream.Flush();
outStream.Finish();
ms.Seek(0, SeekOrigin.Begin);
InflaterInputStream inStream = new InflaterInputStream(ms);
byte[] buf2 = new byte[buf.Length];
int pos = 0;
while (true) {
int numRead = inStream.Read(buf2, pos, 4096);
if (numRead <= 0) {
break;
}
pos += numRead;
}
for (int i = 0; i < buf.Length; ++i) {
Assertion.AssertEquals(buf2[i], buf[i]);
}
}
void Inflate(MemoryStream ms, byte[] original, int level, bool zlib)
{
ms.Seek(0, SeekOrigin.Begin);
Inflater inflater = new Inflater(!zlib);
InflaterInputStream inStream = new InflaterInputStream(ms, inflater);
byte[] buf2 = new byte[original.Length];
int currentIndex = 0;
int count = buf2.Length;
try
{
while (true)
{
int numRead = inStream.Read(buf2, currentIndex, count);
if (numRead <= 0)
{
break;
}
currentIndex += numRead;
count -= numRead;
}
}
catch(Exception ex)
{
Console.WriteLine("Unexpected exception - '{0}'", ex.Message);
throw;
}
if ( currentIndex != original.Length )
{
Console.WriteLine("Original {0}, new {1}", original.Length, currentIndex);
Assert.Fail("Lengths different");
}
for (int i = 0; i < original.Length; ++i)
{
if ( buf2[i] != original[i] )
{
string description = string.Format("Difference at {0} level {1} zlib {2} ", i, level, zlib);
if ( original.Length < 2048 )
{
StringBuilder builder = new StringBuilder(description);
for (int d = 0; d < original.Length; ++d)
{
builder.AppendFormat("{0} ", original[d]);
}
Assert.Fail(builder.ToString());
}
else
{
Assert.Fail(description);
}
}
}
}
public static byte[] Decompress(byte[] data, int final_size)
{
byte[] r = null;
using (Stream s = new InflaterInputStream(new MemoryStream(data)))
s.Read(r, 0, final_size);
return r;
}
public void Decompress(ArraySegment<byte> input, ArraySegment<byte> output)
{
using (var gz = new InflaterInputStream(new MemoryStream(input.Array, input.Offset, input.Count)))
{
int read = gz.Read(output.Array, output.Offset, output.Count);
if (read != output.Count)
throw new Exception("Short read!");
}
}
public static byte[] UncompressStream(Stream stream, int filesize, int memsize)
{
BinaryReader r = new BinaryReader(stream);
long end = stream.Position + filesize;
byte[] header = r.ReadBytes(2);
if (checking) if (header.Length != 2)
throw new InvalidDataException("Hit unexpected end of file at " + stream.Position);
bool useDEFLATE = true;
byte[] uncompressedData = null;
if (header[0] == 0x78)
{
useDEFLATE = true;
}
else if (header[1] == 0xFB)
{
useDEFLATE = false;
}
else
{
throw new InvalidDataException("Unrecognized compression format");
}
if (useDEFLATE)
{
byte[] data = new byte[filesize];
stream.Position -= 2; // go back to header
stream.Read(data, 0, filesize);
using (MemoryStream source = new MemoryStream(data))
{
using (InflaterInputStream decomp = new InflaterInputStream(source))
{
uncompressedData = new byte[memsize];
decomp.Read(uncompressedData, 0, memsize);
}
}
}
else
{
uncompressedData = OldDecompress(stream, header[0]);
}
long realsize = uncompressedData.Length;
if (checking) if (realsize != memsize)
throw new InvalidDataException(String.Format(
"Resource data indicates size does not match index at 0x{0}. Read 0x{1}. Expected 0x{2}.",
stream.Position.ToString("X8"), realsize.ToString("X8"), memsize.ToString("X8")));
return uncompressedData;
}
/// <summary>
/// ��ѹ�ֽ�������
/// </summary>
/// <param name="val">��������ֽ�������</param>
/// <returns>���ؽ�ѹ�������</returns>
public byte[] Decompress(byte[] val)
{
if (val[0] == 1) {
Inflater inflater = new Inflater(true);
using (InflaterInputStream decompressStream = new InflaterInputStream(new MemoryStream(UnwrapData(val)), inflater)) {
return ArrayHelper.ReadAllBytesFromStream(decompressStream);
}
}
else
return UnwrapData(val);
}
public static Stream Decompress(byte[] data)
{
var outputStream = new MemoryStream();
using (var compressedStream = new MemoryStream(data))
using (var inputStream = new ICSharpCode.SharpZipLib.Zip.Compression.Streams.InflaterInputStream(compressedStream))
{
inputStream.CopyTo(outputStream);
outputStream.Position = 0;
return(outputStream);
}
}
public static byte[] Decompress(byte[] data)
{
byte[] r = null;
using (Stream s = new InflaterInputStream(new MemoryStream(data)))
{
byte[] b = new byte[8192];
int count = s.Read(b, 0, b.Length);
r = b.Take(count).ToArray();
}
return r;
}
public byte[] Decode(byte[] input, int decompressedSize)
{
InflaterInputStream stream = new InflaterInputStream(new MemoryStream(input));
byte[] data = new byte[4096];
MemoryStream outStream = new MemoryStream();
int size;
while ((size = stream.Read(data, 0, data.Length)) > 0)
{
outStream.Write(data, 0, size);
}
outStream.Capacity = (int)outStream.Length;
return outStream.GetBuffer();
}
// Length = decompressed length
public static byte[] Decompress(int Length, byte[] Data)
{
byte[] Output = new byte[Length];
Stream s = new InflaterInputStream(new MemoryStream(Data));
int Offset = 0;
while(true)
{
int size = s.Read(Output, Offset, Length);
if (size == Length) break;
Offset += size;
Length -= size;
}
return Output;
}
public static byte[] DecompressZlib(byte[] input)
{
MemoryStream source = new MemoryStream(input);
byte[] result = null;
using (MemoryStream outStream = new MemoryStream())
{
using (InflaterInputStream inf = new InflaterInputStream(source))
{
inf.CopyTo(outStream);
}
result = outStream.ToArray();
}
return result;
}
public static int Uncompress(ref byte[] Data)
{
int maxsize = Data.Length * 10 + 300;
if (maxsize > 50000) maxsize = 50000;
byte[] outputData = new byte[maxsize];
MemoryStream dataStream = new MemoryStream(Data);
InflaterInputStream inflater = new InflaterInputStream(dataStream);
//int res=descompresor.Read(packetsalida,0,packetsalida.Length);
//if (res>0)
int res;
int resTotal = 0;
MemoryStream uncompressedStream = new MemoryStream();
do
{
if (inflater.Position == Data.Length) res = 0;
else
try
{
res = inflater.Read(outputData, 0, outputData.Length);
}
catch
{
res = 0;
}
if (res > 0)
{
uncompressedStream.Write(outputData, 0, res);
}
resTotal += res;
}
while (res > 0);
if (resTotal == 0)
{
return 0;
}
else
{
inflater.Close();
inflater = null;
dataStream.Close();
dataStream = null;
Data = null;
Data = new byte[resTotal];
uncompressedStream.Seek(0, SeekOrigin.Begin);
uncompressedStream.Read(Data, 0, resTotal);
uncompressedStream.Close();
uncompressedStream = null;
return resTotal;
}
}
public static byte[] Decompress(string data)
{
byte[] array = null;
if (data.StartsWith("ZipStream:"))
{
MemoryStream memoryStream = new MemoryStream(Convert.FromBase64String(data.Substring(10)));
InflaterInputStream inflaterInputStream = new InflaterInputStream(memoryStream);
BinaryReader binaryReader = new BinaryReader(memoryStream);
int num = binaryReader.ReadInt32();
array = new byte[num];
inflaterInputStream.Read(array, 0, num);
inflaterInputStream.Close();
memoryStream.Close();
}
return array;
}
public static byte[] Decompress(string data)
{
byte[] output = null;
if(data.StartsWith("ZipStream:"))
{
var m = new MemoryStream(Convert.FromBase64String(data.Substring(10)));
var z = new InflaterInputStream(m);
var br = new BinaryReader(m);
var length = br.ReadInt32();
output = new byte[length];
z.Read(output, 0, length);
z.Close();
m.Close();
}
return output;
}
public static void Main(string[] args)
{
var delimiter = new string('-', 10);
var url = "https://google.com";
Console.WriteLine("{0} sending request to {1} {0}", delimiter, url);
var request = WebRequest.Create(url) as HttpWebRequest;
request.Method = "GET";
request.ContentType = "application/xml; charset=\"utf-8\"";
request.UserAgent = "sandbox-compression";
request.Headers.Add("accept-encoding", "gzip, deflate");
using (var response = request.GetResponse() as HttpWebResponse)
{
var stream = response.GetResponseStream();
Console.WriteLine("{0} HEADERS {0}", delimiter);
Console.WriteLine(response.Headers.ToString().Trim());
string encoding = "NO";
Stream decompressionStream = null;
if (response.ContentEncoding.IndexOf("gzip", StringComparison.InvariantCultureIgnoreCase) >=
0)
{
decompressionStream = new GZipInputStream(stream);
encoding = "GZIP";
}
else if (response.ContentEncoding.IndexOf("deflate", StringComparison.InvariantCultureIgnoreCase) >= 0)
{
decompressionStream = new InflaterInputStream(stream);
encoding = "DEFLATE";
}
Console.WriteLine("{0} {1} {0}", delimiter, encoding);
var reader = new StreamReader(decompressionStream ?? stream);
Console.WriteLine("{0} First 20 chars of response body {0}", delimiter);
Console.WriteLine(reader.ReadToEnd().Substring(0, 20));
}
Console.ReadKey();
}
public static void Decompress(ref GenericReader gr)
{
int uncompressedLength = gr.ReadInt32();
byte[] output = new byte[gr.ReadInt32()];
byte[] temp = gr.ReadBytes((int)gr.Remaining);
gr.Close();
Stream s = new InflaterInputStream(new MemoryStream(temp));
int offset = 0;
while (true)
{
int size = s.Read(output, offset, uncompressedLength);
if (size == uncompressedLength) break;
offset += size;
uncompressedLength -= size;
}
gr = new GenericReader(new MemoryStream(output));
//gr.BaseStream.Position = 0;
}
public static GenericReader Decompress(GenericReader gr)
{
int uncompressedLength = gr.ReadInt32();
byte[] input = gr.ReadBytes((int)gr.Remaining);
byte[] output = new byte[uncompressedLength];
gr.Close();
InflaterInputStream istream = new InflaterInputStream(new MemoryStream(input));
int offset = 0;
while (true)
{
int size = istream.Read(output, offset, uncompressedLength);
if (size == uncompressedLength)
break;
offset += size;
uncompressedLength -= size;
}
return new GenericReader(new MemoryStream(output));
}
public string Inflate(byte[] gzBuffer)
{
using (var ms = new MemoryStream())
{
var msgLength = BitConverter.ToInt32(gzBuffer, 0);
ms.Write(gzBuffer, 4, gzBuffer.Length - 4);
var buffer = new byte[msgLength];
ms.Position = 0;
using (var zipStream = new InflaterInputStream(ms, new Inflater()))
{
zipStream.Read(buffer, 0, buffer.Length);
}
return Encoding.UTF8.GetString(buffer);
}
}
public byte[] Decompress( byte[] bytes )
{
Stream stream = new InflaterInputStream( new MemoryStream( bytes ) );
MemoryStream memory = new MemoryStream();
int totalLength = 0;
byte[] writeData = new byte[4096];
while ( true )
{
int size = stream.Read( writeData, 0, writeData.Length );
if ( size > 0 )
{
totalLength += size;
memory.Write( writeData, 0, size );
}
else
break;
}
stream.Close();
return memory.ToArray();
}
public static byte[] Decompress(byte[] bytes)
{
InflaterInputStream stream = new InflaterInputStream(new MemoryStream(bytes));
MemoryStream memory = new MemoryStream();
Byte[] writeData = new byte[4096];
int size;
while (true)
{
size = stream.Read(writeData, 0, writeData.Length);
if (size > 0)
{
memory.Write(writeData, 0, size);
}
else
{
break;
}
}
stream.Close();
return memory.ToArray();
}
public static bool Verify(string licenseString)
{
if (string.IsNullOrEmpty(licenseString) || !CanDecode(licenseString))
return false;
byte[] licenseData = Convert.FromBase64String(GetLicenceContent(licenseString));
Console.WriteLine(Encoding.GetEncoding("UTF-32BE").GetString(licenseData.Take(4).ToArray()));
var length = (((licenseData[0] & 0xff) << 24) | ((licenseData[1] & 0xff) << 16) | ((licenseData[2] & 0xff) << 8) | (licenseData[3] & 0xff));
var license = licenseData.Skip(4).Take(length).ToArray();
var sign = licenseData.Skip(length + 4).ToArray();
byte[] unzipedData;
using (MemoryStream inStream = new MemoryStream(license.Skip(5).ToArray()))
using (InflaterInputStream zip = new InflaterInputStream(inStream))
using (MemoryStream outStream = new MemoryStream())
{
zip.CopyTo(outStream);
unzipedData = outStream.ToArray();
}
Console.WriteLine(Encoding.ASCII.GetString(unzipedData));
return VerifyDsaMessage(Convert.FromBase64String(PublicKey), license, ConvertToP1363Signature(sign));
}
