Esempio n. 1
0
        public async Task Listen(int port)
        {
            var fac = new WebSocketServerFactory();

            Log.LogInformation($"Started listening for network calls on port {port}");
            var listener = new TcpListener(IPAddress.Loopback, port);

            listener.Start();

            while (true)
            {
                var token = new CancellationToken();
                var tcp   = listener.AcceptTcpClient();
                Log.LogInformation("Client connected.");

                try
                {
                    var stream  = tcp.GetStream();
                    var context = await fac.ReadHttpHeaderFromStreamAsync(stream);

                    var server = await fac.AcceptWebSocketAsync(context);

                    if (context.IsWebSocketRequest)
                    {
                        HandleIncoming(server, token);
                    }
                }
                catch (Exception e)
                {
                    Log.LogWarning(e, "Could not accept tcp stream.");
                    break;
                }
            }
        }
        public async Task <WebSocket> AcceptWebSocketAsync()
        {
            var tcpClient = await _tcpListener.AcceptTcpClientAsync();

            var factory = new WebSocketServerFactory();
            WebSocketHttpContext context = await factory.ReadHttpHeaderFromStreamAsync(tcpClient.GetStream());

            Assert.True(context.IsWebSocketRequest);
            return(await factory.AcceptWebSocketAsync(context));
        }
Esempio n. 3
0
        public async void Run(CancellationToken cancellationToken)
        {
            var stream  = _connectedClient.GetStream();
            var factory = new WebSocketServerFactory();

            try
            {
                var context = await factory.ReadHttpHeaderFromStreamAsync(stream, cancellationToken);

                if (!context.IsWebSocketRequest)
                {
                    _connectedClient.Close();
                    return;
                }

                var webSocket = await factory.AcceptWebSocketAsync(context, cancellationToken);

                await Receive(webSocket, cancellationToken);
            }
            catch (OperationCanceledException)
            {
            }
        }