internal void BeginDecompress(CompressionAlgorithm algorithm)
{
if (algorithm != CompressionAlgorithm.None)
{
if (_compressionDecoder != null && _compressionDecoder.Algorithm != algorithm)
{
_compressionDecoder?.Dispose();
_compressionDecoder = null;
}
else
{
_compressionDecoder?.Reset();
}
}
switch (algorithm)
{
case CompressionAlgorithm.None:
_currentCompression = algorithm;
return;
case CompressionAlgorithm.Lz4:
if (_compressionDecoder == null)
{
_compressionDecoder = new Lz4CompressionDecoder(_bufferSize);
}
_currentCompression = algorithm;
break;
default:
throw new ArgumentOutOfRangeException(nameof(algorithm), algorithm, null);
}
}
public void CheckCompressDecompress(CompressionAlgorithm algorithm)
{
if (!TestRuntime.CheckXcodeVersion(7, 0))
{
Assert.Ignore("Requires iOS 9.0+ or macOS 10.11+");
}
byte [] data = new byte[100000];
for (int i = 0; i < 100000; i++)
{
data[i] = (byte)i;
}
MemoryStream dataStream = new MemoryStream(data);
MemoryStream backing = new MemoryStream();
DeflateStream compressing = new DeflateStream(backing, CompressionMode.Compress, algorithm, true);
CopyStream(dataStream, compressing);
dataStream.Close();
compressing.Close();
backing.Seek(0, SeekOrigin.Begin);
DeflateStream decompressing = new DeflateStream(backing, CompressionMode.Decompress, algorithm);
MemoryStream output = new MemoryStream();
CopyStream(decompressing, output);
Assert.AreNotEqual(0, output.Length, "Length should be more than 0.");
Assert.IsTrue(compare_buffers(data, output.GetBuffer(), (int)output.Length), "Buffers are not equal.");
decompressing.Close();
output.Close();
}
public void JunkAtTheEnd(CompressionAlgorithm algorithm)
{
if (!TestRuntime.CheckXcodeVersion(7, 0))
{
Assert.Ignore("Requires iOS 9.0+ or macOS 10.11+");
}
// Write a deflated stream, then some additional data...
using (MemoryStream ms = new MemoryStream())
{
// The compressed stream
using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Compress, algorithm, true))
{
stream.WriteByte(1);
stream.Flush();
}
// Junk
ms.WriteByte(2);
ms.Position = 0;
// Reading: this should not hang
using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Decompress, algorithm))
{
byte[] buffer = new byte[512];
int len = stream.Read(buffer, 0, buffer.Length);
Console.WriteLine(len == 1);
}
}
}
private void AddCompressionCapabilities(DetectionInfo info)
{
var excludedCompressionAlogrithms = new CompressionAlgorithm[]
{
CompressionAlgorithm.NONE,
CompressionAlgorithm.Unsupported,
};
var possibleCompressionAlogrithms = Enum.GetValues(typeof(CompressionAlgorithm)).Cast <CompressionAlgorithm>().Except(excludedCompressionAlogrithms);
foreach (var compressionAlgorithm in possibleCompressionAlogrithms)
{
if (info.smb2Info.SupportedCompressionAlgorithms.Contains(compressionAlgorithm))
{
AddResultItem(ref this.compressionItems, compressionAlgorithm.ToString(), DetectResult.Supported);
}
else
{
AddResultItem(ref this.compressionItems, compressionAlgorithm.ToString(), DetectResult.UnSupported);
}
}
var chainedCompressionResult = info.smb2Info.IsChainedCompressionSupported ? DetectResult.Supported : DetectResult.UnSupported;
AddResultItem(ref this.compressionItems, "Chained compression", chainedCompressionResult);
}
public void Uncompress(CompressionAlgorithm algorithm)
{
Position = 0;
var ms = new MemoryStream();
var buffer = new byte[1024];
// The zlib format is specified by RFC 1950. Zlib also uses deflate, plus 2 or 6 header bytes, and a 4 byte checksum at the end.
// The first 2 bytes indicate the compression method and flags. If the dictionary flag is set, then 4 additional bytes will follow.
// Preset dictionaries aren't very common and we don't support them
var deflateStream = algorithm == CompressionAlgorithm.Zlib
? new ZlibStream(memoryStream, CompressionMode.Decompress, false)
: new DeflateStream(memoryStream, CompressionMode.Decompress, false);
while (true)
{
var readCount = deflateStream.Read(buffer, 0, buffer.Length);
if (readCount == 0)
{
break;
}
ms.Write(buffer, 0, readCount);
}
memoryStream.Dispose();
memoryStream = ms;
memoryStream.Position = 0;
dataOutput = new DataOutput(new AmfWriter(memoryStream, serializationContext));
dataInput = new DataInput(new AmfReader(memoryStream, serializationContext));
}
private void BasicSMB2Compression(CompressionAlgorithm compressionAlgorithm)
{
CheckCompressionAndEncryptionApplicability(compressionAlgorithm);
var compressionAlgorithms = new CompressionAlgorithm[] { compressionAlgorithm };
SMB2CompressionTest(compressionAlgorithms, false, CompressionTestVariant.BasicReadWrite);
}
public void BeginCompress(CompressionAlgorithm algorithm, int compressionBlockSize)
{
if (_compressionEncoder != null)
{
if (_compressionEncoder.Algorithm != algorithm)
{
_compressionEncoder.Dispose();
_compressionEncoder = null;
}
else
{
_currentCompression = _compressionEncoder.Algorithm;
_compressionEncoder.Reset();
return;
}
}
switch (algorithm)
{
case CompressionAlgorithm.None:
break;
case CompressionAlgorithm.Lz4:
_currentCompression = algorithm;
_compressionEncoder = new Lz4CompressionEncoder(_bufferSize, compressionBlockSize);
break;
default:
throw new NotSupportedException($"Compression algorithm \"{algorithm}\" is not supported.");
}
}
public static Byte[] Compress(this Byte[] data, CompressionAlgorithm algorithm)
{
//--- Define Location To Store Compressed Data ---//
MemoryStream MS = new MemoryStream();
//--- Create Compression Object ---//
Stream zipper;
if (algorithm == CompressionAlgorithm.GZipStream)
zipper = new GZipStream(MS, CompressionMode.Compress);
else
zipper = new DeflateStream(MS, CompressionMode.Compress);
//--- Compress ---//
zipper.Write(data, 0, data.Length);
zipper.Flush();
zipper.Close();
zipper.Dispose();
//--- Get Compressed Data ---//
Byte[] compressedData = MS.ToArray();
MS.Close();
MS.Dispose();
//--- Return Compressed Data ---//
return compressedData;
}
public virtual void CompressionAlgorithm_InputStreamThenOuputStreamProducesEquivalentData(Stream testData)
{
var originalDataStream = new MemoryStream();
testData.CopyTo(originalDataStream);
originalDataStream.Position = 0;
CompressionAlgorithm algorithm = GetAlgorithm();
CompressionOptions options = GenerateCompressionOptions(algorithm.CompressionType);
var compressedMemoryStream = new MemoryStream();
using (Stream compressorStream = algorithm.CreateCompressor(options).CreateOutputStream(compressedMemoryStream, true, 4096))
{
originalDataStream.CopyTo(compressorStream);
}
var decompressedData = new MemoryStream();
compressedMemoryStream.Position = 0;
using (Stream decopmressorStream = algorithm.CreateDecompressor().CreateInputStream(compressedMemoryStream, true))
{
decopmressorStream.CopyTo(decompressedData);
}
Assert.AreEqual(originalDataStream.Length, decompressedData.Length);
CollectionAssert.AreEqual(originalDataStream.ToArray(), decompressedData.ToArray());
}
public virtual byte[] Decompress(byte[] compressedData, CompressionAlgorithm algorithm)
{
using (MemoryStream ms = new MemoryStream(compressedData))
{
if (algorithm == CompressionAlgorithm.GZip)
{
using (GZipStream stream2 = new GZipStream(ms, CompressionMode.Decompress))
{
return(LoadToBuffer(stream2));
}
}
else if (this.Algorithm == CompressionAlgorithm.Deflate)
{
using (DeflateStream stream3 = new DeflateStream(ms, CompressionMode.Decompress))
{
return(LoadToBuffer(stream3));
}
}
else
{
using (var bzipStream = new BZip2InputStream(ms))
{
return(LoadToBuffer(bzipStream));
//这里要指明要读入的格式，要不就有乱码
//StreamReader reader = new StreamReader(bzipStream, Encoding.UTF8);
//reader.
//var commonString = reader.ReadToEnd();
//return commonString;
}
}
}
}
private int CompressBlock(ref byte[] input, int startPos, int blockSize, out CompressionAlgorithm compressionAlgorithm)
{
if (ZstdLevel < 1)
{
compressionAlgorithm = CompressionAlgorithm.None;
return(blockSize);
}
// compress
using (var memoryStream = new MemoryStream())
using (var compressionStream = new ZstandardStream(memoryStream, CompressionMode.Compress))
{
compressionStream.CompressionLevel = ZstdLevel;
compressionStream.Write(input, startPos, blockSize);
compressionStream.Close();
var tmp = memoryStream.ToArray();
if (tmp.Length < blockSize)
{
compressionAlgorithm = CompressionAlgorithm.Zstandard;
Array.Copy(tmp, 0, input, startPos, tmp.Length);
return(tmp.Length);
}
compressionAlgorithm = CompressionAlgorithm.None;
return(blockSize);
}
}
private void BasicSMB2Compression_Encrypted(CompressionAlgorithm compressionAlgorithm)
{
CheckCompressionAndEncryptionApplicability(compressionAlgorithm, true);
var compressionAlgorithms = new CompressionAlgorithm[] { compressionAlgorithm };
SMB2CompressionTest(compressionAlgorithms, CompressionTestVariant.BasicReadWrite, enableEncryption: true);
}
/// <summary>
/// Get compressor instance.
/// </summary>
/// <param name="compressionAlgorithm">The compression algorithm to use.</param>
/// <returns>The compressor.</returns>
public static XcaCompressor GetCompressor(CompressionAlgorithm compressionAlgorithm)
{
if (!compressorInstances.ContainsKey(compressionAlgorithm))
{
throw new InvalidOperationException("Invalid compressor algorithm!");
}
return compressorInstances[compressionAlgorithm];
}
public CompressionMessageFormatter(CompressionAlgorithm algorithm, OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute, DataContractSerializerOperationBehavior serializerFactory)
{
this.MessageCompressor = new MessageCompressor(algorithm);
Type innerFormatterType = Type.GetType(DataContractSerializerOperationFormatterTypeName);
var innerFormatter = Activator.CreateInstance(innerFormatterType, description, dataContractFormatAttribute, serializerFactory);
this.InnerClientMessageFormatter = innerFormatter as IClientMessageFormatter;
this.InnerDispatchMessageFormatter = innerFormatter as IDispatchMessageFormatter;
}
public Tid(Bitmap bitmap, MixedString filename, CompressionAlgorithm compression = CompressionAlgorithm.None, byte version = 0x90)
{
Bitmap = bitmap;
Filename = filename.GetCustomLength(0x20);
Compression = compression;
Version = version;
Loaded = true;
}
/// <summary>
/// Creates the Compression stream that will handle inflation.
/// </summary>
private void InflateInit(CompressionAlgorithm algorithm)
{
_compression_struct = new CompressionStreamStruct();
var status = CompressionStreamStruct.compression_stream_init(ref _compression_struct, StreamOperation.Decode, algorithm);
if (status != CompressionStatus.Ok)
throw new InvalidOperationException(status.ToString()); }
/// <summary>
/// Get decompressor instance.
/// </summary>
/// <param name="compressionAlgorithm">The compression algorithm to use.</param>
/// <returns>The decompressor.</returns>
public static XcaDecompressor GetDecompressor(CompressionAlgorithm compressionAlgorithm)
{
if (!compressorInstances.ContainsKey(compressionAlgorithm))
{
throw new InvalidOperationException();
}
return(decompressorInstances[compressionAlgorithm]);
}
/// <summary>
/// Sets the parser back to the beginning of the file.
/// </summary>
public void Reset()
{
m_compressionAlgorithm = CompressionAlgorithm.None;
m_compressionStyle = CompressionStyle.None;
m_fileReader.BaseStream.Seek(0, SeekOrigin.Begin);
m_hasNextRecord = true;
m_headerAddresses.Clear();
m_exceptionList.Clear();
}
/// <summary>
/// Indicates that all data that will be written into the stream should be compressed.
/// </summary>
/// <param name="algorithm">Compression algorithm that should be used</param>
public void BeginCompression(CompressionAlgorithm algorithm)
{
Write(ref algorithm);
if (algorithm == CompressionAlgorithm.Deflate)
{
_activeStream = new DeflateStream(_stream, CompressionLevel.SmallestSize, true);
}
}
public CompressionMessageFormatter(CompressionAlgorithm algorithm, OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute, DataContractSerializerOperationBehavior serializerFactory)
{
this.MessageCompressor = new MessageCompressor(algorithm);
Type innerFormatterType = Type.GetType(DataContractSerializerOperationFormatterTypeName);
var innerFormatter = Activator.CreateInstance(innerFormatterType, description, dataContractFormatAttribute, serializerFactory);
this.InnerClientMessageFormatter = innerFormatter as IClientMessageFormatter;
this.InnerDispatchMessageFormatter = innerFormatter as IDispatchMessageFormatter;
}
public void TestDecodeRealFile(CompressionAlgorithm algorithm, string compressedFile)
{
#if MONOMAC
string compressedFilePath = Path.Combine(NSBundle.MainBundle.BundlePath, $"Contents/Resources/{compressedFile}");
#else
string compressedFilePath = Path.Combine(NSBundle.MainBundle.BundlePath, compressedFile);
#endif
DecodeRealFile(algorithm, compressedFilePath, uncompressedFilePath);
}
//The GZip encoder wraps an inner encoder
//We require a factory to be passed in that will create this inner encoder
public GZipMessageEncoderFactory(MessageEncoderFactory messageEncoderFactory, CompressionAlgorithm compressionAlgorithm)
{
if (messageEncoderFactory == null)
{
throw new ArgumentNullException("messageEncoderFactory", "A valid message encoder factory must be passed to the CompressionEncoder");
}
encoder = new GZipMessageEncoder(messageEncoderFactory.Encoder, compressionAlgorithm);
this.compressionAlgorithm = compressionAlgorithm;
this.innerFactory = messageEncoderFactory;
}
/// <summary>
/// Initializes a new KdbxWriter with the given options.
/// </summary>
/// <param name="cipher">The algorithm to use for encrypting the database.</param>
/// <param name="rngAlgorithm">The random number generator used for String protection.</param>
/// <param name="compression">The document compression algorithm.</param>
/// <param name="kdfParams">Recipe for transforming the raw key. This will be reseeded.</param>
private KdbxWriter(
EncryptionAlgorithm cipher,
RngAlgorithm rngAlgorithm,
CompressionAlgorithm compression,
KdfParameters kdfParams
)
: base()
{
SeedHeaderData(cipher, rngAlgorithm, compression, kdfParams);
}
public static MethodInfo GetDecompress(ModuleBuilder modBldr, GeneratorOptions config, CompressionAlgorithm alg)
{
switch (alg)
{
case CompressionAlgorithm.LZF:
return GetDecompressLZF(modBldr, config);
default:
throw new Exception("Unknown CompressionAlgorithm!");
}
}
public void TestDecodeRealFile(CompressionAlgorithm algorithm, string compressedFile)
{
if (!TestRuntime.CheckXcodeVersion(7, 0))
{
Assert.Ignore("Requires iOS 9.0+ or macOS 10.11+");
}
string compressedFilePath = Path.Combine(NSBundle.MainBundle.ResourcePath, compressedFile);
DecodeRealFile(algorithm, compressedFilePath, uncompressedFilePath);
}
public Smb2CompressionInfo()
{
CompressAllPackets = false;
CompressionIds = new CompressionAlgorithm[0];
PreferredCompressionAlgorithm = CompressionAlgorithm.NONE;
CompressBufferOnly = false;
SupportChainedCompression = false;
}
//We require an inner encoder to be supplied (see comment above)
internal GZipMessageEncoder(MessageEncoder messageEncoder, CompressionAlgorithm compressionAlgorithm)
: base()
{
if (messageEncoder == null)
{
throw new ArgumentNullException("messageEncoder", "A valid message encoder must be passed to the CompressionEncoder");
}
innerEncoder = messageEncoder;
this.compressionAlgorithm = compressionAlgorithm;
}
private void FetchSmb2CompressionInfo(Smb2Info smb2Info)
{
if (smb2Info.MaxSupportedDialectRevision < DialectRevision.Smb311)
{
logWriter.AddLog(LogLevel.Information, "SMB dialect less than 3.1.1 does not support compression.");
smb2Info.SupportedCompressionAlgorithms = new CompressionAlgorithm[0];
return;
}
var possibleCompressionAlogrithms = new CompressionAlgorithm[] { CompressionAlgorithm.LZ77, CompressionAlgorithm.LZ77Huffman, CompressionAlgorithm.LZNT1 };
// Iterate all possible compression algorithm for Windows will only return only one supported compression algorithm in response.
var result = possibleCompressionAlogrithms.Where(compressionAlgorithm =>
{
using (var client = new Smb2Client(new TimeSpan(0, 0, defaultTimeoutInSeconds)))
{
client.ConnectOverTCP(SUTIpAddress);
DialectRevision selectedDialect;
byte[] gssToken;
Packet_Header responseHeader;
NEGOTIATE_Response responsePayload;
uint status = client.Negotiate(
0,
1,
Packet_Header_Flags_Values.NONE,
0,
new DialectRevision[] { DialectRevision.Smb311 },
SecurityMode_Values.NEGOTIATE_SIGNING_ENABLED,
Capabilities_Values.NONE,
Guid.NewGuid(),
out selectedDialect,
out gssToken,
out responseHeader,
out responsePayload,
preauthHashAlgs: new PreauthIntegrityHashID[] { PreauthIntegrityHashID.SHA_512 },
compressionAlgorithms: new CompressionAlgorithm[] { compressionAlgorithm }
);
if (status == Smb2Status.STATUS_SUCCESS && client.CompressionInfo.CompressionIds.Length == 1 && client.CompressionInfo.CompressionIds[0] == compressionAlgorithm)
{
logWriter.AddLog(LogLevel.Information, $"Compression algorithm: {compressionAlgorithm} is supported by SUT.");
return(true);
}
else
{
logWriter.AddLog(LogLevel.Information, $"Compression algorithm: {compressionAlgorithm} is not supported by SUT.");
return(false);
}
}
});
smb2Info.SupportedCompressionAlgorithms = result.ToArray();
}
/// <summary>
/// Initializes a new KdbxWriter with the given options.
/// </summary>
/// <param name="tokenList">An enumeration of security tokens used for encryption.</param>
/// <param name="cipher">The algorithm to use for encrypting the database.</param>
/// <param name="rngAlgorithm">The random number generator used for String protection.</param>
/// <param name="compression">The document compression algorithm.</param>
/// <param name="kdfParams">Recipe for transforming the raw key.</param>
public KdbxWriter(
IEnumerable <ISecurityToken> securityTokens,
EncryptionAlgorithm cipher,
RngAlgorithm rngAlgorithm,
CompressionAlgorithm compression,
KdfParameters kdfParams
)
: this(cipher, rngAlgorithm, compression, kdfParams)
{
this.securityTokens = securityTokens ?? throw new ArgumentNullException(nameof(securityTokens));
}
public override void Deserialize(Stream input)
{
this.Name = input.ReadStringAlignedU8();
this.Version = input.ReadValueU32();
this.Width = input.ReadValueU32();
this.Height = input.ReadValueU32();
this.Unknown4 = input.ReadValueU32();
this.Unknown5 = input.ReadValueU32();
this.NumMipMaps = input.ReadValueU32();
this.Algorithm = (CompressionAlgorithm)input.ReadValueU32();
}
/// <summary>
/// Indicates that all data that will be read from the stream has been compressed.
/// </summary>
public void BeginCompression()
{
CompressionAlgorithm algorithm = CompressionAlgorithm.None;
Read(ref algorithm);
if (algorithm == CompressionAlgorithm.Deflate)
{
_activeStream = new DeflateStream(_stream, CompressionMode.Decompress, true);
}
}
// 解压缩
public static void DecompressData(byte[] inBytes, uint startPos, uint inLen, ref byte[] outBytes, ref uint outLen, CompressionAlgorithm algorithm = CompressionAlgorithm.ZLIB)
{
if (CompressionAlgorithm.ZLIB == algorithm)
{
DecompressByteZipNet(inBytes, startPos, inLen, ref outBytes, ref outLen);
}
else
{
DecompressStrLZMA(inBytes, startPos, inLen, ref outBytes, ref outLen);
}
}
//The GZip encoder wraps an inner encoder
//We require a factory to be passed in that will create this inner encoder
public CompressMessageEncoderFactory(MessageEncoderFactory messageEncoderFactory,
CompressionAlgorithm compressionAlgorithm)
{
if (messageEncoderFactory == null)
throw new ArgumentNullException("messageEncoderFactory",
"A valid message encoder factory must be passed to the CompressionEncoder");
_encoder = new MyCompressionMessageEncoder(messageEncoderFactory.Encoder, compressionAlgorithm);
_compressionAlgorithm = compressionAlgorithm;
_innerFactory = messageEncoderFactory;
}
internal void InitializeInflater(Stream stream, CompressionAlgorithm algorithm, bool leaveOpen)
{
if (!stream.CanRead)
{
throw new ArgumentException("Stream does not support reading.", nameof(stream));
}
_inflater = new Inflater(algorithm);
_stream = stream;
_mode = CompressionMode.Decompress;
_leaveOpen = leaveOpen;
}
public static string ConvertToString(CompressionAlgorithm algorithm)
{
switch (algorithm)
{
case CompressionAlgorithm.GZip:
return gzip;
case CompressionAlgorithm.Deflate:
return deflate;
default:
throw new NotSupportedException("Compression mode " + algorithm + " is not supported");
}
}
public static SquishFlags ToSquishFlags(this CompressionAlgorithm compression)
{
if (compression == CompressionAlgorithm.Dxt1)
{
return(SquishFlags.Dxt1);
}
if (compression == CompressionAlgorithm.Dxt5)
{
return(SquishFlags.Dxt5);
}
return(0);
}
public static byte[] Compress(byte[] decompressedData, CompressionAlgorithm algorithm)
{
using (MemoryStream stream = new MemoryStream())
{
if (algorithm == CompressionAlgorithm.Deflate)
{
GZipStream stream2 = new GZipStream(stream, CompressionMode.Compress, true);
stream2.Write(decompressedData, 0, decompressedData.Length);
stream2.Close();
}
else
{
DeflateStream stream3 = new DeflateStream(stream, CompressionMode.Compress, true);
stream3.Write(decompressedData, 0, decompressedData.Length);
stream3.Close();
}
return stream.ToArray();
}
}
public virtual byte[] Decompress(byte[] compressedData, CompressionAlgorithm algorithm)
{
using (MemoryStream stream = new MemoryStream(compressedData))
{
if (algorithm == CompressionAlgorithm.Deflate)
{
using (GZipStream stream2 = new GZipStream(stream, CompressionMode.Decompress))
{
return LoadToBuffer(stream2);
}
}
else
{
using (DeflateStream stream3 = new DeflateStream(stream, CompressionMode.Decompress))
{
return LoadToBuffer(stream3);
}
}
}
}
public static byte[] Compress(byte[] decompressedData, CompressionAlgorithm algorithm, CompressionLevel Level)
{
var memoryStream = new MemoryStream();
switch (algorithm)
{
case CompressionAlgorithm.GZip:
var gZipStream = new GZipStream(memoryStream, CompressionMode.Compress, true);
gZipStream.Write(decompressedData, 0, decompressedData.Length);
gZipStream.Close();
break;
case CompressionAlgorithm.Deflate:
var compressedDeflateStream = new DeflateStream(memoryStream, CompressionMode.Compress, true);
compressedDeflateStream.Write(decompressedData, 0, decompressedData.Length);
compressedDeflateStream.Close();
break;
default:
throw new NotSupportedException(
String.Format("Unknown compression algorithm parameter must be deflate or gzip: {0}", algorithm));
}
return memoryStream.ToArray();
}
public static byte[] Decompress(byte[] compressedData, CompressionAlgorithm algorithm, CompressionLevel Level)
{
var memoryStream = new MemoryStream(compressedData);
byte[] buffer;
switch (algorithm)
{
case CompressionAlgorithm.GZip:
using (var gZipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
{
buffer = LoadToBuffer(gZipStream);
}
break;
case CompressionAlgorithm.Deflate:
using (var deflateStream = new DeflateStream(memoryStream, CompressionMode.Decompress))
{
buffer = LoadToBuffer(deflateStream);
}
break;
default:
throw new NotSupportedException(
String.Format("Unknown compression algorithm parameter must be deflate or gzip: {0}", algorithm));
}
return buffer;
}
private static byte[] Decompress(byte[] responseBytes, CompressionAlgorithm compressionAlgorithm)
{
Stream decompressingStream;
switch (compressionAlgorithm)
{
case CompressionAlgorithm.GZip:
decompressingStream = new GZipStream(new MemoryStream(responseBytes), CompressionMode.Decompress);
break;
case CompressionAlgorithm.Deflate:
decompressingStream = new DeflateStream(new MemoryStream(responseBytes), CompressionMode.Decompress);
break;
default:
throw new NotSupportedException("Unsupported compression algorithm: " + compressionAlgorithm + ".");
}
try
{
var buffer = new byte[BufferSize];
using (var outputMemoryStream = new MemoryStream())
{
while (true)
{
var bytesRead = decompressingStream.Read(buffer, 0, buffer.Length);
if (bytesRead <= 0)
{
break;
}
outputMemoryStream.Write(buffer, 0, bytesRead);
}
return outputMemoryStream.ToArray();
}
}
finally
{
decompressingStream.Close();
}
}
public MessageCompressor(CompressionAlgorithm algorithm, CompressionLevel level)
{
_algorithm = algorithm;
_level = level;
}
public static void AddCompressionHeader(this Message message, CompressionAlgorithm algorithm)
{
message.Headers.Add(MessageHeader.CreateHeader(Constants.CompressionMessageHeader, Constants.Namespace, string.Format("algorithm = \"{0}\"", algorithm)));
}
public void Compress(CompressionAlgorithm algorithm)
{
var buffer = memoryStream.ToArray();
memoryStream.Close();
var ms = new MemoryStream();
var stream = algorithm == CompressionAlgorithm.Zlib
? new ZlibStream(ms, CompressionMode.Compress, true)
: new DeflateStream(ms, CompressionMode.Compress, true);
using (stream)
stream.Write(buffer, 0, buffer.Length);
memoryStream = ms;
dataOutput = new DataOutput(new AmfWriter(memoryStream, serializationContext));
dataInput = new DataInput(new AmfReader(memoryStream, serializationContext));
}
public void Uncompress(CompressionAlgorithm algorithm)
{
Position = 0;
var ms = new MemoryStream();
var buffer = new byte[1024];
// The zlib format is specified by RFC 1950. Zlib also uses deflate, plus 2 or 6 header bytes, and a 4 byte checksum at the end.
// The first 2 bytes indicate the compression method and flags. If the dictionary flag is set, then 4 additional bytes will follow.
// Preset dictionaries aren't very common and we don't support them
var deflateStream = algorithm == CompressionAlgorithm.Zlib
? new ZlibStream(memoryStream, CompressionMode.Decompress, false)
: new DeflateStream(memoryStream, CompressionMode.Decompress, false);
while (true)
{
var readCount = deflateStream.Read(buffer, 0, buffer.Length);
if (readCount == 0)
break;
ms.Write(buffer, 0, readCount);
}
memoryStream.Dispose();
memoryStream = ms;
memoryStream.Position = 0;
dataOutput = new DataOutput(new AmfWriter(memoryStream, serializationContext));
dataInput = new DataInput(new AmfReader(memoryStream, serializationContext));
}
// 解压
public uint uncompress(uint len_ = 0, CompressionAlgorithm algorithm = CompressionAlgorithm.ZLIB)
{
len_ = (len_ == 0 ? length : len_);
byte[] retByte = null;
uint retSize = 0;
Compress.DecompressData(m_dynBuff.buff, position, len_, ref retByte, ref retSize, algorithm);
replace(retByte, 0, retSize, position, len_);
//check();
return retSize;
}
public static String Decompress(this String data, CompressionAlgorithm algorithm)
{
return Decompress(data, Encoding.UTF8, algorithm);
}
/// <summary>
/// 压缩数据流。
/// </summary>
/// <param name="algorithm">要使用的压缩算法。CompressionAlgorithms 类中提供了常用的压缩算法。</param>
/// <param name="inputBuffer">指定输入缓冲区。</param>
/// <param name="inputOffset">指定输入缓冲区的开始位置。</param>
/// <param name="inputCount">指定输入缓冲区的长度。</param>
/// <param name="outputBuffer">指定输出缓冲区。</param>
/// <param name="outputOffset">指定输出缓冲区的开始位置。</param>
/// <returns>返回压缩后的字节数。</returns>
/// <exception cref="System.ArgumentNullException"></exception>
public static int Compression(CompressionAlgorithm algorithm, CompressionMode mode, byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
{
if (algorithm == null || inputBuffer == null || outputBuffer == null) throw new ArgumentNullException();
if (mode == CompressionMode.Compress)
return algorithm.CompressBlock(inputBuffer, inputOffset, inputCount, outputBuffer, outputOffset);
else
return algorithm.DecompressBlock(inputBuffer, inputOffset, inputCount, outputBuffer, outputOffset);
}
/// <summary>
/// 压缩数据流。
/// </summary>
/// <param name="algorithm">要使用的压缩算法。CompressionAlgorithms 类中提供了常用的压缩算法。</param>
/// <param name="inputBuffer">指定输入缓冲区。</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"></exception>
public static byte[] Compression(CompressionAlgorithm algorithm, CompressionMode mode, byte[] inputBuffer)
{
if (algorithm == null || inputBuffer == null) throw new ArgumentNullException();
if (mode == CompressionMode.Compress)
return algorithm.CompressFinalBlock(inputBuffer, 0, inputBuffer.Length);
else
return algorithm.DecompressFinalBlock(inputBuffer, 0, inputBuffer.Length);
}
public static Byte[] Decompress(this Byte[] data, CompressionAlgorithm algorithm)
{
if (data == null || data.Length <= 0)
return new Byte[0];
//--- Define Location To Store Compressed n Decompressed Data ---//
MemoryStream cprMS = new MemoryStream(data);
MemoryStream dcprMS = new MemoryStream();
Int32 size = 4096;
cprMS.Position = 0;
//--- Create Compression Object ---//
Stream zipper;
if (algorithm == CompressionAlgorithm.GZipStream)
zipper = new GZipStream(cprMS, CompressionMode.Decompress);
else
zipper = new DeflateStream(cprMS, CompressionMode.Decompress);
//--- Decompress ---//
Byte[] dcprData = new Byte[size];
Int32 Count = 0;
while (true)
{
Count = zipper.Read(dcprData, 0, dcprData.Length);
if (Count > 0)
dcprMS.Write(dcprData, 0, Count);
else
break;
}
return dcprMS.ToArray();
}
public static String Decompress(this String data, Encoding encoder, CompressionAlgorithm algorithm)
{
Byte[] dataBytes = Convert.FromBase64String(data);
return encoder.GetString(Decompress(dataBytes, algorithm));
}
//Helper method to decompress an array of bytes
private static ArraySegment<byte> DecompressBuffer(ArraySegment<byte> buffer, BufferManager bufferManager,
CompressionAlgorithm compressionAlgorithm)
{
var memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count);
var decompressedStream = new MemoryStream();
//int totalRead = 0;
const int blockSize = 1024;
byte[] tempBuffer = bufferManager.TakeBuffer(blockSize);
using (Stream compressedStream = compressionAlgorithm == CompressionAlgorithm.GZip
? new GZipStream(memoryStream, CompressionMode.Decompress)
: (Stream)
new DeflateStream(memoryStream, CompressionMode.Decompress))
{
while (true)
{
int bytesRead = compressedStream.Read(tempBuffer, 0, blockSize);
if (bytesRead == 0)
break;
decompressedStream.Write(tempBuffer, 0, bytesRead);
//totalRead += bytesRead;
}
}
bufferManager.ReturnBuffer(tempBuffer);
byte[] decompressedBytes = decompressedStream.ToArray();
byte[] bufferManagerBuffer = bufferManager.TakeBuffer(decompressedBytes.Length + buffer.Offset);
Array.Copy(buffer.Array, 0, bufferManagerBuffer, 0, buffer.Offset);
Array.Copy(decompressedBytes, 0, bufferManagerBuffer, buffer.Offset, decompressedBytes.Length);
var byteArray = new ArraySegment<byte>(bufferManagerBuffer, buffer.Offset,
decompressedBytes.Length);
bufferManager.ReturnBuffer(buffer.Array);
return byteArray;
}
//Helper method to compress an array of bytes
private static ArraySegment<byte> CompressBuffer(ArraySegment<byte> buffer, BufferManager bufferManager,
int messageOffset,
CompressionAlgorithm compressionAlgorithm)
{
var memoryStream = new MemoryStream();
using (Stream compressedStream = compressionAlgorithm == CompressionAlgorithm.GZip
? new GZipStream(memoryStream, CompressionMode.Compress, true)
: (Stream)
new DeflateStream(memoryStream, CompressionMode.Compress, true)
)
{
compressedStream.Write(buffer.Array, buffer.Offset, buffer.Count);
}
byte[] compressedBytes = memoryStream.ToArray();
int totalLength = messageOffset + compressedBytes.Length;
byte[] bufferedBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(compressedBytes, 0, bufferedBytes, messageOffset, compressedBytes.Length);
bufferManager.ReturnBuffer(buffer.Array);
var byteArray = new ArraySegment<byte>(bufferedBytes, messageOffset,
compressedBytes.Length);
return byteArray;
}
/// <summary>
/// 压缩数据流。
/// </summary>
/// <param name="algorithm">要使用的压缩算法。CompressionAlgorithms 类中提供了常用的压缩算法。</param>
/// <param name="inputStream">指定输入流。</param>
/// <param name="inputCount">输入流的长度，或 -1 以代表读至流的末尾。</param>
/// <param name="outputStream">指定输出流。</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"></exception>
public static void Compression(CompressionAlgorithm algorithm, CompressionMode mode, Stream inputStream, int inputCount, Stream outputStream)
{
if (algorithm == null || inputStream == null || outputStream == null) throw new ArgumentNullException();
if (inputCount == 0)
return;
var countRead = 0;
var lastTimeRead = 0;
var inputBuffer = new byte[Compressor.ChunkSize];
do {
lastTimeRead = inputStream.Read(inputBuffer, 0, inputCount == -1 ? Compressor.ChunkSize : Math.Min(Compressor.ChunkSize, (inputCount - countRead)));
if (lastTimeRead != 0) {
countRead += lastTimeRead;
if (mode == CompressionMode.Compress) {
var ret = algorithm.CompressFinalBlock(inputBuffer, 0, lastTimeRead);
outputStream.Write(ret, 0, ret.Length);
}
else {
var ret = algorithm.DecompressFinalBlock(inputBuffer, 0, lastTimeRead);
outputStream.Write(ret, 0, ret.Length);
}
}
}
while ((countRead < inputCount && inputCount != -1) || (inputCount == -1 && lastTimeRead != 0));
}
/// <summary>
/// 压缩数据流。
/// </summary>
/// <param name="algorithm">要使用的压缩算法。CompressionAlgorithms 类中提供了常用的压缩算法。</param>
/// <param name="inputStream">指定输入流。</param>
/// <param name="outputStream">指定输出流。</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"></exception>
public static void Compression(CompressionAlgorithm algorithm, CompressionMode mode, Stream inputStream, Stream outputStream)
{
Compression(algorithm, mode, inputStream, -1, outputStream);
}
/// <summary>
/// 压缩数据流。
/// </summary>
/// <param name="algorithm">要使用的压缩算法。CompressionAlgorithms 类中提供了常用的压缩算法。</param>
/// <param name="inputStream">指定输入流。</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"></exception>
public static byte[] Compression(CompressionAlgorithm algorithm, CompressionMode mode, Stream inputStream)
{
var ms = new MemoryStream();
Compression(algorithm, mode, inputStream, -1, ms);
return ms.ToArray();
}
public DataCompressor(CompressionAlgorithm algorithm)
{
this.Algorithm = algorithm;
}
public static byte[] CompressData(byte[] data, CompressionAlgorithm alg)
{
switch (alg)
{
case CompressionAlgorithm.None:
return data;
case CompressionAlgorithm.LZF:
return LZF.Compress(data);
default:
throw new Exception("Unknown compression algorithm!");
}
}
//We require an inner encoder to be supplied (see comment above)
internal MyCompressionMessageEncoder(MessageEncoder messageEncoder,
CompressionAlgorithm compressionAlgorithm)
{
if (messageEncoder == null)
throw new ArgumentNullException("messageEncoder",
"A valid message encoder must be passed to the CompressionEncoder");
_innerEncoder = messageEncoder;
_compressionAlgorithm = compressionAlgorithm;
}
public static String Compress(this String data, Encoding encoder, CompressionAlgorithm algorithm)
{
Byte[] dataBytes = data.ToByteArray(encoder);
return Convert.ToBase64String(Compress(dataBytes, algorithm));
}