/// <summary> /// Async method to write pending data to the standard input stream of the command line. /// </summary> private async void WriteToClientTask() { while (ShouldRun) { Thread.Sleep(1); if (!PendingMessages.IsEmpty) // AND if it is a good time to write to client { byte[] msgByte = new byte[MaxLen]; string peekMsg = string.Empty; PendingMessages.TryPeek(out peekMsg); byte[] strBuf = Encoding.UTF8.GetBytes(peekMsg); Buffer.BlockCopy(strBuf, 0, msgByte, 0, strBuf.Length); await server.WriteAsync(msgByte, 0, MaxLen); Thread.Sleep(1); await server.FlushAsync(); lock (threadLock) { PendingMessages.TryDequeue(out var result); } } } KillPipes(); }
private void EncodeThreadInit(int _camNumber, string _encodePipeName, string _sessionPath, int _count, ConcurrentQueue <byte[]> _encodeQueue) { int camNumber = _camNumber; string pipeName = _encodePipeName; string sessionPath = _sessionPath; int count = _count; int nFramesWritten = 0; ConcurrentQueue <byte[]> encodeQueue = _encodeQueue; NamedPipeServerStream pipe = new NamedPipeServerStream(pipeName: pipeName, direction: PipeDirection.Out, maxNumberOfServerInstances: 1, transmissionMode: PipeTransmissionMode.Byte, options: PipeOptions.Asynchronous, inBufferSize: 7057600, outBufferSize: 7057600); string videoFileName = sessionPath + @"\" + DateTime.Now.ToString("yyyy_MM_dd_hh_mm_ss") + ".mp4"; FFProcess ffProcess = new FFProcess(pipeName: pipeName, videoFileName: videoFileName); ffProcess.OpenWithStartInfo(); pipe.WaitForConnection(); Console.WriteLine("Pipe connected to ffProcess for camera {0} on thread {1}", camNumber.ToString(), Thread.CurrentThread.ManagedThreadId.ToString()); bool goEncode = true; bool isDequeueSuccess; while (goEncode) { isDequeueSuccess = encodeQueue.TryDequeue(out byte[] result); if (isDequeueSuccess) { pipe.Write(buffer: result, offset: 0, count: count); nFramesWritten++; if (nFramesWritten % 1000 == 0) { Console.WriteLine("nFramesWritten for cam number {0}: {1}", camNumber.ToString(), nFramesWritten.ToString()); } } else { Thread.Sleep(10); if (encodeQueue.Count == 0) { goEncode = false; } } } pipe.FlushAsync(); pipe.WaitForPipeDrain(); pipe.Close(); ffProcess.process.WaitForExit(); ffProcess.process.Close(); Console.WriteLine("EncodeThread for camera {0}: Pipe flushed, drained, and closed. FFProcess exited and closed.", camNumber.ToString()); if (camNumber == 0) { GC.Collect(); Console.WriteLine("Garbage collected on camera 1 EncodeThread. Now exiting."); } }
private static async Task SendResponceToClient(NamedPipeServerStream stream, string serverResponce) { byte[] responceData = Encoding.Unicode.GetBytes(serverResponce); await stream.WriteAsync(responceData, 0, responceData.Length); await stream.FlushAsync(); stream.WaitForPipeDrain(); }
private static async Task WaitForConnectionAsync(NamedPipeServerStream pipeServerStream) { #if CoreCLR await pipeServerStream.WaitForConnectionAsync(); #else await Task.Factory.FromAsync(pipeServerStream.BeginWaitForConnection, pipeServerStream.EndWaitForConnection, null); #endif await pipeServerStream.FlushAsync(); }
private async Task WriteToPipe(byte[] buffer, NamedPipeServerStream pipe) { if (IsDisposed) { return; } try { await pipe.WriteAsync(buffer, 0, buffer.Length); await pipe.FlushAsync(); } catch {} }
async Task CreateProfileWorkerAsync(CancellationToken ct) { while (!ct.IsCancellationRequested) { PipeSecurity ps = new PipeSecurity(); SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null); PipeAccessRule par = new PipeAccessRule(sid, PipeAccessRights.ReadWrite, System.Security.AccessControl.AccessControlType.Allow); ps.AddAccessRule(par); using (NamedPipeServerStream server = new NamedPipeServerStream("Microsoft.R.Host.UserProfile.Creator{b101cc2d-156e-472e-8d98-b9d999a93c7a}", PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024, ps)) { try { await server.WaitForConnectionAsync(ct); byte[] requestRaw = new byte[1024]; int bytesRead = 0; while (bytesRead == 0 && !ct.IsCancellationRequested) { bytesRead = await server.ReadAsync(requestRaw, 0, requestRaw.Length, ct); } string json = Encoding.Unicode.GetString(requestRaw, 0, bytesRead); var requestData = JsonConvert.DeserializeObject <RUserProfileCreateRequest>(json); var result = RUserProfileCreator.Create(requestData, _logger); string jsonResp = JsonConvert.SerializeObject(result); byte[] respData = Encoding.Unicode.GetBytes(jsonResp); await server.WriteAsync(respData, 0, respData.Length, ct); await server.FlushAsync(ct); // Waiting here to allow client to finish reading // client should disconnect after reading. while (bytesRead == 0 && !ct.IsCancellationRequested) { bytesRead = await server.ReadAsync(requestRaw, 0, requestRaw.Length, ct); } // if there was an attempt to write, disconnect. server.Disconnect(); } catch (Exception ex) when(!ex.IsCriticalException()) { _logger?.LogError(Resources.Error_UserProfileCreationError, ex.Message); } } } _workerdone.Set(); }
private static void StartMonitor(string name) { try { while (!mIsClosed) { using (var server = new NamedPipeServerStream(name + "h", PipeDirection.InOut)) { server.WaitForConnection(); while (!mIsClosed) { try { if (!server.IsConnected) { break; } var cmd = server.ReadByte(); if (cmd == 0) { if (Runner.Instance.IsStarted) { Runner.Instance.Stop(); } mIsClosed = true; server.WriteByte(1); server.FlushAsync(); Console.WriteLine(Res.Get("AnyKeyToExit")); break; //退出系统 } else { } } catch { break; } } } } } catch (Exception ex) { Console.WriteLine(ex.Message); } }
private void CreateServer() { try { using (pipeServer = new NamedPipeServerStream(pipeName, PipeDirection.InOut)) { Logger.Info("Wait Client connect PipeName:" + pipeName); pipeServer.WaitForConnection(); Logger.Info("Client is connected PipeName:" + pipeName); this.isConnected = true; while (true) { Thread.Sleep(1); bool isSuccess = sendMsgQueue.TryDequeue(out sendMsg); if (isSuccess) { byte[] arrByte = Encoding.UTF8.GetBytes(sendMsg.sendContent); pipeServer.Write(arrByte, 0, arrByte.Length); byte[] data = new byte[PipeBufferSize]; int read = pipeServer.Read(data, 0, data.Length); sendMsg.resContent = Encoding.UTF8.GetString(data, 0, read); pipeServer.FlushAsync(); sendMsg.areReceive.Set(); if (string.IsNullOrEmpty(sendMsg.resContent) && !pipeServer.IsConnected) { this.isConnected = false; break; } } } } } catch (Exception ex) { Logger.Error("CreateServer err:" + ex); this.isConnected = false; sendMsg.areReceive.Set(); } Thread.Sleep(1); CreateServer(); }
internal static void ProcesClientMessage(ApplicationMessage applicationMessage, NamedPipeServerStream namedPipeServer) { if (applicationMessage != null) { var printMessage = $"Sync Time:{applicationMessage.SyncTime}\n" + $"Sync ID's received:{String.Join<int>(",", applicationMessage.SyncIDs)}"; Console.WriteLine($"Message from client:\n{printMessage}"); var serialized = JsonConvert.SerializeObject(printMessage); byte[] messageBytes = Encoding.UTF8.GetBytes(serialized); if (!namedPipeServer.IsConnected) { namedPipeServer.WaitForConnection(); Console.WriteLine("Client connected"); } Task.Run(async() => { await namedPipeServer.WriteAsync(messageBytes, 0, messageBytes.Length); await namedPipeServer.FlushAsync(); } ).Wait(); } }
private static async Task WaitForConnectionAsync(NamedPipeServerStream pipeServerStream) { await pipeServerStream.WaitForConnectionAsync(); await pipeServerStream.FlushAsync(); }
public async Task Listen() { var ps = new PipeSecurity(); ps.AddAccessRule(new PipeAccessRule( new SecurityIdentifier(_allowedSid), PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance, AccessControlType.Allow)); var pipeName = GetPipeName(_allowedSid, _allowedPid); Logger.Instance.Log($"Using named pipe {pipeName}.", LogLevel.Debug); Logger.Instance.Log($"Access allowed only for ProcessID {_allowedPid} and childs", LogLevel.Debug); while (!cancellationTokenSource.IsCancellationRequested) { using (NamedPipeServerStream dataPipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut, MAX_SERVER_INSTANCES, PipeTransmissionMode.Message, PipeOptions.Asynchronous, GlobalSettings.BufferSize, GlobalSettings.BufferSize, ps)) { using (NamedPipeServerStream controlPipe = new NamedPipeServerStream(pipeName + "_control", PipeDirection.InOut, MAX_SERVER_INSTANCES, PipeTransmissionMode.Message, PipeOptions.Asynchronous, GlobalSettings.BufferSize, GlobalSettings.BufferSize, ps)) { Logger.Instance.Log("NamedPipeServer listening.", LogLevel.Debug); Task.WaitAll( new Task[] { dataPipe.WaitForConnectionAsync(cancellationTokenSource.Token), controlPipe.WaitForConnectionAsync(cancellationTokenSource.Token), }, cancellationTokenSource.Token ); if (dataPipe.IsConnected && controlPipe.IsConnected && !cancellationTokenSource.IsCancellationRequested) { var connection = new Connection() { ControlStream = controlPipe, DataStream = dataPipe }; ConnectionKeepAliveThread.Start(connection); Logger.Instance.Log("Incoming Connection.", LogLevel.Info); var clientPid = dataPipe.GetClientProcessId(); if (!IsAuthorized(clientPid, _allowedPid)) { Logger.Instance.Log($"Unauthorized access from PID {clientPid}", LogLevel.Warning); await controlPipe.WriteAsync($"{Constants.TOKEN_ERROR}Unauthorized.{Constants.TOKEN_ERROR}").ConfigureAwait(false); await controlPipe.FlushAsync().ConfigureAwait(false); controlPipe.WaitForPipeDrain(); dataPipe.Disconnect(); controlPipe.Disconnect(); // kill the server. return; } ConnectionAccepted?.Invoke(this, connection); while (connection.IsAlive) { await Task.Delay(10).ConfigureAwait(false); } ConnectionClosed?.Invoke(this, connection); } Logger.Instance.Log("Listener Closed.", LogLevel.Debug); } } } }
public Task FlushAsync(CancellationToken cancellationToken) { return(stream.FlushAsync(cancellationToken)); }
public async static Task OpenServer() { ApiCredentials = new ClientSecrets(); string CustomCredentials = Path.Combine(AppDataDirectory, "credentials.json"); if (System.IO.File.Exists(CustomCredentials)) { using (var Stream = new MemoryStream(System.IO.File.ReadAllBytes(CustomCredentials))) ApiCredentials = GoogleClientSecrets.Load(Stream).Secrets; } else { ApiCredentials.ClientId = "1028112365169-3iss4ffrp626a31lc96pn3c3cujkbdg2.apps.googleusercontent.com"; ApiCredentials.ClientSecret = "lDb5KUCJt6gLrOtHNScZ6QYm"; } if (ServerInstance == null) { Message("Null server instance", "dbg", MessageType.Other, ButtonsType.Ok); return; } using (NamedPipeServerStream Server = new NamedPipeServerStream(ServerName + (ServerInstance ?? "GLOBAL"))) { while (true) { try { if (!Server.IsConnected) { await Server.WaitForConnectionAsync(); } var Cmd = (Commands)await Server.ReadU16(); switch (Cmd) { case Commands.PING: await Server.WriteBool(true); break; case Commands.InterAccounts: await Server.WriteBool(UserInfoA.EmailAddress != UserInfoB.EmailAddress); break; case Commands.CloseServer: Server.Close(); return; case Commands.ConnectA: CredentialsA = await GoogleWebAuthorizationBroker.AuthorizeAsync(ApiCredentials, Scopes, UserA, System.Threading.CancellationToken.None); ServiceA = new DriveService(new BaseClientService.Initializer() { HttpClientInitializer = CredentialsA, ApplicationName = "DriveMirror" }); UserInfoA = await ServiceA.GetUserInfo(); break; case Commands.ConnectB: CredentialsB = await GoogleWebAuthorizationBroker.AuthorizeAsync(ApiCredentials, Scopes, UserB, System.Threading.CancellationToken.None); ServiceB = new DriveService(new BaseClientService.Initializer() { HttpClientInitializer = CredentialsB, ApplicationName = "DriveMirror" }); UserInfoB = await ServiceB.GetUserInfo(); break; case Commands.Disconnect: await CredentialsA.RevokeTokenAsync(CancellationToken.None); await CredentialsB.RevokeTokenAsync(CancellationToken.None); break; case Commands.EnumDrivesA: var DrivesA = await ServiceA.EnumDrives().ToListAsync(); await Server.WriteU32((uint)DrivesA.Count); foreach (var Drive in DrivesA) { await Server.WriteString(Drive.Name); await Server.WriteString(Drive.Id); } break; case Commands.EnumDrivesB: var DrivesB = await ServiceB.EnumDrives().ToListAsync(); await Server.WriteU32((uint)DrivesB.Count); foreach (var Drive in DrivesB) { await Server.WriteString(Drive.Name); await Server.WriteString(Drive.Id); } break; case Commands.GetFileByIdA: var FileAID = await Server.ReadString(); var AInfo = await ServiceA.GetFileById(FileAID); await Server.WriteFileInfo(AInfo); break; case Commands.GetFileByIdB: var FileBID = await Server.ReadString(); var BInfo = await ServiceB.GetFileById(FileBID); await Server.WriteFileInfo(BInfo); break; case Commands.ParsePathA: var APath = await Server.ReadString(); var AFInfo = await ServiceA.TranslatePath(APath, DriveA, true); await Server.WriteFileInfo(AFInfo); break; case Commands.ParsePathB: var BPath = await Server.ReadString(); var BFInfo = await ServiceB.TranslatePath(BPath, DriveB, true); await Server.WriteFileInfo(BFInfo); break; case Commands.EnumFilesA: var AEFID = await Server.ReadString(); var ATrashed = await Server.ReadBool(); if (AEFID.StartsWith("/")) { AEFID = (await ServiceA.TranslatePath(AEFID)).Id; } await ServiceA.EnumFiles(AEFID, DriveA, true, ATrashed).ForEachAsync(async x => { await Server.WriteBool(true); await Server.WriteFileInfo(x); }); await Server.WriteBool(false); break; case Commands.EnumFilesB: var BEFID = await Server.ReadString(); var BTrashed = await Server.ReadBool(); if (BEFID.StartsWith("/")) { BEFID = (await ServiceB.TranslatePath(BEFID)).Id; } await ServiceB.EnumFiles(BEFID, DriveB, true, BTrashed).ForEachAsync(async x => { await Server.WriteBool(true); await Server.WriteFileInfo(x); }); await Server.WriteBool(false); break; case Commands.EnumFoldersA: var AEDID = await Server.ReadString(); var ADTrashed = await Server.ReadBool(); if (AEDID.StartsWith("/")) { AEDID = (await ServiceA.TranslatePath(AEDID)).Id; } await ServiceA.EnumFolders(AEDID, DriveA, ADTrashed).ForEachAsync(async x => { await Server.WriteBool(true); await Server.WriteFileInfo(x); }); await Server.WriteBool(false); break; case Commands.EnumFoldersB: var BEDID = await Server.ReadString(); var BDTrashed = await Server.ReadBool(); if (BEDID.StartsWith("/")) { BEDID = (await ServiceB.TranslatePath(BEDID)).Id; } await ServiceB.EnumFolders(BEDID, DriveB, BDTrashed).ForEachAsync(async x => { await Server.WriteBool(true); await Server.WriteFileInfo(x); }); await Server.WriteBool(false); break; case Commands.CopyFileA: string ACPYID = await Server.ReadString(); string ACPYNM = await Server.ReadString(); string ACPYDR = await Server.ReadString(); var ACPYNF = await ServiceA.CopyFile(ACPYID, ACPYNM, ACPYDR); await Server.WriteFileInfo(ACPYNF); break; case Commands.CopyFileB: string BCPYID = await Server.ReadString(); string BCPYNM = await Server.ReadString(); string BCPYDR = await Server.ReadString(); var BCPYNF = await ServiceB.CopyFile(BCPYID, BCPYNM, BCPYDR); await Server.WriteFileInfo(BCPYNF); break; case Commands.DeleteFileA: string ADELID = await Server.ReadString(); await ServiceA.Delete(await ServiceA.GetFileById(ADELID)); break; case Commands.DeleteFileB: string BDELID = await Server.ReadString(); await ServiceB.Delete(await ServiceB.GetFileById(BDELID)); break; case Commands.CreateDirectoryA: string NewDirPathA = await Server.ReadString(); var NDirA = await ServiceA.CreateDirectory(NewDirPathA, DriveA); await Server.WriteFileInfo(NDirA); break; case Commands.CreateDirectoryB: string NewDirPathB = await Server.ReadString(); var NDirB = await ServiceB.CreateDirectory(NewDirPathB, DriveB); await Server.WriteFileInfo(NDirB); break; case Commands.SelectDriveA: string ADriveID = await Server.ReadString(); DriveA = new Drive() { Id = ADriveID }; break; case Commands.SelectDriveB: string BDriveID = await Server.ReadString(); DriveB = new Drive() { Id = BDriveID }; break; case Commands.ShareFileA: string ASFID = await Server.ReadString(); var ASFInfo = await ServiceA.ShareFile(ASFID, ServiceB); await Server.WriteFileInfo(ASFInfo); break; case Commands.ShareFileB: string BSFID = await Server.ReadString(); var BSFInfo = await ServiceB.ShareFile(BSFID, ServiceA); await Server.WriteFileInfo(BSFInfo); break; case Commands.StopShareA: var StpFileInfA = await Server.ReadFileInfo(); var NWFileInfA = await ServiceA.StopSharing(StpFileInfA); await Server.WriteFileInfo(NWFileInfA); break; case Commands.StopShareB: var StpFileInfB = await Server.ReadFileInfo(); var NWFileInfB = await ServiceB.StopSharing(StpFileInfB); await Server.WriteFileInfo(NWFileInfB); break; } await Server.FlushAsync(); } catch (Exception ex) { if (!Client.IsConnected) { return; } Message(ex.ToString(), "DriveMirror Service", MessageType.Error, ButtonsType.Ok); } } } }
public async Task Listen() { var ps = new PipeSecurity(); ps.AddAccessRule(new PipeAccessRule( new SecurityIdentifier(_allowedSid), PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance, AccessControlType.Allow)); var networkSid = new SecurityIdentifier("S-1-5-2"); // deny remote connections. ps.AddAccessRule(new PipeAccessRule( networkSid, PipeAccessRights.FullControl, System.Security.AccessControl.AccessControlType.Deny)); var pipeName = NamedPipeNameFactory.GetPipeName(_allowedSid, _allowedPid); Logger.Instance.Log($"Listening on named pipe {pipeName}.", LogLevel.Debug); Logger.Instance.Log($"Access allowed only for ProcessID {_allowedPid} and children", LogLevel.Debug); _ = Task.Factory.StartNew(CancelIfAllowedProcessEnds, _cancellationTokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Current); do { using (NamedPipeServerStream dataPipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut, MAX_SERVER_INSTANCES, PipeTransmissionMode.Message, PipeOptions.Asynchronous, Settings.BufferSize, Settings.BufferSize, ps)) { using (NamedPipeServerStream controlPipe = new NamedPipeServerStream(pipeName + "_control", PipeDirection.InOut, MAX_SERVER_INSTANCES, PipeTransmissionMode.Message, PipeOptions.Asynchronous, Settings.BufferSize, Settings.BufferSize, ps)) { Logger.Instance.Log("NamedPipeServer listening.", LogLevel.Debug); Task.WaitAll( new Task[] { dataPipe.WaitForConnectionAsync(_cancellationTokenSource.Token), controlPipe.WaitForConnectionAsync(_cancellationTokenSource.Token), }, _cancellationTokenSource.Token ); if (dataPipe.IsConnected && controlPipe.IsConnected && !_cancellationTokenSource.IsCancellationRequested) { var connection = new Connection() { ControlStream = controlPipe, DataStream = dataPipe }; ConnectionKeepAliveThread.Start(connection); Logger.Instance.Log("Incoming Connection.", LogLevel.Info); var clientPid = dataPipe.GetClientProcessId(); if (!IsAuthorized(clientPid, _allowedPid)) { Logger.Instance.Log($"Unauthorized access from PID {clientPid}", LogLevel.Warning); await controlPipe.WriteAsync($"{Constants.TOKEN_ERROR}Unauthorized.{Constants.TOKEN_ERROR}").ConfigureAwait(false); await controlPipe.FlushAsync().ConfigureAwait(false); controlPipe.WaitForPipeDrain(); dataPipe.Disconnect(); controlPipe.Disconnect(); // kill the server. return; } ConnectionAccepted?.Invoke(this, connection); while (connection.IsAlive) { await Task.Delay(10).ConfigureAwait(false); } ConnectionClosed?.Invoke(this, connection); Logger.Instance.Log("Connection Closed.", LogLevel.Info); } } } } while (!_singleUse && !_cancellationTokenSource.IsCancellationRequested); Logger.Instance.Log("Listener Closed.", LogLevel.Debug); _exeLock?.Close(); }
private static async Task ProfileServiceOperationAsync(Func <IUserCredentials, ILogger, IUserProfileServiceResult> operation, string name, IUserProfileNamedPipeFactory pipeFactory, int serverTimeOutms = 0, int clientTimeOutms = 0, CancellationToken ct = default(CancellationToken), ILogger logger = null) { using (NamedPipeServerStream server = pipeFactory.CreatePipe(name)) { await server.WaitForConnectionAsync(ct); ManualResetEventSlim forceDisconnect = new ManualResetEventSlim(false); try { if (serverTimeOutms + clientTimeOutms > 0) { Task.Run(() => { // This handles Empty string input cases. This is usually the case were client is connected and writes a empty string. // on the server side this blocks the ReadAsync indefinitely (even with the cancellation set). The code below protects // the server from being indefinitely blocked by a malicious client. forceDisconnect.Wait(serverTimeOutms + clientTimeOutms); if (server.IsConnected) { server.Disconnect(); logger?.LogError(Resources.Error_ClientTimedOut); } }).DoNotWait(); } using (var cts = CancellationTokenSource.CreateLinkedTokenSource(ct)) { if (serverTimeOutms > 0) { cts.CancelAfter(serverTimeOutms); } byte[] requestRaw = new byte[1024]; int bytesRead = 0; while (bytesRead == 0 && !cts.IsCancellationRequested) { bytesRead = await server.ReadAsync(requestRaw, 0, requestRaw.Length, cts.Token); } string json = Encoding.Unicode.GetString(requestRaw, 0, bytesRead); var requestData = Json.DeserializeObject <RUserProfileServiceRequest>(json); var result = operation?.Invoke(requestData, logger); string jsonResp = JsonConvert.SerializeObject(result); byte[] respData = Encoding.Unicode.GetBytes(jsonResp); await server.WriteAsync(respData, 0, respData.Length, cts.Token); await server.FlushAsync(cts.Token); } using (var cts = CancellationTokenSource.CreateLinkedTokenSource(ct)) { if (clientTimeOutms > 0) { cts.CancelAfter(clientTimeOutms); } // Waiting here to allow client to finish reading client should disconnect after reading. byte[] requestRaw = new byte[1024]; int bytesRead = 0; while (bytesRead == 0 && !cts.Token.IsCancellationRequested) { bytesRead = await server.ReadAsync(requestRaw, 0, requestRaw.Length, cts.Token); } // if there was an attempt to write, disconnect. server.Disconnect(); } } finally { // server work is done. forceDisconnect.Set(); } } }
private static async Task RunServer() { Console.WriteLine("Initiating server, waiting for client..."); // Start up our named pipe in message mode and close the pipe // when done. using (NamedPipeServerStream serverPipe = new NamedPipeServerStream("mypipe", PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.None)) { // wait for a client... serverPipe.WaitForConnection(); // process messages until the client goes away while (serverPipe.IsConnected) { int bytesRead = 0; byte[] messageBytes = new byte[256]; // read until we have the message then respond do { // build up the client message StringBuilder message = new StringBuilder(); // check that we can read the pipe if (serverPipe.CanRead) { // loop until the entire message is read do { bytesRead = await serverPipe.ReadAsync(messageBytes, 0, messageBytes.Length); // got bytes from the stream so add them to the message if (bytesRead > 0) { message.Append( Encoding.Unicode.GetString(messageBytes, 0, bytesRead)); Array.Clear(messageBytes, 0, messageBytes.Length); } }while (!serverPipe.IsMessageComplete); } // if we got a message, write it out and respond if (message.Length > 0) { // set to zero as we have read the whole message bytesRead = 0; Console.WriteLine($"Received message: {message.ToString()}"); // return the message text we got from the // client in reverse char[] messageChars = message.ToString().Trim().ToCharArray(); Array.Reverse(messageChars); string reversedMessageText = new string(messageChars); // show the return message Console.WriteLine($" Returning Message: {reversedMessageText}"); // write the response messageBytes = Encoding.Unicode.GetBytes(messageChars); if (serverPipe.CanWrite) { // write the message await serverPipe.WriteAsync(messageBytes, 0, messageBytes.Length); // flush the buffer await serverPipe.FlushAsync(); // wait till read by client serverPipe.WaitForPipeDrain(); } } }while (bytesRead != 0); } } }
private static void StartMonitor(string name) { try { while (!mIsClosed) { try { using (var server = new NamedPipeServerStream(name, PipeDirection.InOut)) { server.WaitForConnection(); while (!mIsClosed) { try { if (!server.IsConnected) { break; } var cmd = server.ReadByte(); if (cmd == 0) { if (Cdy.Tag.Runner3.RunInstance.IsStarted) { Cdy.Tag.Runner3.RunInstance.Stop(); } mIsClosed = true; server.WriteByte(1); server.FlushAsync(); //server.WaitForPipeDrain(); Console.WriteLine(Res.Get("AnyKeyToExit") + "....."); break; //退出系统 } else if (cmd == 1) { Console.WriteLine("Start to restart database......."); Task.Run(() => { Cdy.Tag.Runner3.RunInstance.ReStartDatabase(); }); server.WriteByte(1); server.FlushAsync(); // server.WaitForPipeDrain(); } else { } } catch (Exception eex) { break; } } } } catch (Exception ex) { Console.WriteLine(ex.Message); } } } catch (Exception ex) { LoggerService.Service.Info("Programe", ex.Message); //Console.WriteLine(ex.Message); } }
/// <summary> /// Server loop /// </summary> public async Task LoopAsync() { await JoinableTaskFactory.SwitchToMainThreadAsync(Loop.Token); var DTE = await Package.GetServiceAsync(typeof(DTE)) as DTE2; await TaskScheduler.Default; var pipeName = string.Format("QtVSTest_{0}", Process.GetCurrentProcess().Id); while (!Loop.Token.IsCancellationRequested) { using (var pipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut)) { await pipe.WaitForConnectionAsync(Loop.Token); if (Loop.Token.IsCancellationRequested) { break; } while (!Loop.Token.IsCancellationRequested && pipe.IsConnected) { byte[] data = new byte[4]; await pipe.ReadAsync(data, 0, 4, Loop.Token); if (Loop.Token.IsCancellationRequested) { break; } if (pipe.IsConnected) { int size = BitConverter.ToInt32(data, 0); data = new byte[size]; await pipe.ReadAsync(data, 0, size, Loop.Token); if (Loop.Token.IsCancellationRequested) { break; } var macro = new Macro(Package, DTE, JoinableTaskFactory, Loop.Token); await macro.CompileAsync(Encoding.UTF8.GetString(data)); if (macro.AutoRun) { await macro.RunAsync(); } data = Encoding.UTF8.GetBytes(macro.Result); size = data.Length; await pipe.WriteAsync(BitConverter.GetBytes(size), 0, 4, Loop.Token); if (Loop.Token.IsCancellationRequested) { break; } await pipe.WriteAsync(data, 0, size, Loop.Token); if (Loop.Token.IsCancellationRequested) { break; } await pipe.FlushAsync(Loop.Token); if (Loop.Token.IsCancellationRequested) { break; } pipe.WaitForPipeDrain(); if (macro != null && macro.Ok && macro.AutoRun && macro.QuitWhenDone) { await JoinableTaskFactory.SwitchToMainThreadAsync(Loop.Token); if (DTE != null) { DTE.Solution.Close(false); DTE.Quit(); } await TaskScheduler.Default; Loop.Cancel(); } } } } } }
public static async Task RunServer() { Console.WriteLine("Initiating server, waiting for client..."); // Start up our named pipe in message mode and close the pipe // when done. using (NamedPipeServerStream serverStream = new NamedPipeServerStream("mypipe", PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.None)) { // wait for a client… await serverStream.WaitForConnectionAsync(); while (serverStream.IsConnected) { int bytesRead = 0; byte[] messageBytes = new byte[256]; // read until we have the message then respond do { // build up the client message StringBuilder message = new StringBuilder(); // check canRead if (serverStream.CanRead) { do { // loop until the entire message is read bytesRead = await serverStream.ReadAsync(messageBytes, 0, messageBytes.Length); // get bytes from stream and add to message if (bytesRead > 0) { message.Append(Encoding.Unicode.GetString(messageBytes, 0, bytesRead)); Array.Clear(messageBytes, 0, messageBytes.Length); } } while (!serverStream.IsMessageComplete); } // write it out till it got message if (message.Length > 0) { bytesRead = 0; Console.WriteLine($"Received message: {message}"); // return message in reverse char[] messageChars = message.ToString().Trim().ToCharArray(); Array.Reverse(messageChars); string reversedMessageText = new string(messageChars); Console.WriteLine($" Returning Message: " + $"{reversedMessageText}"); messageBytes = Encoding.Unicode.GetBytes(messageChars); if (serverStream.CanWrite) { // write the message await serverStream.WriteAsync(messageBytes, 0, messageBytes.Length); // flush buffer await serverStream.FlushAsync(); // wait till read by client serverStream.WaitForPipeDrain(); } } } while (bytesRead != 0); } } }