/// <inheritdoc /> public bool Connect() { if (_pipeStream != null) { throw new InvalidPipeOperationException("Client pipe already connected"); } if (_pipeName == null) { throw new InvalidPipeOperationException("Client pipe name was not set"); } try { _pipeStream = new NamedPipeClientStream( ".", _pipeName, PipeDirection.InOut, PipeOptions.Asynchronous, TokenImpersonationLevel.Impersonation); _pipeStream.Connect(); } catch (IOException e) { Console.WriteLine(e.ToString()); return(false); } Connection = new PipeConnection(_pipeStream, () => _connectionStopped); MessageHandler = new MessageHandler(Connection); return(true); }
public void AddAllReadyServerConnectionsToObservers() { var connection1 = new NetworkConnection(tconn42) { IsReady = true }; var connection2 = new NetworkConnection(tconn43) { IsReady = false }; // add some server connections server.connections.Add(connection1); server.connections.Add(connection2); // add a host connection (_, IConnection localConnection) = PipeConnection.CreatePipe(); server.SetLocalConnection(client, localConnection); server.LocalConnection.IsReady = true; // call OnStartServer so that observers dict is created identity.StartServer(); // add all to observers. should have the two ready connections then. identity.AddAllReadyServerConnectionsToObservers(); Assert.That(identity.observers, Is.EquivalentTo(new[] { connection1, server.LocalConnection })); // clean up server.Disconnect(); }
public override Task <IConnection> ConnectAsync(Uri uri) { (IConnection c1, IConnection c2) = PipeConnection.CreatePipe(); AcceptConnections.Enqueue(c2); return(Task.FromResult(c1)); }
public static (NetworkConnection, NetworkConnection) PipedConnections() { (IConnection c1, IConnection c2) = PipeConnection.CreatePipe(); var toServer = new NetworkConnection(c2); var toClient = new NetworkConnection(c1); return(toServer, toClient); }
public SecsGemUnitTests() { var pipe1 = new Pipe(new PipeOptions(useSynchronizationContext: false)); var pipe2 = new Pipe(new PipeOptions(useSynchronizationContext: false)); pipeConnection1 = new PipeConnection(decoderReader: pipe1.Reader, decoderInput: pipe2.Writer); pipeConnection2 = new PipeConnection(decoderReader: pipe2.Reader, decoderInput: pipe1.Writer); }
public static (IPipeConnection Transport, IPipeConnection Application) CreateConnectionPair(this PipeFactory pipeFactory, PipeOptions inputOptions, PipeOptions outputOptions) { var input = pipeFactory.Create(inputOptions); var output = pipeFactory.Create(outputOptions); var transportToApplication = new PipeConnection(output.Reader, input.Writer); var applicationToTransport = new PipeConnection(input.Reader, output.Writer); return(applicationToTransport, transportToApplication); }
private void ProcessAccept(NamedPipeServerStream ioStream) { PostAccept(); var connection = new PipeConnection(serializer, dispatcher, ioStream); connection.Disconnected += new EventHandler(Connection_Disconnected); connections[connection.Guid] = connection; connection.Start(); }
public static Pipe Connect(string url, bool create, PipeConnection connection = PipeConnection.Global, uint timeout = 50, string options = null) { var res = Pipe_connect(url, create, connection, timeout, options); if (res == null) { throw new Exception("an error occured during pipe connect"); } return(new Pipe(res)); }
public void SetupNetworkManager() { gameObject = new GameObject(); gameObject.AddComponent <LoopbackTransport>(); manager = gameObject.AddComponent <NetworkManager>(); manager.startOnHeadless = false; manager.client = gameObject.GetComponent <NetworkClient>(); manager.server = gameObject.GetComponent <NetworkServer>(); (tconn1, tconn2) = PipeConnection.CreatePipe(); }
public static (NetworkConnectionToServer, NetworkConnectionToClient) PipedConnections(bool authenticated = false) { (IConnection c1, IConnection c2) = PipeConnection.CreatePipe(); var toServer = new NetworkConnectionToServer(c2); var toClient = new NetworkConnectionToClient(c1); toServer.isAuthenticated = authenticated; toClient.isAuthenticated = authenticated; return(toServer, toClient); }
private IConnection BuildDuplicatedNamedPipeConnection(NamedPipeDuplicateContext duplicateContext, int connectionBufferSize) { if (DiagnosticUtility.ShouldTraceVerbose) { TraceUtility.TraceEvent(TraceEventType.Verbose, 0xa0002, System.ServiceModel.SR.GetString("TraceCodePortSharingDuplicatedPipe")); } PipeHandle pipe = new PipeHandle(duplicateContext.Handle); PipeConnection innerConnection = new PipeConnection(pipe, connectionBufferSize, false, true); return(new NamedPipeValidatingConnection(new PreReadConnection(innerConnection, duplicateContext.ReadData), this)); }
static NetworkPlayer CreateNetworkConnection(GameObject player) { (IConnection conn1, IConnection _) = PipeConnection.CreatePipe(); var connection = new NetworkPlayer(conn1) { Identity = player.GetComponent <NetworkIdentity>() }; connection.Identity.ConnectionToClient = connection; connection.IsReady = true; return(connection); }
public override Task <IConnection> ConnectAsync(Uri uri) { (IConnection c1, IConnection c2) = PipeConnection.CreatePipe(); if (AcceptCompletionSource == null) { return(Task.FromException <IConnection>(new SocketException((int)SocketError.ConnectionRefused))); } else { AcceptCompletionSource?.SetResult(c2); return(Task.FromResult(c1)); } }
public async Task <JsonResult> GetData(long wellboreId, DateTime startTime, DateTime?endTime, List <Parameter> parameters) { Response.BufferOutput = false; //IRealtimeConnection testConnection; var pipeConnection = new PipeConnection(); using (var store = new Store()) { var data = store.GetData(parameters, new Wellbore { Id = wellboreId }, startTime, (DateTime)endTime); Response.Write(data); Response.Flush(); } if (endTime == null) { return(Json(new { success = true })); } pipeConnection.ConfigureConnection(wellboreId, parameters); pipeConnection.PipeClient = new NamedPipeClientStream(".", "PipeConnection", PipeDirection.InOut, PipeOptions.Asynchronous); pipeConnection.PipeClient.Connect(); while (true) { var newData = await pipeConnection.GetNewData(); if (newData == null) { break; } Response.Write(newData); Response.Flush(); } Response.End(); pipeConnection.PipeClient.Close(); return(Json(new { success = true }, JsonRequestBehavior.AllowGet)); }
internal void ConnectHost(NetworkServer server) { logger.Log("Client Connect Host to Server"); connectState = ConnectState.Connected; InitializeAuthEvents(); // create local connection objects and connect them (IConnection c1, IConnection c2) = PipeConnection.CreatePipe(); server.SetLocalConnection(this, c2); hostServer = server; Connection = GetNewConnection(c1); RegisterHostHandlers(); OnConnected().Forget(); }
public async Task ConnectPlayerAsync(ConnectionType connectionType, IProgress <string> prog) { if (m_user != null) { return; } IConnection connection; switch (connectionType) { case ConnectionType.Tcp: connection = await TcpConnection.ConnectAsync(this.NetStats, "CNet"); break; case ConnectionType.Direct: connection = DirectConnection.Connect(m_server.Game); break; case ConnectionType.Pipe: connection = PipeConnection.Connect(); break; default: throw new Exception(); } var user = new ClientUser(connection); user.DisconnectEvent += OnDisconnected; await user.LogOn("tomba", prog); m_user = user; if (this.UserConnected != null) { this.UserConnected(user); } user.StartProcessingMessages(); }
public void AddAllReadyServerConnectionsToObservers() { player1.IsReady = true; player2.IsReady = false; // add some server connections server.Players.Add(player1); server.Players.Add(player2); // add a host connection (_, IConnection localConnection) = PipeConnection.CreatePipe(); server.SetLocalConnection(client, localConnection); server.LocalPlayer.IsReady = true; // call OnStartServer so that observers dict is created identity.StartServer(); // add all to observers. should have the two ready connections then. identity.AddAllReadyServerConnectionsToObservers(); Assert.That(identity.observers, Is.EquivalentTo(new[] { player1, server.LocalPlayer })); // clean up server.Stop(); }
private static extern IntPtr Pipe_connect(string url, bool create, PipeConnection connection, uint timeout, string options);
/// <summary> /// /// </summary> /// <param name="connection"></param> /// <param name="exception"></param> public ConnectionExceptionEventArgs(PipeConnection <T> connection, Exception exception) : base(connection) { Exception = exception ?? throw new ArgumentNullException(nameof(exception)); }
public override UniTask <IConnection> ConnectAsync(Uri uri) { (IConnection c1, IConnection c2) = PipeConnection.CreatePipe(); Connected.Invoke(c2); return(UniTask.FromResult(c1)); }
/// <summary> /// /// </summary> /// <param name="connection"></param> public ConnectionEventArgs(PipeConnection <T> connection) { Connection = connection ?? throw new ArgumentNullException(nameof(connection)); }
private void OnConnection(IAsyncResult ar) { // Check if we should be accepting any new connections. if (_connectionStopped) { return; } _pipe = null; var connectionBroken = false; if (!(ar.AsyncState is NamedPipeServerStream pipe)) { return; } try { try { pipe.EndWaitForConnection(ar); } catch (IOException e) { connectionBroken = true; if (!_connectionStopped) { Log($"Pipe {_pipeName} broken with: ", e); } } catch (ObjectDisposedException) { if (!_connectionStopped) { throw; } } catch (Exception e) { Log("Unhandled exception during connection initialization", e); } if (!_connectionStopped && !connectionBroken) { try { Connection = new PipeConnection(pipe, () => _connectionStopped); MessageHandler = new MessageHandler(Connection); _handleTransportConnection?.Invoke(this); } catch (Exception e) { Log("Unhandled exception during message transport initialization", e); } } } finally { pipe.Dispose(); } }
protected void Pipe_ServerPush(PipeConnection connection, int length) { try { var msg = PushMessageBase.Parser.ParseFrom(connection.Buffer, 0, length); switch (msg.Type) { case PushMessageID.UpdateUser: UserInfo = msg.DataUser; break; case PushMessageID.UpdateTunnel: Dispatcher.Invoke(() => { foreach (var t in Tunnels) { if (t.Id == msg.DataTunnel.Id) { t.Proto = msg.DataTunnel; t.SetNodeName(Nodes.ToDictionary(k => k.Id, v => v.Name)); break; } } }); break; case PushMessageID.UpdateTunnels: LoadTunnels(msg.DataTunnels); break; case PushMessageID.UpdateNodes: Dispatcher.Invoke(() => { Nodes.Clear(); var map = new Dictionary <int, string>(); foreach (var n in msg.DataNodes.Nodes) { Nodes.Add(new NodeModel(n)); map.Add(n.Id, n.Name); } foreach (var t in Tunnels) { t.SetNodeName(map); } }); break; case PushMessageID.AppendLog: Dispatcher.Invoke(() => { foreach (var l in msg.DataLog.Data) { Log(l); } }); break; case PushMessageID.PushUpdate: Update = msg.DataUpdate; break; case PushMessageID.PushConfig: Config = msg.DataConfig; break; } } catch { } }
/// <summary> /// /// </summary> /// <param name="connection"></param> /// <param name="message"></param> public ConnectionMessageEventArgs(PipeConnection <T> connection, T message) : base(connection) { Message = message; }
public void Pipe_DataReceived(PipeConnection connection, int count) { try { var req = RequestBase.Parser.ParseFrom(connection.Buffer, 0, count); var resp = ResponseBase(true); var blockSensitive = connection is RemotePipeConnection; switch (req.Type) { case MessageID.UserLogin: { if (blockSensitive) { connection.RespondFailure("远程控制无法执行该操作"); return; } var result = Login(req.DataUserLogin.Token).WaitResult(); if (result != null) { connection.RespondFailure(result); return; } } break; case MessageID.UserLogout: { if (blockSensitive) { connection.RespondFailure("远程控制无法执行该操作"); return; } var result = Logout(); if (result != null) { connection.RespondFailure(result); return; } } break; case MessageID.UserInfo: lock (UserInfo) { if (AutoLogin) { resp.DataUser = UserInfo.Clone(); resp.DataUser.Status = UserStatus.Pending; } else { resp.DataUser = UserInfo; } } break; case MessageID.LogGet: resp.DataLog = new LogList(); lock (LogManager) { resp.DataLog.Data.Add(LogManager); } break; case MessageID.LogClear: LogManager.Clear(); break; case MessageID.ControlExit: if (blockSensitive) { connection.RespondFailure("远程控制无法执行该操作"); return; } Stop(); return; case MessageID.ControlConfigGet: if (blockSensitive) { connection.RespondFailure("远程控制无法执行该操作"); return; } resp.DataConfig = GetConfig(); break; case MessageID.ControlConfigSet: if (blockSensitive) { connection.RespondFailure("远程控制无法执行该操作"); return; } if (req.DataConfig.RemoteKeyNew != "") { RemoteManager.EncryptKey = Sodium.PasswordHash.ArgonHashBinary(Encoding.UTF8.GetBytes(req.DataConfig.RemoteKeyNew), RemoteManager.SALT, 3, 268435456, 32); } RemoteManager.Enabled = req.DataConfig.RemoteManagement; if (RemoteManager.Enabled && UserInfo.Status == UserStatus.LoggedIn) { RemoteManager.Start(); } else { RemoteManager.Stop(); } Natfrp.BypassProxy = req.DataConfig.BypassProxy; UpdateManager.UpdateInterval = req.DataConfig.UpdateInterval; Save(); PushConfig(); break; case MessageID.ControlCheckUpdate: if (blockSensitive) { connection.RespondFailure("远程控制无法执行该操作"); return; } resp.DataUpdate = UpdateManager.CheckUpdate().WaitResult(); break; case MessageID.ControlGetUpdate: if (blockSensitive) { connection.RespondFailure("远程控制无法执行该操作"); return; } resp.DataUpdate = UpdateManager.Status; break; default: // Login required ↓ lock (UserInfo) { if (UserInfo.Status != UserStatus.LoggedIn) { connection.RespondFailure("用户未登录"); return; } } switch (req.Type) { case MessageID.TunnelList: resp.DataTunnels = new TunnelList(); resp.DataTunnels.Tunnels.Add(TunnelManager.Values.Select(t => t.CreateProto())); break; case MessageID.TunnelReload: TunnelManager.UpdateTunnels().Wait(); break; case MessageID.TunnelUpdate: lock (TunnelManager) { if (!TunnelManager.TryGetValue(req.DataUpdateTunnel.Id, out Tunnel t)) { connection.RespondFailure("隧道不存在"); return; } t.Enabled = req.DataUpdateTunnel.Status == 1; TunnelManager.PushOne(t); } break; case MessageID.TunnelDelete: Natfrp.Request <Natfrp.ApiResponse>("delete_tunnel", "tunnel=" + req.DataId).WaitResult(); lock (TunnelManager) { TunnelManager.Remove(req.DataId); TunnelManager.Push(); } break; case MessageID.TunnelCreate: { var result = Natfrp.Request <Natfrp.CreateTunnel>("create_tunnel", new StringBuilder() .Append("type=").Append(req.DataCreateTunnel.Type) .Append("&name=").Append(req.DataCreateTunnel.Name) .Append("¬e=").Append(req.DataCreateTunnel.Note) .Append("&node=").Append(req.DataCreateTunnel.Node) .Append("&local_ip=").Append(req.DataCreateTunnel.LocalAddress) .Append("&local_port=").Append(req.DataCreateTunnel.LocalPort) .Append("&remote_port=").Append(req.DataCreateTunnel.RemotePort).ToString()).WaitResult(); var t = TunnelManager.CreateFromApi(result.Data); lock (TunnelManager) { TunnelManager[t.Id] = t; TunnelManager.Push(); } resp.Message = "#" + t.Id + " " + t.Name; } break; case MessageID.NodeList: resp.DataNodes = new NodeList(); resp.DataNodes.Nodes.Add(NodeManager.Values); break; case MessageID.NodeReload: NodeManager.UpdateNodes().Wait(); break; } break; } connection.SendProto(resp); } catch (AggregateException e) when(e.InnerExceptions.Count == 1) { connection.SendProto(ResponseBase(false, e.InnerExceptions[0].ToString())); } catch (Exception e) { connection.SendProto(ResponseBase(false, e.ToString())); } }
public void Setup() { (c1, c2) = PipeConnection.CreatePipe(); }