private static void AnonymousPipe(AnonymousPipeServerStream outPipe, AnonymousPipeServerStream inPipe) { var clientExePath = @"..\..\..\..\CStutorial\bin\Debug\CStutorial.exe"; var path = Path.GetFullPath(clientExePath); try { var outId = outPipe.GetClientHandleAsString(); var inId = inPipe.GetClientHandleAsString(); var command = string.Format("{0} {1}", outId, inId); var startInfo = new ProcessStartInfo(clientExePath, command); startInfo.UseShellExecute = false; Process?process = Process.Start(startInfo); outPipe.DisposeLocalCopyOfClientHandle(); inPipe.DisposeLocalCopyOfClientHandle(); for (int i = 0; i < 1000; i++) { var v = (byte)new Random().Next(0, 150); Console.WriteLine(v); outPipe.WriteByte(v); } process?.WaitForExit(); } catch (Exception exception) { Console.WriteLine(exception); } }
public static void Main(string[] args) { try { // Debug. Console.WriteLine("Anonymous Pipes Server Begin: {0}", System.DateTime.Now.ToString()); // Path to client executable. string clientPath = @"C:\Source\AV\CSharp\Streams\AnonymousPipes\AnonymousPipesClient.exe"; HandleInheritability inherit = HandleInheritability.Inheritable; using (var svr = new AnonymousPipeServerStream(PipeDirection.Out, inherit)) using (var clt = new AnonymousPipeServerStream(PipeDirection.In, inherit)) { string svrID = svr.GetClientHandleAsString(); string cltID = clt.GetClientHandleAsString(); ProcessStartInfo prc = new ProcessStartInfo { FileName = clientPath, Arguments = svrID + " " + cltID, UseShellExecute = false }; Process.Start(prc); // var startInfo = new ProcessStartInfo(clientPath, svrID + " " + cltID); // startInfo.UseShellExecute = false; // Process p = Process.Start(startInfo); svr.DisposeLocalCopyOfClientHandle(); clt.DisposeLocalCopyOfClientHandle(); svr.WriteByte(101); Console.WriteLine($"Transmission received: {clt.ReadByte()}"); //prc.WaitForExit(); } } catch (Exception ex) { Console.WriteLine(ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine + ex.Source); } // Debug. Console.WriteLine("Anonymous Pipes Client End: {0}", System.DateTime.Now.ToString()); // Await user input. Console.ReadLine(); }
public static void ServerReadOnlyThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Assert.Throws <NotSupportedException>(() => server.Write(new byte[5], 0, 5)); Assert.Throws <NotSupportedException>(() => server.WriteByte(123)); Assert.Throws <NotSupportedException>(() => server.Flush()); Assert.Throws <NotSupportedException>(() => server.OutBufferSize); Assert.Throws <NotSupportedException>(() => server.WaitForPipeDrain()); } }
public static void Main(string[] args) { try { // Debug. Console.WriteLine("Anonymous Pipes Client Begin: {0}", System.DateTime.Now.ToString()); //string cltID = args[0]; //string svrID = args[1]; // Debug. Console.WriteLine($"args.Length: {args.Length}"); // Debug. if (args.Length > 0) { for (int i = 0; i < args.Length; i++) { Console.WriteLine($"args[{i}]: {args[i].ToString()}"); } } // Debug. Console.WriteLine("Line #40"); using (var clt = new AnonymousPipeServerStream(PipeDirection.In, inherit)) using (var svr = new AnonymousPipeServerStream(PipeDirection.Out, inherit)) { // Debug. Console.WriteLine("AnonymousPipesClient.cs :: Line #46"); Console.WriteLine($"Transmission received: {clt.ReadByte()}"); svr.WriteByte(200); } } catch (Exception ex) { Console.WriteLine(ex.Message + Environment.NewLine + ex.StackTrace + Environment.NewLine + ex.Source); } // Debug. Console.WriteLine("Anonymous Pipes Client End: {0}", System.DateTime.Now.ToString()); }
public static void ServerSendsByteClientReceives() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Assert.True(server.IsConnected); using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString())) { Assert.True(server.IsConnected); Assert.True(client.IsConnected); byte[] sent = new byte[] { 123 }; byte[] received = new byte[] { 0 }; server.Write(sent, 0, 1); Assert.Equal(1, client.Read(received, 0, 1)); Assert.Equal(sent[0], received[0]); } Assert.Throws <System.IO.IOException>(() => server.WriteByte(5)); } }
public void PingPong() { // Create two anonymous pipes, one for each direction of communication. // Then spawn another process to communicate with. using (var outbound = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable)) using (var inbound = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable)) using (var remote = RemoteInvoke(PingPong_OtherProcess, outbound.GetClientHandleAsString(), inbound.GetClientHandleAsString())) { // Close our local copies of the handles now that we've passed them of to the other process outbound.DisposeLocalCopyOfClientHandle(); inbound.DisposeLocalCopyOfClientHandle(); // Ping-pong back and forth by writing then reading bytes one at a time. for (byte i = 0; i < 10; i++) { outbound.WriteByte(i); int received = inbound.ReadByte(); Assert.Equal(i, received); } } }
public static void ClonedServer_ActsAsOriginalServer() { using (AnonymousPipeServerStream serverBase = new AnonymousPipeServerStream(PipeDirection.Out)) using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, serverBase.SafePipeHandle, serverBase.ClientSafePipeHandle)) { Assert.True(server.IsConnected); using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle)) { Assert.True(server.IsConnected); Assert.True(client.IsConnected); byte[] sent = new byte[] { 123 }; byte[] received = new byte[] { 0 }; server.Write(sent, 0, 1); Assert.Equal(1, client.Read(received, 0, 1)); Assert.Equal(sent[0], received[0]); } Assert.Throws <IOException>(() => server.WriteByte(5)); } }
public void PingPong() { // Create two anonymous pipes, one for each direction of communication. // Then spawn another process to communicate with. using (var outbound = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable)) using (var inbound = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable)) using (var remote = RemoteInvoke(PingPong_OtherProcess, outbound.GetClientHandleAsString(), inbound.GetClientHandleAsString())) { // Close our local copies of the handles now that we've passed them of to the other process outbound.DisposeLocalCopyOfClientHandle(); inbound.DisposeLocalCopyOfClientHandle(); // Ping-pong back and forth by writing then reading bytes one at a time. for (byte i = 0; i < 10; i++) { outbound.WriteByte(i); int received = inbound.ReadByte(); Assert.Equal(i, received); } } }
public static void Main() { AnonymousPipeServerStream pipeServer = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable); var clientPipeHandle = pipeServer.GetClientHandleAsString(); Console.WriteLine(clientPipeHandle); Process pipeClient = new Process(); pipeClient.StartInfo.FileName = "client.exe"; pipeClient.StartInfo.Arguments = clientPipeHandle; pipeClient.StartInfo.UseShellExecute = false; pipeClient.Start(); pipeServer.DisposeLocalCopyOfClientHandle(); pipeServer.WriteByte(45); pipeServer.Flush(); Console.WriteLine("Press any key to quit"); Console.ReadKey(); pipeServer.Dispose(); }
public static void ClonedServer_ActsAsOriginalServer() { using (AnonymousPipeServerStream serverBase = new AnonymousPipeServerStream(PipeDirection.Out)) { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, serverBase.SafePipeHandle, serverBase.ClientSafePipeHandle)) { Assert.True(server.IsConnected); using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString())) { Assert.True(server.IsConnected); Assert.True(client.IsConnected); byte[] sent = new byte[] { 123 }; byte[] received = new byte[] { 0 }; server.Write(sent, 0, 1); Assert.Equal(1, client.Read(received, 0, 1)); Assert.Equal(sent[0], received[0]); } Assert.Throws<IOException>(() => server.WriteByte(5)); } } }
public void Process_IPC() { Process p = CreateProcess("ipc"); using (var outbound = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable)) using (var inbound = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable)) { p.StartInfo.Arguments += " " + outbound.GetClientHandleAsString() + " " + inbound.GetClientHandleAsString(); p.Start(); outbound.DisposeLocalCopyOfClientHandle(); inbound.DisposeLocalCopyOfClientHandle(); for (byte i = 0; i < 10; i++) { outbound.WriteByte(i); int received = inbound.ReadByte(); Assert.Equal(i, received); } Assert.True(p.WaitForExit(WaitInMS)); Assert.Equal(SuccessExitCode, p.ExitCode); } }
public void PingPong() { // Create two anonymous pipes, one for each direction of communication. // Then spawn another process to communicate with. using (var outbound = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable)) using (var inbound = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable)) using (var remote = RemoteExecutor.Invoke(new Func <string, string, int>(ChildFunc), outbound.GetClientHandleAsString(), inbound.GetClientHandleAsString())) { // Close our local copies of the handles now that we've passed them of to the other process outbound.DisposeLocalCopyOfClientHandle(); inbound.DisposeLocalCopyOfClientHandle(); // Ping-pong back and forth by writing then reading bytes one at a time. for (byte i = 0; i < 10; i++) { outbound.WriteByte(i); int received = inbound.ReadByte(); Assert.Equal(i, received); } } int ChildFunc(string inHandle, string outHandle) { // Create the clients associated with the supplied handles using (var inbound = new AnonymousPipeClientStream(PipeDirection.In, inHandle)) using (var outbound = new AnonymousPipeClientStream(PipeDirection.Out, outHandle)) { // Repeatedly read then write a byte from and to the server for (int i = 0; i < 10; i++) { int b = inbound.ReadByte(); outbound.WriteByte((byte)b); } } return(RemoteExecutor.SuccessExitCode); } }
public void CtorAndAccept_SocketNotKeptAliveViaInheritance(bool validateClientOuter, int acceptApiOuter) { // 300 ms should be long enough to connect if the socket is actually present & listening. const int ConnectionTimeoutMs = 300; // Run the test in another process so as to not have trouble with other tests // launching child processes that might impact inheritance. RemoteExecutor.Invoke((validateClientString, acceptApiString) => { bool validateClient = bool.Parse(validateClientString); int acceptApi = int.Parse(acceptApiString); // Create a listening server. using (var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { listener.Bind(new IPEndPoint(IPAddress.Loopback, 0)); listener.Listen(); EndPoint ep = listener.LocalEndPoint; // Create a client and connect to that listener. using (var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { client.Connect(ep); // Accept the connection using one of multiple accept mechanisms. Socket server = acceptApi == 0 ? listener.Accept() : acceptApi == 1 ? listener.AcceptAsync().GetAwaiter().GetResult() : acceptApi == 2 ? Task.Factory.FromAsync(listener.BeginAccept, listener.EndAccept, null).GetAwaiter().GetResult() : throw new Exception($"Unexpected {nameof(acceptApi)}: {acceptApi}"); // Get streams for the client and server, and create a pipe that we'll use // to communicate with a child process. using (var serverStream = new NetworkStream(server, ownsSocket: true)) using (var clientStream = new NetworkStream(client, ownsSocket: true)) using (var serverPipe = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable)) { // Create a child process that blocks waiting to receive a signal on the anonymous pipe. // The whole purpose of the child is to test whether handles are inherited, so we // keep the child process alive until we're done validating that handles close as expected. using (RemoteExecutor.Invoke(clientPipeHandle => { using (var clientPipe = new AnonymousPipeClientStream(PipeDirection.In, clientPipeHandle)) { Assert.Equal(42, clientPipe.ReadByte()); } }, serverPipe.GetClientHandleAsString())) { if (validateClient) // Validate that the child isn't keeping alive the "new Socket" for the client { // Send data from the server to client, then validate the client gets EOF when the server closes. serverStream.WriteByte(84); Assert.Equal(84, clientStream.ReadByte()); serverStream.Close(); Assert.Equal(-1, clientStream.ReadByte()); } else // Validate that the child isn't keeping alive the "listener.Accept" for the server { // Send data from the client to server, then validate the server gets EOF when the client closes. clientStream.WriteByte(84); Assert.Equal(84, serverStream.ReadByte()); clientStream.Close(); Assert.Equal(-1, serverStream.ReadByte()); } // And validate that we after closing the listening socket, we're not able to connect. listener.Dispose(); using (var tmpClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { bool connected = tmpClient.TryConnect(ep, ConnectionTimeoutMs); // Let the child process terminate. serverPipe.WriteByte(42); Assert.False(connected); } } } } } }, validateClientOuter.ToString(), acceptApiOuter.ToString()).Dispose(); }
public static void ServerReadOnlyThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Assert.Throws<NotSupportedException>(() => server.Write(new byte[5], 0, 5)); Assert.Throws<NotSupportedException>(() => server.WriteByte(123)); Assert.Throws<NotSupportedException>(() => server.Flush()); Assert.Throws<NotSupportedException>(() => server.OutBufferSize); Assert.Throws<NotSupportedException>(() => server.WaitForPipeDrain()); Assert.Throws<NotSupportedException>(() => NotReachable(server.WriteAsync(new byte[5], 0, 5))); } }