public static void zlibDeflate(
string pathInput,
string pathOutput,
CompressionMode mode,
CompressionLevel level
)
{
using (Stream input = File.OpenRead(pathInput))
using (Stream output = File.Create(pathOutput))
using (Stream deflateStream = new DeflateStream(
mode == CompressionMode.Compress ? output : input,
mode, level, true))
{
byte[] buff = new byte[ZLIB_BUFF_SIZE];
int n = 0;
Stream toRead = mode == CompressionMode.Compress ?
input : deflateStream;
Stream toWrite = mode == CompressionMode.Compress ?
deflateStream : output;
while (0 != (n = toRead.Read(buff, 0, buff.Length)))
{
toWrite.Write(buff, 0, n);
}
deflateStream.Close();
input.Close();
output.Close();
}
}
internal static ZipFile Read(string name, Task task, DoWorkArgs progress, ProgressChangedArgs args)
{
ZipFile zip = new ZipFile(name);
using (FileStream fileStream = File.OpenRead(name))
{
using (DeflateStream decompress = new DeflateStream(fileStream, CompressionMode.Decompress))
{
using (BinaryReader reader = new BinaryReader(decompress))
{
int count = reader.ReadByte();
for (int k = 0; k < count; k++)
{
string fileName = reader.ReadString();
if (task != null)
{
args.message = "Reading " + fileName + "...";
task.ReportProgress(progress.background, -1, args);
}
byte[] buffer = reader.ReadBytes(reader.ReadInt32());
zip[fileName] = buffer;
}
}
}
}
return zip;
}
/// <summary>
/// 지정된 데이타를 압축한다.
/// </summary>
/// <param name="input">압축할 Data</param>
/// <returns>압축된 Data</returns>
public override byte[] Compress(byte[] input) {
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.CompressStartMsg);
// check input data
if(input.IsZeroLength()) {
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.InvalidInputDataMsg);
return CompressorTool.EmptyBytes;
}
byte[] output;
using(var outStream = new MemoryStream()) {
using(var deflate = new DeflateStream(outStream, CompressionMode.Compress, CompressionLevel.BestSpeed)) {
deflate.Write(input, 0, input.Length);
}
output = outStream.ToArray();
}
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.CompressResultMsg, input.Length, output.Length, output.Length / (double)input.Length);
return output;
}
internal void Write(Task task, DoWorkArgs progress, ProgressChangedArgs args)
{
using (FileStream fileStream = File.Create(this.name))
{
using (DeflateStream compress = new DeflateStream(fileStream, CompressionMode.Compress))
{
using (BinaryWriter writer = new BinaryWriter(compress))
{
writer.Write((byte)this.files.Count);
foreach (string file in this.files.Keys)
{
if (task != null)
{
args.message = "Saving " + file + "...";
task.ReportProgress(progress.background, -1, args);
}
writer.Write(file);
writer.Write(this.files[file].Length);
writer.Write(this.files[file]);
}
if (task != null)
{
args.message = "Done";
task.ReportProgress(progress.background, -1, args);
}
}
}
}
}
internal void Read()
{
try
{
using (FileStream fileStream = File.OpenRead(this.Name))
{
using (DeflateStream deflateStream = new DeflateStream(fileStream, CompressionMode.Decompress))
{
using (BinaryReader binaryReader = new BinaryReader(deflateStream))
{
int num = (int)binaryReader.ReadByte();
for (int i = 0; i < num; i++)
{
this.AddFile(binaryReader.ReadString(), binaryReader.ReadBytes(binaryReader.ReadInt32()));
}
}
deflateStream.Dispose();
}
}
}
catch
{
this.InvalidFile = true;
}
}
/// <summary>
/// Reads all log messages from the supplied file.
/// </summary>
public static void Compact(ICollection<string> inputFileNames, string outputFileName)
{
LogCollection logs = new LogCollection();
foreach (var file in inputFileNames)
{
using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
if (stream.ReadBoolean())
{
//Wrong File Version
break;
}
if (stream.ReadNextByte() != 1)
{
//Wrong File Version
break;
}
using (var zipStream = new DeflateStream(stream, CompressionMode.Decompress, true))
using (var bs = new BufferedStream(zipStream, 8192))
{
while (bs.ReadBoolean())
{
var message = new LogMessage(bs);
logs.Pass1(message);
}
}
}
}
logs.Compact();
foreach (var file in inputFileNames)
{
using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
if (stream.ReadBoolean())
{
//Wrong File Version
break;
}
if (stream.ReadNextByte() != 1)
{
//Wrong File Version
break;
}
using (var zipStream = new DeflateStream(stream, CompressionMode.Decompress, true))
using (var bs = new BufferedStream(zipStream, 8192))
{
while (bs.ReadBoolean())
{
var message = new LogMessage(bs);
logs.Pass2(message);
}
}
}
}
logs.Save(outputFileName);
}
public byte[] Decompress(Stream inputStream)
{
using (var deflateStream = new DeflateStream(inputStream, CompressionMode.Decompress))
using (var outputStream = new MemoryStream())
{
deflateStream.WriteTo(outputStream);
return outputStream.ToArray();
}
}
private byte[] compress(byte[] a, int level)
{
using (var ms = new MemoryStream())
{
CompressionLevel compressionLevel = CompressionLevel.Default;
switch (level)
{
case 0:
compressionLevel = CompressionLevel.Level0;
break;
case 1:
compressionLevel = CompressionLevel.Level1;
break;
case 2:
compressionLevel = CompressionLevel.Level2;
break;
case 3:
compressionLevel = CompressionLevel.Level3;
break;
case 4:
compressionLevel = CompressionLevel.Level4;
break;
case 5:
compressionLevel = CompressionLevel.Level5;
break;
case 6:
compressionLevel = CompressionLevel.Level6;
break;
case 7:
compressionLevel = CompressionLevel.Level7;
break;
case 8:
compressionLevel = CompressionLevel.Level8;
break;
case 9:
compressionLevel = CompressionLevel.Level9;
break;
}
using (var compresssor = new Ionic.Zlib.DeflateStream(ms, CompressionMode.Compress, compressionLevel))
{
compresssor.Write(a, 0, a.Length);
}
return(ms.ToArray());
}
}
/// <summary>Deflate encoder, compatible with .NET one but with bettern compression
/// ratio (in .NET 4.0, in .NET 4.5 they are identical).</summary>
/// <param name="input">The input.</param>
/// <returns>Compressed data.</returns>
public static byte[] DeflateEncoder(byte[] input)
{
using (var ostream = new MemoryStream())
{
using (var zstream = new DeflateStream(ostream, CompressionMode.Compress))
{
zstream.Write(input, 0, input.Length);
zstream.Flush();
}
return ostream.ToArray();
}
}
public static byte[] CompressDeflate(byte[] bytes)
{
using (var ms = new MemoryStream())
{
using (var zip = new DeflateStream(ms, CompressionMode.Compress, true))
{
zip.Write(bytes, 0, bytes.Length);
}
return ms.ToArray();
}
}
public static byte[] CompressBuffer(byte[] buffer)
{
byte[] compressed;
using (var input = new MemoryStream(buffer))
using (var compressStream = new MemoryStream())
using (var compressor = new DeflateStream(compressStream, CompressionMode.Compress))
{
input.CopyTo(compressor);
compressor.Close();
compressed = compressStream.ToArray();
}
return compressed;
}
private static byte[] DecryptAes128CbcWithGzip(byte[] data, byte[] key)
{
byte[] gzippedFile;
using (var cipher = new AesManaged { Mode = CipherMode.CBC, Key = key })
gzippedFile = cipher.CreateDecryptor().TransformFinalBlock(data, 0, data.Length).Skip(16).ToArray();
using (var inStream = new MemoryStream(gzippedFile))
using (var zipStream = new DeflateStream(inStream, CompressionMode.Decompress))
using (var outStream = new MemoryStream())
{
zipStream.CopyTo(outStream);
return outStream.ToArray();
}
}
private static byte[] Deflate(byte[] bytes)
{
if (bytes == null) return new byte[0];
using (var stream = new MemoryStream())
{
using (var compressor = new DeflateStream(stream,CompressionMode.Compress, CompressionLevel.BestSpeed))
{
compressor.Write(bytes, 0, bytes.Length);
}
return stream.ToArray();
}
}
private async void btnApiAccess_Click(object sender, EventArgs e)
{
var claim = await GetClaimsAsync(UserAccessInfo.AccessToken);
var query = from info in claim where info.Item1 == UGConstants.ClaimTypes.PreferredUserName select info.Item2;
string userName = string.Empty;
if (query.Count() > 0)
userName = query.First();
var client = new HttpClient();
client.SetBearerToken(UserAccessInfo.AccessToken);
client.DefaultRequestHeaders.Add(UGConstants.HTTPHeaders.IOT_CLIENT_ID, IoTClientId);
client.DefaultRequestHeaders.Add(UGConstants.HTTPHeaders.IOT_CLIENT_SECRET, IoTClientSecret);
client.DefaultRequestHeaders.Add(UGConstants.ClaimTypes.PreferredUserName, userName);
BaseMessage msg = new BaseMessage("", "", SSD.Framework.Exceptions.ErrorCode.IsSuccess, "");
msg.MsgJson = "{\"LocationStoreID\":1,\"ID\":1}";
StringContent queryString = new StringContent(msg.ToJson());
var response = await client.PostAsync(APIUri,queryString);
if (response.IsSuccessStatusCode)
{
string contentStr = string.Empty;
IEnumerable<string> lst;
if (response.Content.Headers != null
&& response.Content.Headers.TryGetValues(UGConstants.HTTPHeaders.CONTENT_ENCODING, out lst)
&& lst.First().ToLower() == "deflate")
{
var bj = await response.Content.ReadAsByteArrayAsync();
using (var inStream = new MemoryStream(bj))
{
using (var bigStreamsss = new DeflateStream(inStream, CompressionMode.Decompress, true))
{
contentStr = await (new StreamReader(bigStreamsss)).ReadToEndAsync();
//using (var bigStreamOut = new MemoryStream())
//{
// bigStreamsss.CopyTo(bigStreamOut);
// contentStr = Encoding.UTF8.GetString(bigStreamOut.ToArray(), 0, bigStreamOut.ToArray().Length);
//}
}
}
}
else contentStr = await response.Content.ReadAsStringAsync();
MessageBox.Show(contentStr);
}
}
private static async Task CreateResponse(
HttpResponse result, Uri uri, HttpRequest request,
HttpClientHandler handler, HttpResponseMessage response,
CancellationToken token, IProgress <HttpProgress> progress)
{
if (response.Content != null)
{
foreach (var header in response.Content.Headers)
{
result.Headers.Add(header.Key, header.Value.First());
}
}
foreach (var header in response.Headers)
{
result.Headers.Add(header.Key, header.Value.First());
}
foreach (var cookie in handler.CookieContainer.GetCookies(uri))
{
result.Cookies.Add((Cookie)cookie);
}
var stream = await response.Content.ReadAsStreamAsync();
if (response.Content.Headers.ContentEncoding.Any(e => e.ToLower() == "gzip"))
{
stream = new Ionic.Zlib.GZipStream(stream, Ionic.Zlib.CompressionMode.Decompress);
}
else if (response.Content.Headers.ContentEncoding.Any(e => e.ToLower() == "deflate"))
{
stream = new Ionic.Zlib.DeflateStream(stream, Ionic.Zlib.CompressionMode.Decompress);
}
if (request.ResponseAsStream)
{
result.ResponseStream = stream;
result.RawResponse = null;
}
else
{
result.RawResponse = await stream.ReadToEndAsync(
response.Content.Headers.ContentLength.HasValue?response.Content.Headers.ContentLength.Value : -1,
token, progress);
}
}
public static byte[] DeflateByte(byte[] content)
{
if(null==content)
{
return null;
}
using (var stream = new MemoryStream())
{
using (var compressor = new DeflateStream(stream,CompressionMode.Compress,CompressionLevel.BestSpeed))
{
compressor.Write(content,0,content.Length);
}
return stream.ToArray();
}
}
public static byte[] DecompressDeflate(Stream input)
{
using (var decompressor = new DeflateStream(input, CompressionMode.Decompress))
{
var buffer = new byte[BufferSize];
using (var output = new MemoryStream())
{
int read;
while ((read = decompressor.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, read);
}
return output.ToArray();
}
}
}
public static byte[] CompressBuffer(byte[] buffer, ushort key, uint keyend)
{
byte[] compressed;
using (var compressStream = new MemoryStream())
using (var compressor = new DeflateStream(compressStream, CompressionMode.Compress))
{
compressor.Write(buffer, 0, buffer.Length);
compressor.Close();
compressed = compressStream.ToArray();
}
byte[] returnbytes = new byte[compressed.Length + 6];
byte[] kbyte = BitConverter.GetBytes(key);
byte[] kebyte = BitConverter.GetBytes(keyend);
Array.Copy(kbyte, 0, returnbytes, 0, kbyte.Length);
Array.Copy(compressed, 0, returnbytes, 2, compressed.Length);
Array.Copy(kebyte, 0, returnbytes, returnbytes.Length - 4, kebyte.Length);
return returnbytes;
}
/// <summary>
/// Creates a LogFileWriter that initially queues message
/// </summary>
public LogFileWriter(string logFileName)
{
CompressionLevel level = CompressionLevel.Level1;
FileName = logFileName;
m_saveHelper = LogMessageSaveHelper.Create();
FilePath.ValidatePathName(logFileName);
m_stream = new FileStream(logFileName, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read);
m_stream.Write(282497); //VersionNumber: Compressed. With LogSaveHelper
m_zipStream = new DeflateStream(m_stream, CompressionMode.Compress, level, true);
m_zipStream.FlushMode = FlushType.Sync;
m_tmpBuffer = new byte[40960];
m_tmpStream = new MemoryStream();
m_logCount = 0;
m_syncRoot = new object();
}
/// <summary>
/// Reads all log messages from the supplied file.
/// </summary>
public static List<LogMessage> Read(string logFileName)
{
List<LogMessage> lst = new List<LogMessage>();
FilePath.ValidatePathName(logFileName);
using (var stream = new FileStream(logFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
{
try
{
LogMessageSaveHelper helper;
int version = stream.ReadInt32();
switch (version)
{
case 282497:
helper = LogMessageSaveHelper.Create(); //VersionNumber: Compressed. With LogSaveHelper
break;
default:
throw new VersionNotFoundException();
}
using (var zipStream = new DeflateStream(stream, CompressionMode.Decompress, true))
using (var bs = new BufferedStream(zipStream))
{
while (bs.ReadBoolean())
{
var message = new LogMessage(bs, helper);
lst.Add(message);
}
bs.Dispose();
}
}
catch (EndOfStreamException)
{
}
catch (ZlibException)
{
}
}
return lst;
}
internal void Save()
{
using (FileStream fileStream = File.Create(Name))
{
using (DeflateStream compress = new DeflateStream(fileStream, CompressionMode.Compress))
{
using (BinaryWriter writer = new BinaryWriter(compress))
{
writer.Write((byte)fileNames.Count);
foreach (string fileName in fileNames)
{
writer.Write(fileName);
byte[] data = files[fileName];
writer.Write(data.Length);
writer.Write(data);
}
}
}
}
}
public static byte[] DeflateByte(byte[] str)
{
if (str == null)
{
return null;
}
using (var output = new MemoryStream())
{
using (
var compressor = new DeflateStream(
output, CompressionMode.Compress,
CompressionLevel.BestSpeed))
{
compressor.Write(str, 0, str.Length);
}
return output.ToArray();
}
}
public static ZipFile Read(string name)
{
ZipFile zip = new ZipFile(name);
using (FileStream fileStream = File.OpenRead(name))
{
using (DeflateStream decompress = new DeflateStream(fileStream, CompressionMode.Decompress))
{
using (BinaryReader reader = new BinaryReader(decompress))
{
int count = reader.ReadByte();
for (int k = 0; k < count; k++)
{
string fileName = reader.ReadString();
byte[] buffer = reader.ReadBytes(reader.ReadInt32());
zip[fileName] = buffer;
}
}
}
}
return zip;
}
public void Write(Task task = null, DoWorkArgs progress = default(DoWorkArgs))
{
using (FileStream fileStream = File.Create(this.name))
{
using (DeflateStream compress = new DeflateStream(fileStream, CompressionMode.Compress))
{
using (BinaryWriter writer = new BinaryWriter(compress))
{
writer.Write((byte)this.files.Count);
foreach (string file in this.files.Keys)
{
writer.Write(file);
writer.Write(this.files[file].Length);
writer.Write(this.files[file]);
if (task != null)
{
task.ReportProgress(progress);
}
}
}
}
}
}
internal void Read()
{
try
{
using (FileStream fileStream = File.OpenRead(Name))
{
using (DeflateStream decompress = new DeflateStream(fileStream, CompressionMode.Decompress))
{
using (BinaryReader reader = new BinaryReader(decompress))
{
int count = reader.ReadByte();
for (int k = 0; k < count; k++)
{
AddFile(reader.ReadString(), reader.ReadBytes(reader.ReadInt32()));
}
}
}
}
}
catch
{
InvalidFile = true;
}
}
/// <summary>
/// 압축된 데이타를 복원한다.
/// </summary>
/// <param name="input">복원할 Data</param>
/// <returns>복원된 Data</returns>
public override byte[] Decompress(byte[] input) {
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.DecompressStartMsg);
// check input data
if(input.IsZeroLength()) {
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.InvalidInputDataMsg);
return CompressorTool.EmptyBytes;
}
byte[] output;
var outStream = new MemoryStream();
try {
using(var inStream = new MemoryStream(input))
using(var deflate = new DeflateStream(inStream, CompressionMode.Decompress, CompressionLevel.BestSpeed, true)) {
StreamTool.CopyStreamToStream(deflate, outStream, CompressorTool.BUFFER_SIZE);
output = outStream.ToArray();
}
}
catch(Exception ex) {
if(log.IsErrorEnabled)
log.ErrorException("압축 복원 중 예외가 발생했습니다.", ex);
throw;
}
finally {
outStream.Close();
}
if(IsDebugEnabled)
log.Debug(CompressorTool.SR.DecompressResultMsg, input.Length, output.Length, output.Length / (double)input.Length);
return output;
}
public void Save()
{
if (!EnterSave())
return;
Stream zip = new DeflateStream(File.Create(DataFile + ".tmp"), CompressionMode.Compress);
try
{
zip.WriteByte(0); // version
zip.WriteByte(Convert.ToByte(LightToRecalculate));
for (int x = 0; x < 16; ++x)
{
for (int z = 0; z < 16; ++z)
{
zip.WriteByte(HeightMap[x, z]);
}
}
WriteAllBlocks(zip);
zip.Flush();
}
finally
{
try
{
zip.Dispose();
File.Delete(DataFile);
File.Move(DataFile + ".tmp", DataFile);
}
catch
{
}
finally
{
ExitSave();
}
}
}
public static Chunk Load(UniversalCoords coords, WorldManager world)
{
string path = world.Folder + "/x" + coords.ChunkX + "_z" + coords.ChunkZ + ".gz";
if (!CanLoad(path))
return null;
Stream zip = null;
Chunk chunk = new Chunk(world, coords);
try
{
zip = new DeflateStream(File.Open(path, FileMode.Open), CompressionMode.Decompress);
int version = zip.ReadByte();
switch(version)
{
/* When there's a new mod you do:
case 1:
{
* dosomething
* goto case 0;
}*/
case 0:
{
chunk.LightToRecalculate = Convert.ToBoolean(zip.ReadByte());
chunk.HeightMap = new byte[16,16];
int height;
chunk.MaxHeight = 0;
for (int x = 0; x < 16; ++x)
{
for (int z = 0; z < 16; ++z)
{
height = chunk.HeightMap[x, z] = (byte) zip.ReadByte();
if (chunk.MaxHeight < height)
chunk.MaxHeight = height;
}
}
chunk.LoadAllBlocks(zip);
break;
}
}
}
catch (Exception ex)
{
world.Logger.Log(ex);
return null;
}
if (zip != null)
zip.Dispose();
(BlockHelper.Instance((byte) BlockData.Blocks.Sign_Post) as BlockSignBase).LoadSignsFromDisk(chunk, world.SignsFolder);
return chunk;
}
/// <summary>
/// Uncompress a DEFLATE'd byte array into a byte array.
/// </summary>
///
/// <seealso cref="DeflateStream.CompressBuffer(byte[])">DeflateStream.CompressBuffer(byte[])</seealso>
/// <seealso cref="DeflateStream.UncompressString(byte[])">DeflateStream.UncompressString(byte[])</seealso>
/// <seealso cref="GZipStream.UncompressBuffer(byte[])">GZipStream.UncompressBuffer(byte[])</seealso>
/// <seealso cref="ZlibStream.UncompressBuffer(byte[])">ZlibStream.UncompressBuffer(byte[])</seealso>
///
/// <param name="compressed">
/// A buffer containing data that has been compressed with DEFLATE.
/// </param>
///
/// <returns>The data in uncompressed form</returns>
public static byte[] UncompressBuffer(byte[] compressed)
{
using (var input = new System.IO.MemoryStream(compressed))
{
System.IO.Stream decompressor =
new DeflateStream( input, CompressionMode.Decompress );
return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
}
}
/// <summary>
/// Compress a byte array into a new byte array using DEFLATE.
/// </summary>
///
/// <remarks>
/// Uncompress it with <see cref="DeflateStream.UncompressBuffer(byte[])"/>.
/// </remarks>
///
/// <seealso cref="DeflateStream.CompressString(string)">DeflateStream.CompressString(string)</seealso>
/// <seealso cref="DeflateStream.UncompressBuffer(byte[])">DeflateStream.UncompressBuffer(byte[])</seealso>
/// <seealso cref="GZipStream.CompressBuffer(byte[])">GZipStream.CompressBuffer(byte[])</seealso>
/// <seealso cref="ZlibStream.CompressBuffer(byte[])">ZlibStream.CompressBuffer(byte[])</seealso>
///
/// <param name="b">
/// A buffer to compress.
/// </param>
///
/// <returns>The data in compressed form</returns>
public static byte[] CompressBuffer(byte[] b)
{
using (var ms = new System.IO.MemoryStream())
{
System.IO.Stream compressor =
new DeflateStream( ms, CompressionMode.Compress, CompressionLevel.BestCompression );
ZlibBaseStream.CompressBuffer(b, compressor);
return ms.ToArray();
}
}
public string PostData(string url, string postData)
{
string str = string.Empty;
try
{
Uri requestUri = new Uri(url);
HttpWebRequest request = (HttpWebRequest) WebRequest.Create(requestUri);
byte[] bytes = Encoding.UTF8.GetBytes(postData);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = bytes.Length;
using (Stream stream = request.GetRequestStream())
{
stream.Write(bytes, 0, bytes.Length);
}
using (HttpWebResponse response = (HttpWebResponse) request.GetResponse())
{
using (Stream stream2 = response.GetResponseStream())
{
Encoding encoding = Encoding.UTF8;
Stream stream3 = stream2;
if (response.ContentEncoding.ToLower() == "gzip")
{
stream3 = new GZipStream(stream2, CompressionMode.Decompress);
}
else if (response.ContentEncoding.ToLower() == "deflate")
{
stream3 = new DeflateStream(stream2, CompressionMode.Decompress);
}
using (StreamReader reader = new StreamReader(stream3, encoding))
{
return reader.ReadToEnd();
}
}
}
}
catch (Exception exception)
{
str = string.Format("获取信息错误：{0}", exception.Message);
}
return str;
}
public void Save()
{
if (!EnterSave())
return;
Stream zip = new DeflateStream(File.Create(DataFile + ".tmp"), CompressionMode.Compress);
try
{
WriteAllBlocks(zip);
zip.Flush();
}
finally
{
try
{
zip.Dispose();
File.Delete(DataFile);
File.Move(DataFile + ".tmp", DataFile);
}
catch
{
}
finally
{
ExitSave();
}
}
}
