public ClientConnection(MessageEnvelope envelope, INetworkTransport client) { this.client = client; Envelope = envelope; ClientId = Guid.NewGuid(); }
public virtual void Stop() { if (transport != null) { transport.Destroy(); transport = null; } }
public TvDiscovery(IDeviceDiscovery upnpDiscovery, INetworkTransport networkTransport) { this.transport = networkTransport; this.upnpDiscovery = upnpDiscovery; this.upnpDiscovery.DeviceConnected += new EventHandler <DeviceInfoEventArgs>(this.upnpDiscovery_DeviceConnected); this.upnpDiscovery.DeviceDisconnected += new EventHandler <DeviceInfoEventArgs>(this.upnpDiscovery_DeviceDisconnected); this.devicePool = new DevicePool(); this.devicePool.DeviceAdded += new EventHandler <DeviceInfoEventArgs>(this.devicePool_DeviceAdded); this.devicePool.DeviceRemoved += new EventHandler <DeviceInfoEventArgs>(this.devicePool_DeviceRemoved); }
internal void StartServer() { INIT(); if (m_activeTransport == null) { m_activeTransport = new BaseServerTransport(m_MessageHandlers); } m_activeTransport.SetOperational(true); m_activeTransport.StartListening(); }
internal void StartClient() { INIT(); if (m_activeTransport == null) { m_activeTransport = new BaseClientTransport(m_MessageHandlers); } m_activeTransport.SetOperational(true); m_activeTransport.StartClient(); }
private async Task DoConnect(TcpClient client, string hostname, bool text, bool tls, bool verify_tls, bool buffered) { Stream stm; _client = client; _client.NoDelay = true; if (tls) { RemoteCertificateValidationCallback validation = verify_tls ? new RemoteCertificateValidationCallback(ValidateRemoteConnection) : new RemoteCertificateValidationCallback(ValidateRemoteConnectionBypass); SslStream sslStream = new SslStream(_client.GetStream(), false, validation); int lastTimeout = sslStream.ReadTimeout; sslStream.ReadTimeout = 3000; await sslStream.AuthenticateAsClientAsync(hostname); Console.WriteLine("TLS Protocol: {0}", SslProtocolToString(sslStream.SslProtocol)); Console.WriteLine("TLS KeyEx : {0}", KeyExToString(sslStream.KeyExchangeAlgorithm)); Console.WriteLine("TLS Cipher: {0}", sslStream.CipherAlgorithm); Console.WriteLine("TLS Hash: {0}", sslStream.HashAlgorithm); Console.WriteLine("Cert Subject: {0}", sslStream.RemoteCertificate.Subject); Console.WriteLine("Cert Issuer : {0}", sslStream.RemoteCertificate.Issuer); sslStream.ReadTimeout = lastTimeout; stm = sslStream; } else { stm = _client.GetStream(); } _base_stream = new XorStream(stm); if (text) { NetworkUtils.WriteNetworkOrderInt32(_base_stream, NetworkUtils.TEXT_MAGIC); _transport = new TextNetworkTransport(_base_stream); } else { NetworkUtils.WriteNetworkOrderInt32(_base_stream, NetworkUtils.BINARY_MAGIC); _transport = new BinaryNetworkTransport(_base_stream, buffered); } }
unsafe public NetworkServer(INetworkTransport transport) { _transport = transport; serverInfo = new ServerInfo(); // Allocate array to hold world snapshots m_Snapshots = new WorldSnapshot[NetworkConfig.snapshotDeltaCacheSize]; for (int i = 0; i < m_Snapshots.Length; ++i) { m_Snapshots[i] = new WorldSnapshot(); m_Snapshots[i].data = (uint *)UnsafeUtility.Malloc(NetworkConfig.maxWorldSnapshotDataSize, UnsafeUtility.AlignOf <UInt32>(), Unity.Collections.Allocator.Persistent); } // Allocate scratch buffer to hold predictions. This is overwritten every time // a snapshot is being written to a specific client m_Prediction = (uint *)UnsafeUtility.Malloc(NetworkConfig.maxWorldSnapshotDataSize, UnsafeUtility.AlignOf <UInt32>(), Unity.Collections.Allocator.Persistent); }
private void Run() { while (running) { try { INetworkTransport transport = listener.AcceptClient(0); logger.Info("New connection from : " + transport.RemoteEndPoint); ClientConnection channel = ClientConnection.CreateClientConnection(transport, Envelope); lock (clientLock) { clients.Add(channel); } OnChannelConnected(this, new ClientEventArgs(channel)); channel.ClientClosed += OnClientClosed; } catch (SocketException) { // This is here because AcceptTcpClient throws an exception when we tell it // stop listening. logger.Debug("ChannelListener shutdown. No longer accepting connections"); } catch (IOException ex) { logger.Warn(ex.Message, ex); if (ex.InnerException != null) { logger.Warn("Inner Exception: " + ex.InnerException.Message, ex.InnerException); } } catch (Exception ex) { // Catch everything to make sure server remains running logger.Fatal("Exception catchall: " + ex.Message, ex); if (ex.InnerException != null) { logger.Fatal("Inner Exception: " + ex.InnerException.Message, ex.InnerException); } running = false; listener.Stop(); } } }
private void ServerMain() { listener.Start(); while (!IsStopped) { try { INetworkTransport client = listener.AcceptClient(); if (client != null) { ClientConnection channel = ClientConnection.CreateClientConnection( new ProtoBuffEnvelope(registry), client); channel.ClientId = Guid.NewGuid(); Logger.Info("New connection from : " + client.RemoteEndPoint); lock (clientSync) { _connectionList.Add(channel.ClientId, channel); } OnClientConnected(channel.ClientId, channel, client.RemoteEndPoint.ToString()); channel.ClientClosed += OnClientDisconnected; channel.MessageReceived += OnMessageReceived; } } catch (SocketException) { // This is here because AcceptTcpClient throws an exception when we tell it // stop listening. Logger.Debug("SocketServer shutdown. No longer accepting connections"); } } }
public override async Task OnRTPPacket(byte[] packet) { RTPSessionState[] transports = null; lock (Sessions) { transports = Sessions.Values.ToArray(); } foreach (var transport in transports) { INetworkTransport network = transport.RTPTransport; IPEndPoint endPoint = transport.RTPIPEndPoint; try { bool success = await network.SendPacket(packet, endPoint); } catch (Exception ex) { _logger.Error(ex); } } }
/// <summary> /// Creates a controller channel with a transport that is able to handle incoming messages /// using the given envelope and dispatcher /// </summary> /// <param name="transport">A transport used to send/receive messages</param> /// <param name="envelope"></param> /// <param name="dispatcher">A MessageDispatcher to route messages to appropriate handlers</param> public ClientConnection(INetworkTransport transport, Envelope envelope, MessageDispatcher dispatcher) { Initialize(transport, envelope, dispatcher); }
/// <summary> /// Creates a controller channel with a default TCP transport that is able to handle incoming messages /// using the given dispatcher /// </summary> /// <param name="transport">A transport used to send/receive messages</param> /// <param name="dispatcher">A MessageDispatcher to route messages to appropriate handlers</param> public ClientConnection(INetworkTransport transport, MessageDispatcher dispatcher) { Initialize(transport, new PlainEnvelope(), dispatcher); }
/// <summary> /// Creates a controller channel with the given transport /// </summary> /// <param name="transport">The transport for the channel to communicate over</param> public Channel(INetworkTransport transport) { Initialize(transport, new PlainEnvelope(), new MessageDispatcher()); }
public NetworkClientManager(INetworkTransport transport, INetSerializer serializer) : base(transport) { msgManager = new MessageManager(serializer, false); }
public NetworkClient(INetworkTransport transport) { m_Transport = transport; clientConfig = new ClientConfig(); }
public static ClientConnection CreateClientConnection(MessageEnvelope envelope, INetworkTransport client) { ClientConnection connection = new ClientConnection(envelope, client); connection.StartReceiveThread(); return connection; }
public static ClientConnection CreateClientConnection(MessageEnvelope envelope, INetworkTransport client) { ClientConnection connection = new ClientConnection(envelope, client); connection.StartReceiveThread(); return(connection); }
public ClientConnection(INetworkTransport transport) : this(transport, new PlainEnvelope()) { }
public NetworkManagerBase(INetworkTransport transport) { this.transport = transport; }
public NetworkServerManager(INetworkTransport transport, INetSerializer serializer) : base(transport) { msgManager = new MessageManager(serializer, true); }
public ClientConnection(int connectionId, INetworkTransport transport, ClientConfig clientConfig) : base(connectionId, transport) { this.clientConfig = clientConfig; }
public ushort outSequenceAckMask; // The mask describing which of the last packaged have been acked related to outSequence public NetworkConnection(int connectionId, INetworkTransport transport) { ConnectionId = connectionId; Transport = transport; }