private static async Task <bool> GetHeader(Stream stream, byte[] messageHeader, ISharedArrayPool sharedArrayPool)
{
var binaryReader = new AsyncBinaryReader(stream);
var messageHeaderLength = await binaryReader.ReadUInt16Async();
Debug.Assert(messageHeaderLength == messageHeader.Length);
if (messageHeaderLength != messageHeader.Length)
{
// 消息不对，忽略
return(false);
}
var messageHeaderBuffer = sharedArrayPool.Rent(messageHeader.Length);
try
{
var readCount = await ReadBufferAsync(stream, messageHeaderBuffer, messageHeader.Length);
Debug.Assert(readCount == messageHeader.Length);
if (ByteListExtension.Equals(messageHeaderBuffer, messageHeader, readCount))
{
// 读对了
return(true);
}
else
{
// 发过来的消息是出错的
return(false);
}
}
finally
{
sharedArrayPool.Return(messageHeaderBuffer);
}
}
public async Task RunAsync(TcpClient client)
{
_client = client;
var ipaddr = ((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString();
_client.ReceiveTimeout = 1000;
var seedArr = new byte[4];
new Random().NextBytes(seedArr);
_mseed = seedArr;
_clientStream = _client.GetStream();
_reader = new AsyncBinaryReader(_clientStream);
_writer = new BinaryWriter(_clientStream);
_status = AuthStatus.UNAUTHED;
Debug.WriteLine("Connection from " + ipaddr);
SendAuthChallenge();
while (_run)
{
var lb1 = _ac.decrypt((await _reader.ReadBytesAsync(1)))[0];
var lb2 = _ac.decrypt((await _reader.ReadBytesAsync(1)))[0];
var len = (lb1 << 8) + lb2;
Debug.WriteLine(lb1 + "|" + lb2 + " ->| " + len);
var wp = new WorldPacket(await _reader.ReadBytesAsync(len), this);
Debug.WriteLine("INCOMING COM:" + wp.cmd + " SIZE:" + len);
switch (wp.cmd)
{
case WorldCommand.CMSG_AUTH_SESSION:
await HandleAuthSession(wp);
break;
case WorldCommand.CMSG_PING:
if (_status != AuthStatus.AUTHED) //Should not be pinging if not authed
{
Close();
}
else
{
HandlePing(wp);
}
break;
default:
if (_session == null || _status == AuthStatus.UNAUTHED) //Should not be sending anything else right now. Should also be authed by now
{
Close();
}
else
{
_session.HandlePacket(wp);
}
break;
}
}
}
public static async Task <bool> IsL33TZipAsync(Stream stream, CancellationToken ct = default)
{
var oldPosition = stream.Position;
try
{
using var reader = new AsyncBinaryReader(stream, new UTF8Encoding(), true);
var fileHeader = new string(await reader.ReadCharsAsync(4, ct));
switch (fileHeader.ToLower())
{
case L33THeader:
case L66THeader:
break;
default:
throw new InvalidOperationException($"Header '{fileHeader}' is not recognized as a valid type");
}
return(true);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception)
{
return(false);
}
#pragma warning restore CA1031 // Do not catch general exception types
finally
{
stream.Position = oldPosition;
}
}
private async Task <List <object> > DeserializeCollectionAsync(BoundedStream stream, EventShuttle eventShuttle,
CancellationToken cancellationToken)
{
var list = new List <object>();
/* Create single serializer to do all the work */
var childSerializer = (ValueValueNode)CreateChildSerializer();
var childSerializedType = childSerializer.TypeNode.GetSerializedType();
var terminationValue = GetTerminationValue();
var terminationChild = GetTerminationChild();
var itemLength = GetFieldItemLength();
var reader = new AsyncBinaryReader(stream, GetFieldEncoding());
var count = GetFieldCount() ?? long.MaxValue;
for (long i = 0; i < count && !EndOfStream(stream); i++)
{
if (IsTerminated(stream, terminationChild, terminationValue, eventShuttle))
{
break;
}
await childSerializer.DeserializeAsync(reader, childSerializedType, itemLength, cancellationToken)
.ConfigureAwait(false);
var value = childSerializer.GetValue(childSerializedType);
list.Add(value);
}
return(list);
}
private async Task DrainReceivingContexts(AsyncBinaryReader binaryReader)
{
while (!(this.receivingContexts.IsEmpty && this.requestQueue.Count == 0))
{
byte[] frameHeaderBytes = await binaryReader.ReadBytesAsync(20).ConfigureAwait(false);
if (frameHeaderBytes.Length < 20)
{
throw new IOException("Socket closed during reading.");
}
var frameHeader = FrameHeader.Parse(frameHeaderBytes);
if (frameHeader.ContentOffset != 20)
{
this.logger.LogCritical(
"Invalid frame header with unexpected content offset, expected=20 actual={0}",
frameHeader.ContentOffset);
throw new InvalidDataException("Invalid frame header");
}
if (frameHeader.Version != 1)
{
this.logger.LogWarning(
"Invalid frame header with unexpected version {0}",
frameHeader.Version);
throw new InvalidDataException("Invalid frame header");
}
byte[] framePayloadBytes = await binaryReader
.ReadBytesAsync(frameHeader.ContentLength)
.ConfigureAwait(false);
if (framePayloadBytes.Length < frameHeader.ContentLength)
{
throw new IOException("Socket closed during reading.");
}
if (this.logger.IsEnabled(LogLevel.Debug))
{
var buffer = new byte[frameHeaderBytes.Length + framePayloadBytes.Length];
Buffer.BlockCopy(frameHeaderBytes, 0, buffer, 0, frameHeaderBytes.Length);
Buffer.BlockCopy(framePayloadBytes, 0, buffer, frameHeaderBytes.Length, framePayloadBytes.Length);
this.logger.LogDebug(
"Received streamId={0}:" + Environment.NewLine + "{1}",
frameHeader.StreamId,
HexUtils.Dump(buffer.AsMemory()));
}
if (this.receivingContexts.TryRemove((int)frameHeader.StreamId, out RequestContext requestContext))
{
this.Process(requestContext, frameHeader, framePayloadBytes);
}
else
{
this.logger.LogWarning("Dropped a frame with unexpected streamId {0}", frameHeader.StreamId);
}
}
}
public async Task The_ReadAsync_Method_Throws_When_Length_Is_Negative()
{
var reader = new AsyncBinaryReader(new MemoryStream());
await Assert.ThrowsAsync <ArgumentException>(async() =>
{
await reader.ReadAsync(-1);
});
}
public async Task TestReaderCancellation(Func <AsyncBinaryReader, CancellationToken, Task> f)
{
using (var cts = new CancellationTokenSource())
{
var ct = cts.Token;
var reader = new AsyncBinaryReader(new SlowStream());
cts.Cancel();
await Assert.ThrowsAsync <TaskCanceledException>(() => f(reader, ct));
}
}
/// <exception cref="InvalidDataException"></exception>
private static async Task <int> ReadAssertAsync(this AsyncBinaryReader br, int expected)
{
int x = await br.ReadInt32Async();
if (x != expected)
{
throw new InvalidDataException("The remote sent an unexpected result.");
}
return(x);
}
public void SetClient(TcpClient client)
{
_client = client;
_client.ReceiveTimeout = 1000;
var stream = _client.GetStream();
_reader = new AsyncBinaryReader(stream);
_writer = new AuthWriter(stream);
}
public async Task The_ReadAsync_Method_Works()
{
var expected = Encoding.UTF8.GetBytes("123456");
var stream = new MemoryStream(expected);
var reader = new AsyncBinaryReader(stream);
var actual = await reader.ReadAsync(expected.Length);
Assert.Equal(expected, actual);
}
public async Task The_ReadValueAsync_Method_Works(bool zeroTerminated)
{
var expected = "123456";
var stream = new MemoryStream(Encoding.UTF8.GetBytes(expected));
var reader = new AsyncBinaryReader(stream);
var value = new StringPalmValue(expected.Length, Encoding.UTF8, zeroTerminated);
var actual = await value.ReadValueAsync(reader);
Assert.Equal(expected, actual);
}
public async Task When_reading_bytes_from_a_stream_that_is_too_short()
{
var sut = new AsyncBinaryReader(new TestStream(
0, 1, 2, 3, 4, 5
));
await Assert.ThrowsAsync<EndOfStreamException>(async () =>
{
await sut.ReadBytesAsync(10, CancellationToken.None);
});
}
public async Task When_reading_bytes()
{
var sut = new AsyncBinaryReader(new TestStream(
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
));
var ba = await sut.ReadBytesAsync(10, CancellationToken.None);
Assert.Equal(10, ba.Length);
for (var i = 0; i < 10; i++)
Assert.Equal(i, ba[i]);
}
async Task <TResponse> AsyncCallAsync <TRequest, TResponse>(
Method <TRequest, TResponse> method, TRequest request)
{
await pipeLock.WaitAsync();
PipePair pipePair;
availablePipePairs.TryTake(out pipePair);
Debug.Assert(pipePair != null);
try
{
var writer = new AsyncBinaryWriter(pipePair.OutPipe);
var reader = new AsyncBinaryReader(pipePair.InPipe);
// Send the RPC name.
await writer.WriteAsync(method.FullName.Length);
await writer.WriteAsync(Encoding.ASCII.GetBytes(method.FullName));
// Send the request.
using (var serializationContext = new SimpleSerializationContext())
{
method.RequestMarshaller.ContextualSerializer(request, serializationContext);
byte[] requestBytes = serializationContext.GetPayload();
await writer.WriteAsync(requestBytes.Length);
await writer.WriteAsync(requestBytes);
}
// Read the response.
int size = await reader.ReadInt32Async();
byte[] responseBytes = await reader.ReadBytesAsync(size);
var deserializationContext = new SimpleDeserializationContext(responseBytes);
return(method.ResponseMarshaller.ContextualDeserializer(deserializationContext));
}
// Unfortunately, RpcExceptions can't be nested with InnerException.
catch (EndOfStreamException e)
{
throw new RpcException(new Status(StatusCode.Unknown, e.ToString()),
"Connection to server lost. Did it shut down?");
}
catch (Exception e) when(!(e is RpcException))
{
throw new RpcException(new Status(StatusCode.Unknown, e.ToString()),
"Unknown failure: " + e);
}
finally
{
availablePipePairs.Add(pipePair);
pipeLock.Release();
}
}
public async Task When_reading_negative_amounts_of_bytes()
{
var sut = new AsyncBinaryReader(new TestStream(
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
));
await Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () =>
{
await sut.ReadBytesAsync(-1, CancellationToken.None);
});
}
// ReSharper disable once InconsistentNaming
public async void ReadCharAsyncUTF16Test()
{
var encoding = System.Text.Encoding.Unicode;
var expected = 'ش';
var data = encoding.GetBytes(expected.ToString());
var stream = new MemoryStream(data);
var boundedStream = new BoundedStream(stream, string.Empty);
var reader = new AsyncBinaryReader(boundedStream, encoding);
var actual = await reader.ReadCharAsync(CancellationToken.None);
Assert.Equal(expected, actual);
}
public async Task RunAsync(TcpClient client)
{
Debug.WriteLine("New Connection");
_client = client;
_client.ReceiveTimeout = 1000;
_clientStream = _client.GetStream();
_reader = new AsyncBinaryReader(_clientStream);
while (_run && _clientStream.CanRead)
{
var cmd = (AuthCommand)await _reader.ReadUInt8Async();
_currentCommand = cmd;
Debug.WriteLine("OPCODE " + cmd + " received");
switch (cmd)
{
case AuthCommand.LogonChallenge:
await HandleLogonChallengeAsync();
break;
case AuthCommand.LogonProof:
await HandleLogonProofAsync();
break;
case AuthCommand.RealmList:
await HandleRealmListAsync();
break;
case AuthCommand.ReconnectChallenge:
await HandleReconnectChallengeAsync();
break;
case AuthCommand.ReconnectProof:
await HandleReconnectProofAsync();
break;
default:
Debug.WriteLine($"Unhandled opcode {cmd} (0x{cmd:X})");
await CloseAsync(AuthStatus.Unimplemented);
break;
}
}
}
public async Task The_ReadValueAsync_Method_Reads_Until_First_Zero()
{
var expected = "123456";
var bytes = Encoding.UTF8.GetBytes(expected);
Array.Resize(ref bytes, 10);
var stream = new MemoryStream(bytes);
var reader = new AsyncBinaryReader(stream);
var value = new StringPalmValue(bytes.Length, Encoding.UTF8, true);
var actual = await value.ReadValueAsync(reader);
Assert.Equal(expected, actual);
}
public async Task Test(object value, Action<BinaryWriter, object> writeFunc, Func<AsyncBinaryReader, Task<object>> readFunc, Encoding encoding = null)
{
encoding = encoding ?? Encoding.UTF8;
var stream = new MemoryStream();
var writer = new BinaryWriter(stream, encoding);
writeFunc(writer, value);
writer.Flush();
stream.Position = 0;
var reader = new AsyncBinaryReader(stream, encoding);
var result = await readFunc(reader);
Assert.Equal(value, result);
}
public static async Task<ISymbolMetadata> TryOpenAsync(Stream stream, CancellationToken cancellationToken)
{
using (var reader = new AsyncBinaryReader(stream))
{
try
{
var IMAGE_DOS_HEADER_e_magic = await reader.ReadBytesAsync(_mzHeader.Length, cancellationToken);
if (!NativeMethods.MemoryEquals(IMAGE_DOS_HEADER_e_magic, _mzHeader)) return null;
stream.Position = 60;
var IMAGE_DOS_HEADER_e_lfanew = await reader.ReadUInt32Async(cancellationToken);
stream.Position = IMAGE_DOS_HEADER_e_lfanew;
var PE_Signature = await reader.ReadBytesAsync(_peHeader.Length, cancellationToken);
if (!NativeMethods.MemoryEquals(PE_Signature, _peHeader)) return null;
stream.Position = IMAGE_DOS_HEADER_e_lfanew + 4;
var IMAGE_FILE_HEADER_Machine = await reader.ReadUInt16Async(cancellationToken);
if (IMAGE_FILE_HEADER_Machine != 0x014c &&
IMAGE_FILE_HEADER_Machine != 0x0200 &&
IMAGE_FILE_HEADER_Machine != 0x8664)
return null;
stream.Position = IMAGE_DOS_HEADER_e_lfanew + 8;
var IMAGE_FILE_HEADER_TimeDateStamp = await reader.ReadUInt32Async(cancellationToken);
stream.Position = IMAGE_DOS_HEADER_e_lfanew + 24;
var IMAGE_OPTIONAL_HEADER_Magic = await reader.ReadUInt16Async(cancellationToken);
if (IMAGE_OPTIONAL_HEADER_Magic != 0x10b &&
IMAGE_OPTIONAL_HEADER_Magic != 0x20b)
return null;
stream.Position = IMAGE_DOS_HEADER_e_lfanew + 80;
var IMAGE_OPTIONAL_HEADER_SizeOfImage = await reader.ReadUInt16Async(cancellationToken);
return new MZMetadata(string.Format(
CultureInfo.InvariantCulture,
"{0:X8}{1:x4}",
IMAGE_FILE_HEADER_TimeDateStamp,
IMAGE_OPTIONAL_HEADER_SizeOfImage));
}
catch
{
return null;
}
}
}
public async Task When_reading_a_structure_from_a_stream_that_is_too_short()
{
var sut = new AsyncBinaryReader(new TestStream(
0, 0, 0, 0,
1, 0, 0, 0,
2, 0, 0, 0,
3, 0, 0, 0,
4, 0, 0, 0
));
await Assert.ThrowsAsync<EndOfStreamException>(async () =>
{
await sut.ReadStructureAsync<Symblr.Symbols.Pdb70.Pdb70Header>(CancellationToken.None);
});
}
private static async Task <TcpClient> StartPlcAsync(ILogger logger, string hostname, int port)
{
var fakePlc = new TcpClient(hostname, port);
logger.LogInformation("Fake PLC connected.");
NetworkStream networkStream = fakePlc.GetStream();
using var reader = new AsyncBinaryReader(networkStream, Encoding.ASCII, true);
using var writer = new AsyncBinaryWriter(networkStream, Encoding.ASCII, true);
logger.LogDebug("Receiving TestRequest frame...");
byte[] receivedBytes = await reader.ReadBytesAsync(0x53).ConfigureAwait(false);
logger.LogInformation("Received {0} bytes.", 0x53);
byte[] sendingPayload = new UnifiedFrameContent
{
Header = new Header {
Status = 0
},
Payload = new TestResponse
{
A = 42,
B = 3.1415926F,
C = "Hello World!",
D = Timestamp.FromDateTimeOffset(DateTimeOffset.Parse("2019-10-29T21:42:13.00000+8:00", CultureInfo.InvariantCulture)),
}.ToByteString(),
}.ToByteArray();
var sendingHeader = new FrameHeader(
version: 1,
type: 2,
sequenceNumber: 0,
streamId: 1,
contentOffset: 20,
contentLength: (ushort)sendingPayload.Length,
contentChecksum: Crc32C.Crc32CAlgorithm.Compute(sendingPayload));
logger.LogDebug("Sending TestResponse frame header...");
await sendingHeader.WriteTo(writer).ConfigureAwait(false);
logger.LogDebug("Sending TestResponse frame body...");
await writer.WriteAsync(sendingPayload).ConfigureAwait(false);
logger.LogInformation("Sent TestResponse.");
return(fakePlc);
}
public IntegrityTestFixture()
{
// create the server
var server = new WsServer();
server.StartAsync(new IPEndPoint(IPAddress.Loopback, 0), async stream =>
{
Server = stream;
}).GetAwaiter().GetResult();
// start client
var client = new WsClient();
Client = client.ConnectAsync(new Uri("ws://" + server.ListeningAddresses[0].Substring(7))).GetAwaiter().GetResult();
Thread.Sleep(1000);
Reader = new AsyncBinaryReader(Client);
Writer = new AsyncBinaryWriter(Server);
}
private async Task ConnectAsync(Action <BinaryWriter> writeAddress, int port)
{
await _tcpClient.ConnectAsync(_proxyServer.Address, _proxyServer.Port);
_sslStream = new SslStream(_tcpClient.GetStream());
await _sslStream.AuthenticateAsClientAsync(_domain);
if (_protocolType == ClientProtocolType.Udp)
{
_udpReader = new AsyncBinaryReader(new BufferedStream(_sslStream), Encoding.UTF8);
}
// +-----------------------+---------+----------------+---------+
// | hex(SHA224(password)) | CRLF | Trojan Request | CRLF |
// +-----------------------+---------+----------------+---------+
// | 56 | X'0D0A' | Variable | X'0D0A' |
// +-----------------------+---------+----------------+---------+
//
// where Trojan Request is a SOCKS5 - like request:
//
// +-----+------+----------+----------+
// | CMD | ATYP | DST.ADDR | DST.PORT |
// +-----+------+----------+----------+
// | 1 | 1 | Variable | 2 |
// +-----+------+----------+----------+
using (var stream = new MemoryStream(256))
using (var writer = new BinaryWriter(stream)) {
writer.Write(_passwordHash);
writer.Write(CRLF);
writer.Write((byte)(IsTcp ? Command.Connect : Command.UdpAssociate));
// write IP address or hostname
writeAddress(writer);
writer.Write(IPAddress.HostToNetworkOrder((short)port));
writer.Write(CRLF);
// it always true because we use MemoryStream(int capacity) constructor
stream.TryGetBuffer(out var buffer);
await _sslStream.WriteAsync(buffer.Array, buffer.Offset, buffer.Count);
}
}
public async Task When_reading_a_structure()
{
var sut = new AsyncBinaryReader(new TestStream(
0, 0, 0, 0,
1, 0, 0, 0,
2, 0, 0, 0,
3, 0, 0, 0,
4, 0, 0, 0,
5, 0, 0, 0
));
var str = await sut.ReadStructureAsync<Symblr.Symbols.Pdb70.Pdb70Header>(CancellationToken.None);
Assert.Equal(0, str.PageSize);
Assert.Equal(1, str.BitmapPage);
Assert.Equal(2, str.PageCount);
Assert.Equal(3, str.IndexBytes);
Assert.Equal(4, str.Reserved);
Assert.Equal(5, str.IndexPage);
}
private async void BackgroundReceivingTaskEntryPoint()
{
try
{
using var binaryReader = new AsyncBinaryReader(this.client.GetStream(), Encoding.ASCII, true);
while (!this.stoppedEvent.WaitOne(1000))
{
await this.DrainReceivingContexts(binaryReader).ConfigureAwait(false);
}
await this.DrainReceivingContexts(binaryReader).ConfigureAwait(false);
}
catch (IOException e)
{
this.logger.LogError(e, "Error when receiving data from {0}", this.remoteEndPoint);
this.client.Close();
this.ConnectionClosed?.Invoke(this, new EventArgs());
}
}
private async Task <DownloadResponse> DownloadDataTaskAsync()
{
cancellationToken.ThrowIfCancellationRequested();
Logger.Info(
$"{request.StreamType}: Segment: {SegmentId(request.SegmentId)} Requested. URL: {request.DownloadSegment.Url} Range: {downloadRange}");
using (var httpRequest = CreateHttpRequest())
{
var watch = Stopwatch.StartNew();
long totalBytesReceived = 0;
try
{
using (var response = await client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead,
cancellationToken))
{
StatusCode = response.StatusCode;
response.EnsureSuccessStatusCode();
using (var stream = await response.Content.ReadAsStreamAsync())
using (var reader = new AsyncBinaryReader(stream))
{
byte[] buffer;
do
{
buffer = await ReadChunk(reader);
PushChunk(buffer);
totalBytesReceived += buffer.Length;
} while (buffer.Length != 0);
return(CreateDownloadResponse());
}
}
}
finally
{
throughputHistory.Push((int)totalBytesReceived, watch.Elapsed);
}
}
}
public async Task ValidateReadWriteStatistics()
{
InterceptData clientData = null, serverData = null;
var server = new WsServer();
await server.StartAsync(new IPEndPoint(IPAddress.Loopback, 0), async stream =>
{
await stream.WrapSocketAsync(x =>
Task.FromResult <WStreamSocket>(new Interceptor(x, out serverData))
);
var abr = new AsyncBinaryReader(stream);
for (int i = 0; i < 100000; i++)
{
Assert.Equal(i, await abr.ReadInt32Async());
}
await stream.CloseAsync();
});
var client = new WsClient();
var connection = await client.ConnectAsync(new Uri("ws://" + server.ListeningAddresses[0].Substring(7)));
await connection.WrapSocketAsync(x =>
Task.FromResult <WStreamSocket>(new Interceptor(x, out clientData))
);
var abw = new AsyncBinaryWriter(connection);
for (int i = 0; i < 100000; i++)
{
await abw.WriteAsync(i);
}
await abw.FlushAsync();
await Task.Delay(1000);
Assert.Equal(4 * 100000, clientData.BytesWritten);
Assert.Equal(4 * 100000, serverData.BytesRead);
client.Dispose();
server.Dispose();
}
public static async Task DecompressL33TZipAsync(
Stream inputStream,
Stream outputStream,
IProgress <double> progress = null,
CancellationToken ct = default)
{
//Get extracted content length
long fileLength;
using (var reader = new AsyncBinaryReader(inputStream, new UTF8Encoding(), true))
{
var fileHeader = new string(await reader.ReadCharsAsync(4, ct));
switch (fileHeader.ToLower())
{
case L33THeader:
fileLength = await reader.ReadInt32Async(ct);
break;
case L66THeader:
fileLength = await reader.ReadInt64Async(ct);
break;
default:
throw new InvalidOperationException($"Header '{fileHeader}' is not recognized as a valid type");
}
//Skip deflate specification (2 Byte)
reader.BaseStream.Position += 2;
}
//Extract content
var buffer = new byte[BufferSize];
int bytesRead;
var totalBytesRead = 0L;
var lastProgress = 0d;
using var compressedStream = new DeflateStream(inputStream, CompressionMode.Decompress);
while ((bytesRead = await compressedStream.ReadAsync(buffer, 0, buffer.Length, ct)) > 0)
{
ct.ThrowIfCancellationRequested();
if (bytesRead > fileLength)
{
totalBytesRead += fileLength;
await outputStream.WriteAsync(buffer, 0, (int)fileLength, ct);
}
else if (totalBytesRead + bytesRead <= fileLength)
{
totalBytesRead += bytesRead;
await outputStream.WriteAsync(buffer, 0, bytesRead, ct);
}
else if (totalBytesRead + bytesRead > fileLength)
{
var leftToRead = fileLength - totalBytesRead;
totalBytesRead += leftToRead;
await outputStream.WriteAsync(buffer, 0, (int)leftToRead, ct);
}
var newProgress = (double)totalBytesRead / fileLength * 100;
if (newProgress - lastProgress > 1)
{
progress?.Report(newProgress);
lastProgress = newProgress;
}
if (totalBytesRead >= fileLength)
{
break;
}
}
}
public PixelReader16(AsyncBinaryReader reader, Framebuffer framebuffer) : base(reader, framebuffer)
{
}
/// <summary>
/// Asynchronously reads a bit set from the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A <see cref="Task{Pdb20BitSet}"/> that represents the asynchronous read operation.
/// </returns>
public static async Task<Pdb70BitSet> ReadAsync(AsyncBinaryReader reader, CancellationToken cancellationToken)
{
var result = new Pdb70BitSet(await reader.ReadInt32Async(cancellationToken));
if (result.Words.Length != 0)
{
var bytes = await reader.ReadBytesAsync(result.Words.Length * sizeof(int), cancellationToken);
Buffer.BlockCopy(bytes, 0, result.Words, 0, bytes.Length);
}
return result;
}
public ZRLECompressedReader(Stream uncompressedStream) : base(uncompressedStream)
{
zlibMemoryStream = new MemoryStream();
zlibDecompressedStream = new ZOutputStream(zlibMemoryStream);
uncompressedReader = new AsyncBinaryReader(zlibMemoryStream);
}
public async Task When_reading_a_bit_set()
{
var reader = new AsyncBinaryReader(new TestStream(
2, 0, 0, 0,
1, 0, 0, 0,
0, 1, 0, 0
));
var sut = await Pdb70BitSet.ReadAsync(reader, CancellationToken.None);
Assert.Equal(2, sut.Words.Length);
Assert.True(sut[0x0]);
Assert.True(sut[0x28]);
Assert.False(sut[0x1]);
}
protected PixelReader(AsyncBinaryReader reader, Framebuffer framebuffer)
{
this.reader = reader;
this.framebuffer = framebuffer;
}
public async Task When_reading_an_Int16_from_a_stream_that_is_too_short()
{
var sut = new AsyncBinaryReader(new TestStream(
1
));
await Assert.ThrowsAsync<EndOfStreamException>(async () =>
{
await sut.ReadInt16Async(CancellationToken.None);
});
}
public async Task When_reading_an_Int32()
{
var sut = new AsyncBinaryReader(new TestStream(
1, 0, 0, 0
));
var i = await sut.ReadInt32Async(CancellationToken.None);
Assert.Equal(1, i);
}
public static async Task <IpcMessageResult> ReadAsync(Stream stream,
byte[] messageHeader, ISharedArrayPool sharedArrayPool)
{
/*
* UInt16 Message Header Length 消息头的长度
* byte[] Message Header 消息头的内容
* UInt32 Version 当前IPC服务的版本
* UInt64 Ack 用于给对方确认收到消息使用
* UInt32 Empty 给以后版本使用的值
* UInt16 Command Type 命令类型，业务端的值将会是 0 而框架层采用其他值
* UInt32 Content Length 这条消息的内容长度
* byte[] Content 实际的内容
*/
if (!await GetHeader(stream, messageHeader, sharedArrayPool))
{
// 消息不对，忽略
return(new IpcMessageResult("Message Header no match"));
}
var binaryReader = new AsyncBinaryReader(stream);
// UInt32 Version 当前IPC服务的版本
var version = await binaryReader.ReadUInt32Async();
Debug.Assert(version == 1);
if (version == 0)
{
// 这是上个版本的，但是不兼容了
return(new IpcMessageResult("收到版本为 0 的旧版本消息，但是不兼容此版本"));
}
// UInt64 Ack 用于给对方确认收到消息使用
var ack = await binaryReader.ReadReadUInt64Async();
// UInt32 Empty 给以后版本使用的值
var empty = await binaryReader.ReadUInt32Async();
Debug.Assert(empty == 0);
// UInt16 Command Type 命令类型，业务端的值将会是大于 0 而框架层采用其他值
var commandType = (IpcMessageCommandType)await binaryReader.ReadUInt16Async();
// UInt32 Content Length 这条消息的内容长度
var messageLength = await binaryReader.ReadUInt32Async();
if (messageLength > IpcConfiguration.MaxMessageLength)
{
// 太长了
return(new IpcMessageResult(
$"Message Length too long MessageLength={messageLength} MaxMessageLength={IpcConfiguration.MaxMessageLength}. {DebugContext.OverMaxMessageLength}"));
}
var messageBuffer = sharedArrayPool.Rent((int)messageLength);
// byte[] Content 实际的内容
var readCount = await ReadBufferAsync(stream, messageBuffer, (int)messageLength);
Debug.Assert(readCount == messageLength);
var ipcMessageContext = new IpcMessageContext(ack, messageBuffer, messageLength, sharedArrayPool);
return(new IpcMessageResult(success: true, ipcMessageContext, commandType));
}
public async Task TestAsyncBinaryReader()
{
byte customByte = 39;
bool customBool = Unsafe.As <byte, bool>(ref customByte);
object[] expectedResults =
{
true,
false,
customBool,
(byte)42,
(sbyte)-28,
(short)-279,
(ushort)64221,
(int)-288888,
(uint)3310229011,
(float)3811.55f,
(long)-19195205991011,
(ulong)11223372036854775807,
(double)Math.PI,
(decimal)295222.2811m
};
using (var ms = new MemoryStream())
{
using (var wr = new BinaryWriter(ms, Encoding.Default, leaveOpen: true))
{
foreach (dynamic obj in expectedResults)
{
wr.Write(obj);
}
}
ms.Position = 0;
using (var rd = new AsyncBinaryReader(ms, Encoding.Default, leaveOpen: true))
{
foreach (var obj in expectedResults)
{
switch (obj)
{
case bool b8:
////Assert.Equal(b8, await rd.ReadBooleanAsync());
if (b8)
{
Assert.True(await rd.ReadBooleanAsync());
}
else
{
Assert.False(await rd.ReadBooleanAsync());
}
break;
case byte u8:
Assert.Equal(u8, await rd.ReadByteAsync());
break;
case sbyte s8:
Assert.Equal(s8, await rd.ReadSByteAsync());
break;
case short s16:
Assert.Equal(s16, await rd.ReadInt16Async());
break;
case ushort u16:
Assert.Equal(u16, await rd.ReadUInt16Async());
break;
case int s32:
Assert.Equal(s32, await rd.ReadInt32Async());
break;
case uint u32:
Assert.Equal(u32, await rd.ReadUInt32Async());
break;
case long s64:
Assert.Equal(s64, await rd.ReadInt64Async());
break;
case ulong u64:
Assert.Equal(u64, await rd.ReadUInt64Async());
break;
case float f32:
Assert.Equal(f32, await rd.ReadSingleAsync());
break;
case double f64:
Assert.Equal(f64, await rd.ReadDoubleAsync());
break;
case decimal d128:
Assert.Equal(d128, await rd.ReadDecimalAsync());
break;
}
}
}
}
}
/// <summary>
/// Reads a <see cref="PalmDatabase"/> from the specified <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The stream to read the database from.</param>
public static async Task <PalmDatabase> ReadAsync(Stream stream)
{
Guard.NotNull(stream, nameof(stream));
Guard.Not(stream.CanSeek == false, nameof(stream.CanSeek));
Guard.Not(stream.CanRead == false, nameof(stream.CanRead));
var database = new PalmDatabase();
var reader = new AsyncBinaryReader(stream);
var nameValue = new StringPalmValue(32, Encoding.UTF8, zeroTerminated: true);
database.Name = await nameValue.ReadValueAsync(reader);
var attributesValue = new EnumPalmValue <PalmDatabaseAttributes>(2);
database.Attributes = await attributesValue.ReadValueAsync(reader);
var versionValue = new UIntPalmValue(2);
database.Version = (short)await versionValue.ReadValueAsync(reader);
var creationDateValue = new DateTimeOffsetPalmValue();
database.CreationDate = await creationDateValue.ReadValueAsync(reader);
var modificationDateValue = new DateTimeOffsetPalmValue();
database.ModificationDate = await modificationDateValue.ReadValueAsync(reader);
var lastBackupDateValue = new DateTimeOffsetPalmValue();
database.LastBackupDate = await lastBackupDateValue.ReadValueAsync(reader);
var modificationNumberValue = new UIntPalmValue(4);
database.ModificationNumber = await modificationNumberValue.ReadValueAsync(reader);
var appInfoIdValue = new UIntPalmValue(4);
var appInfoOffset = await appInfoIdValue.ReadValueAsync(reader);
var sortInfoIdValue = new UIntPalmValue(4);
var sortInfoOffset = await sortInfoIdValue.ReadValueAsync(reader);
var typeValue = new StringPalmValue(4, Encoding.UTF8, zeroTerminated: false);
database.Type = await typeValue.ReadValueAsync(reader);
var creatorValue = new StringPalmValue(4, Encoding.UTF8, zeroTerminated: false);
database.Creator = await creatorValue.ReadValueAsync(reader);
var uniqueIdSeedValue = new UIntPalmValue(4);
database.UniqueIdSeed = await uniqueIdSeedValue.ReadValueAsync(reader);
var nextRecordListIdValue = new UIntPalmValue(4);
database.NextRecordListId = await nextRecordListIdValue.ReadValueAsync(reader);
uint numberOfRecords = await new UIntPalmValue(2).ReadValueAsync(reader);
var recordAndDataOffsets = new List <Tuple <PalmDatabaseRecord, uint> >();
//Read the records
for (int i = 0; i < numberOfRecords; i++)
{
var recordDataOffset = await new UIntPalmValue(4).ReadValueAsync(reader);
var recordAttribute = await new ByteArrayPalmValue(1).ReadValueAsync(reader);
var uniqueId = await new UIntPalmValue(3).ReadValueAsync(reader);
var record = new PalmDatabaseRecord
{
UniqueId = uniqueId,
Attributes = recordAttribute[0],
};
recordAndDataOffsets.Add(Tuple.Create(record, recordDataOffset));
}
//Read appInfo and sortInfo
var offsets = new List <uint>
{
appInfoOffset,
sortInfoOffset,
recordAndDataOffsets.Any() ? recordAndDataOffsets[0].Item2 : (uint)reader.Stream.Length
};
offsets = offsets
.Where(f => f > 0)
.OrderBy(f => f)
.ToList();
for (int i = 0; i < offsets.Count - 1; i++)
{
var startOffset = offsets[i];
var endOffset = offsets[i + 1];
reader.Stream.Seek(startOffset, SeekOrigin.Begin);
var data = await new ByteArrayPalmValue((int)(endOffset - startOffset)).ReadValueAsync(reader);
if (startOffset == appInfoOffset)
{
database.AppInfo = data;
}
else if (startOffset == sortInfoOffset)
{
database.SortInfo = data;
}
}
if (database.AppInfo == null)
{
database.AppInfo = new byte[0];
}
if (database.SortInfo == null)
{
database.SortInfo = new byte[0];
}
//Fill all records with their content
for (int i = 0; i < numberOfRecords; i++)
{
var currentRecord = recordAndDataOffsets[i];
var nextRecord = i == numberOfRecords - 1 ? null : recordAndDataOffsets[i + 1];
var startOffset = currentRecord.Item2;
var nextStartOffset = nextRecord?.Item2 ?? (uint)reader.Stream.Length;
reader.Stream.Seek(startOffset, SeekOrigin.Begin);
var data = await new ByteArrayPalmValue((int)(nextStartOffset - startOffset)).ReadValueAsync(reader);
currentRecord.Item1.Data = data;
}
database.Records = recordAndDataOffsets
.Select(f => f.Item1)
.ToList();
return(database);
}
private Task <byte[]> ReadChunk(AsyncBinaryReader reader)
{
return(reader.ReadBytesAsync(ChunkSize, cancellationToken));
}
