// If more than just the lifetime event is sent over the rx pipe then // the pipe reading will need to be moved elsewhere so it can be shared // with other systems. private async Task HandleLifetimeEvents() { var headerBuffer = new byte[1 + 255 + 4]; // max header size while (true) { await rxPipe.ReadAsync(headerBuffer, 0, 1); if (headerBuffer[0] != 1) { throw new InvalidDataException("Unknown protocol"); } await rxPipe.ReadAsync(headerBuffer, 1, 1); await rxPipe.ReadAsync(headerBuffer, 2, headerBuffer[1]); var msgType = Encoding.UTF8.GetString(headerBuffer, 2, headerBuffer[1]); await rxPipe.ReadAsync(headerBuffer, 2 + headerBuffer[1], 4); var payloadSize = ReadUInt32LE(headerBuffer, 2 + headerBuffer[1]); var payload = new byte[payloadSize]; await rxPipe.ReadAsync(payload, 0, (int)payloadSize); if (msgType == "lifetimeevent") { switch (payload[0]) { // Startup event case 0: await App.Current.Dispatcher.InvokeAsync(() => { CurrentStatus = statusMessages[payload[1]]; }); break; // Startup completed case 1: // TODO: hide main window await App.Current.Dispatcher.InvokeAsync(() => { CurrentStatus = "Startup finished"; App.Current.LaunchPaymetheus(); }); break; // Shutdown event case 2: await App.Current.Dispatcher.InvokeAsync(() => { CurrentStatus = statusMessages[3 + payload[1]]; }); break; } } } }
public async static void ServerReadAsyncNegativeOffsetThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { await Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => server.ReadAsync(new byte[5], -1, 1)); // array is checked first await Assert.ThrowsAsync <ArgumentNullException>(() => server.ReadAsync(null, -1, 1)); } }
public async Task <byte[]> ReadBytesAsync(int size) { byte[] bytes = new byte[size]; await pipe.ReadAsync(bytes, 0, bytes.Length); return(bytes); }
public async static void ServerWriteOnlyAsyncThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { await Assert.ThrowsAsync <NotSupportedException>(() => server.ReadAsync(new byte[5], 0, 5)); } }
public async static void ServerReadAsyncBufferNullThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { await Assert.ThrowsAsync <ArgumentNullException>(() => server.ReadAsync(null, 0, 1)); } }
public static void ServerReadBufferNullThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Assert.Throws <ArgumentNullException>(() => server.Read(null, 0, 1)); Assert.Throws <ArgumentNullException>(() => NotReachable(server.ReadAsync(null, 0, 1))); } }
public static void ServerReadNegativeCountThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Assert.Throws <System.ArgumentOutOfRangeException>(() => server.Read(new byte[5], 0, -1)); // offset is checked before count Assert.Throws <ArgumentOutOfRangeException>(() => server.Read(new byte[1], -1, -1)); // array is checked first Assert.Throws <ArgumentNullException>(() => server.Read(null, -1, -1)); Assert.Throws <System.ArgumentOutOfRangeException>(() => NotReachable(server.ReadAsync(new byte[5], 0, -1))); // offset is checked before count Assert.Throws <ArgumentOutOfRangeException>(() => NotReachable(server.ReadAsync(new byte[1], -1, -1))); // array is checked first Assert.Throws <ArgumentNullException>(() => NotReachable(server.ReadAsync(null, -1, -1))); } }
public static void ServerWriteOnlyThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Assert.Throws <NotSupportedException>(() => server.Read(new byte[5], 0, 5)); Assert.Throws <NotSupportedException>(() => server.ReadByte()); Assert.Throws <NotSupportedException>(() => server.InBufferSize); Assert.Throws <NotSupportedException>(() => NotReachable(server.ReadAsync(new byte[5], 0, 5))); } }
private static async Task <DateTime> ReadDateTime(AnonymousPipeServerStream pipeServer) { var buffer = new byte[sizeof(long)]; var numbytes = await pipeServer.ReadAsync(buffer, 0, sizeof(long)).ConfigureAwait(false); // readasync ignores tokens :( if (numbytes < sizeof(long)) { throw new Exception("less than sizeof(long) bytes read"); } var nowLong = BitConverter.ToInt64(buffer, 0); var now = DateTime.FromBinary(nowLong); return(now); }
private static async Task AnonymousReaderAsync() { using (var reader = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable)) { WriteLine("Using anonymous pipe"); var pipeHandle = reader.GetClientHandleAsString(); WriteLine($"Pipe handle: {pipeHandle}"); const int bufferSize = 0x100; var buffer = new byte[bufferSize]; /*var nRead = */ await reader.ReadAsync(buffer, 0, bufferSize).ConfigureAwait(false); var line = Encoding.UTF8.GetString(buffer, 0, bufferSize); WriteLine(line); } }
public static void ServerPInvokeChecks() { // calling every API related to server and client to detect any bad PInvokes using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Task clientTask = Task.Run(() => StartClient(PipeDirection.In, server.ClientSafePipeHandle)); Assert.False(server.CanRead); Assert.False(server.CanSeek); Assert.False(server.CanTimeout); Assert.True(server.CanWrite); Assert.False(string.IsNullOrWhiteSpace(server.GetClientHandleAsString())); Assert.False(server.IsAsync); Assert.True(server.IsConnected); Assert.Equal(0, server.OutBufferSize); Assert.Equal(PipeTransmissionMode.Byte, server.ReadMode); Assert.NotNull(server.SafePipeHandle); Assert.Equal(PipeTransmissionMode.Byte, server.TransmissionMode); server.Write(new byte[] { 123 }, 0, 1); server.WriteAsync(new byte[] { 124 }, 0, 1).Wait(); server.Flush(); server.WaitForPipeDrain(); clientTask.Wait(); server.DisposeLocalCopyOfClientHandle(); } using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Task clientTask = Task.Run(() => StartClient(PipeDirection.Out, server.ClientSafePipeHandle)); Assert.Equal(4096, server.InBufferSize); byte[] readData = new byte[] { 0, 1 }; Assert.Equal(1, server.Read(readData, 0, 1)); Assert.Equal(1, server.ReadAsync(readData, 1, 1).Result); Assert.Equal(123, readData[0]); Assert.Equal(124, readData[1]); clientTask.Wait(); } }
public static void ServerReadArrayOutOfBoundsThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { // offset out of bounds Assert.Throws <ArgumentException>(null, () => server.Read(new byte[1], 1, 1)); // offset out of bounds for 0 count read Assert.Throws <ArgumentException>(null, () => server.Read(new byte[1], 2, 0)); // offset out of bounds even for 0 length buffer Assert.Throws <ArgumentException>(null, () => server.Read(new byte[0], 1, 0)); // combination offset and count out of bounds Assert.Throws <ArgumentException>(null, () => server.Read(new byte[2], 1, 2)); // edges Assert.Throws <ArgumentException>(null, () => server.Read(new byte[0], int.MaxValue, 0)); Assert.Throws <ArgumentException>(null, () => server.Read(new byte[0], int.MaxValue, int.MaxValue)); Assert.Throws <ArgumentException>(() => server.Read(new byte[5], 3, 4)); // offset out of bounds Assert.Throws <ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[1], 1, 1))); // offset out of bounds for 0 count read Assert.Throws <ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[1], 2, 0))); // offset out of bounds even for 0 length buffer Assert.Throws <ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[0], 1, 0))); // combination offset and count out of bounds Assert.Throws <ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[2], 1, 2))); // edges Assert.Throws <ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[0], int.MaxValue, 0))); Assert.Throws <ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[0], int.MaxValue, int.MaxValue))); Assert.Throws <ArgumentException>(() => NotReachable(server.ReadAsync(new byte[5], 3, 4))); } }
public static void ServerPInvokeChecks() { // calling every API related to server and client to detect any bad PInvokes using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Task clientTask = StartClientAsync(PipeDirection.In, server.ClientSafePipeHandle); Console.WriteLine("server.CanRead = {0}", server.CanRead); Console.WriteLine("server.CanSeek = {0}", server.CanSeek); Console.WriteLine("server.CanTimeout = {0}", server.CanTimeout); Console.WriteLine("server.CanWrite = {0}", server.CanWrite); Console.WriteLine("server.GetClientHandleAsString() = {0}", server.GetClientHandleAsString()); Console.WriteLine("server.IsAsync = {0}", server.IsAsync); Console.WriteLine("server.IsConnected = {0}", server.IsConnected); Console.WriteLine("server.OutBufferSize = {0}", server.OutBufferSize); Console.WriteLine("server.ReadMode = {0}", server.ReadMode); Console.WriteLine("server.SafePipeHandle = {0}", server.SafePipeHandle); Console.WriteLine("server.TransmissionMode = {0}", server.TransmissionMode); server.Write(new byte[] { 123 }, 0, 1); server.WriteAsync(new byte[] { 124 }, 0, 1).Wait(); server.Flush(); Console.WriteLine("Waiting for Pipe Drain."); server.WaitForPipeDrain(); clientTask.Wait(); server.DisposeLocalCopyOfClientHandle(); } using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Task clientTask = StartClientAsync(PipeDirection.Out, server.ClientSafePipeHandle); Console.WriteLine("server.InBufferSize = {0}", server.InBufferSize); byte[] readData = new byte[] { 0, 1 }; server.Read(readData, 0, 1); server.ReadAsync(readData, 1, 1).Wait(); Assert.Equal(123, readData[0]); Assert.Equal(124, readData[1]); } }
public static void ServerWriteOnlyThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Assert.Throws<NotSupportedException>(() => server.Read(new byte[5], 0, 5)); Assert.Throws<NotSupportedException>(() => server.ReadByte()); Assert.Throws<NotSupportedException>(() => server.InBufferSize); Assert.Throws<NotSupportedException>(() => NotReachable(server.ReadAsync(new byte[5], 0, 5))); } }
public static async Task ServerPInvokeChecks() { // calling every API related to server and client to detect any bad PInvokes using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None, 4096)) { Task clientTask = Task.Run(() => StartClient(PipeDirection.In, server.ClientSafePipeHandle)); Assert.False(server.CanRead); Assert.False(server.CanSeek); Assert.False(server.CanTimeout); Assert.True(server.CanWrite); Assert.False(string.IsNullOrWhiteSpace(server.GetClientHandleAsString())); Assert.False(server.IsAsync); Assert.True(server.IsConnected); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Assert.True(server.OutBufferSize > 0); } else { Assert.Throws <PlatformNotSupportedException>(() => server.OutBufferSize); } Assert.Equal(PipeTransmissionMode.Byte, server.ReadMode); Assert.NotNull(server.SafePipeHandle); Assert.Equal(PipeTransmissionMode.Byte, server.TransmissionMode); server.Write(new byte[] { 123 }, 0, 1); await server.WriteAsync(new byte[] { 124 }, 0, 1); server.Flush(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { server.WaitForPipeDrain(); } else { Assert.Throws <PlatformNotSupportedException>(() => server.WaitForPipeDrain()); } await clientTask; server.DisposeLocalCopyOfClientHandle(); } using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Task clientTask = Task.Run(() => StartClient(PipeDirection.Out, server.ClientSafePipeHandle)); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Assert.Equal(4096, server.InBufferSize); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Assert.True(server.InBufferSize > 0); } else { Assert.Throws <PlatformNotSupportedException>(() => server.InBufferSize); } byte[] readData = new byte[] { 0, 1 }; Assert.Equal(1, server.Read(readData, 0, 1)); Assert.Equal(1, server.ReadAsync(readData, 1, 1).Result); Assert.Equal(123, readData[0]); Assert.Equal(124, readData[1]); await clientTask; } }
public static void ServerReadArrayOutOfBoundsThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { // offset out of bounds Assert.Throws<ArgumentException>(null, () => server.Read(new byte[1], 1, 1)); // offset out of bounds for 0 count read Assert.Throws<ArgumentException>(null, () => server.Read(new byte[1], 2, 0)); // offset out of bounds even for 0 length buffer Assert.Throws<ArgumentException>(null, () => server.Read(new byte[0], 1, 0)); // combination offset and count out of bounds Assert.Throws<ArgumentException>(null, () => server.Read(new byte[2], 1, 2)); // edges Assert.Throws<ArgumentException>(null, () => server.Read(new byte[0], int.MaxValue, 0)); Assert.Throws<ArgumentException>(null, () => server.Read(new byte[0], int.MaxValue, int.MaxValue)); Assert.Throws<ArgumentException>(() => server.Read(new byte[5], 3, 4)); // offset out of bounds Assert.Throws<ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[1], 1, 1))); // offset out of bounds for 0 count read Assert.Throws<ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[1], 2, 0))); // offset out of bounds even for 0 length buffer Assert.Throws<ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[0], 1, 0))); // combination offset and count out of bounds Assert.Throws<ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[2], 1, 2))); // edges Assert.Throws<ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[0], int.MaxValue, 0))); Assert.Throws<ArgumentException>(null, () => NotReachable(server.ReadAsync(new byte[0], int.MaxValue, int.MaxValue))); Assert.Throws<ArgumentException>(() => NotReachable(server.ReadAsync(new byte[5], 3, 4))); } }
public static void ServerReadNegativeCountThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Assert.Throws<System.ArgumentOutOfRangeException>(() => server.Read(new byte[5], 0, -1)); // offset is checked before count Assert.Throws<ArgumentOutOfRangeException>(() => server.Read(new byte[1], -1, -1)); // array is checked first Assert.Throws<ArgumentNullException>(() => server.Read(null, -1, -1)); Assert.Throws<System.ArgumentOutOfRangeException>(() => NotReachable(server.ReadAsync(new byte[5], 0, -1))); // offset is checked before count Assert.Throws<ArgumentOutOfRangeException>(() => NotReachable(server.ReadAsync(new byte[1], -1, -1))); // array is checked first Assert.Throws<ArgumentNullException>(() => NotReachable(server.ReadAsync(null, -1, -1))); } }
public static void ServerReadBufferNullThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Assert.Throws<ArgumentNullException>(() => server.Read(null, 0, 1)); Assert.Throws<ArgumentNullException>(() => NotReachable(server.ReadAsync(null, 0, 1))); } }