/// <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();
}
