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)); }