internal async Task <Int32> ReadInternalAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
        {
            CancellationTokenRegistration reg = cancellationToken.Register(this.Close, false);

            try
            {
                var readed = await _clientStream.ReadAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);

                CurrentHeader.DecodeBytes(buffer, offset, readed);
                return(readed);
            }
            catch (InvalidOperationException)
            {
                this.Close(WebSocketCloseReasons.UnexpectedCondition);
                return(0);
            }
            catch (IOException)
            {
                this.Close(WebSocketCloseReasons.UnexpectedCondition);
                return(0);
            }
            finally
            {
                reg.Dispose();
            }
        }
        private async Task ProcessPingPongAsync()
        {
            var contentLength = _pongBuffer.Count;

            if (CurrentHeader.ContentLength < 125)
            {
                contentLength = (int)CurrentHeader.ContentLength;
            }
            var readed = 0;

            while (CurrentHeader.RemainingBytes > 0)
            {
                readed = await _clientStream.ReadAsync(_pongBuffer.Array, _pongBuffer.Offset + readed, contentLength - readed).ConfigureAwait(false);

                CurrentHeader.DecodeBytes(_pongBuffer.Array, _pongBuffer.Offset, readed);
            }

            if (CurrentHeader.Flags.Option == WebSocketFrameOption.Pong)
            {
                _ping.NotifyPong(_pongBuffer);
            }
            else
            {// pong frames echo what was 'pinged'
                await WriteInternalAsync(_pongBuffer, readed, true, false, WebSocketFrameOption.Pong, WebSocketExtensionFlags.None, CancellationToken.None).ConfigureAwait(false);
            }
        }
        private void ProcessPingPong()
        {
            var contentLength = _pongBuffer.Count;

            if (CurrentHeader.ContentLength < 125)
            {
                contentLength = (int)CurrentHeader.ContentLength;
            }

            var readed = 0;

            while (CurrentHeader.RemainingBytes > 0)
            {
                readed = _clientStream.Read(_pongBuffer.Array, _pongBuffer.Offset + readed, contentLength - readed);
                CurrentHeader.DecodeBytes(_pongBuffer.Array, _pongBuffer.Offset, readed);
            }

            if (CurrentHeader.Flags.Option == WebSocketFrameOption.Pong)
            {
                _ping.NotifyPong(_pongBuffer);
            }
            else
            {// pong frames echo what was 'pinged'
                WriteInternal(_pongBuffer, readed, true, false, WebSocketFrameOption.Pong, WebSocketExtensionFlags.None);
            }
        }
        private void ProcessControlFrame(Stream clientStream)
        {
            switch (CurrentHeader.Flags.Option)
            {
            case WebSocketFrameOption.Continuation:
            case WebSocketFrameOption.Text:
            case WebSocketFrameOption.Binary:
                throw new WebSocketException("Text, Continuation or Binary are not protocol frames");

            case WebSocketFrameOption.ConnectionClose:
                this.Close(WebSocketCloseReasons.NormalClose);
                break;

            case WebSocketFrameOption.Ping:
            case WebSocketFrameOption.Pong:
                Int32 contentLength = _pongBuffer.Count;
                if (CurrentHeader.ContentLength < 125)
                {
                    contentLength = (Int32)CurrentHeader.ContentLength;
                }
                Int32 readed = 0;
                while (CurrentHeader.RemainingBytes > 0)
                {
                    readed = clientStream.Read(_pongBuffer.Array, _pongBuffer.Offset + readed, contentLength - readed);
                    CurrentHeader.DecodeBytes(_pongBuffer.Array, _pongBuffer.Offset, readed);
                }

                if (CurrentHeader.Flags.Option == WebSocketFrameOption.Pong)
                {
                    var now = DateTime.Now;
                    _lastPong = now;
                    var timestamp = BitConverter.ToInt64(_pongBuffer.Array, _pongBuffer.Offset);
                    Latency = TimeSpan.FromTicks((now.Ticks - timestamp) / 2);
                }
                else     // pong frames echo what was 'pinged'
                {
                    this.WriteInternal(_pongBuffer, readed, true, false, WebSocketFrameOption.Pong, WebSocketExtensionFlags.None);
                }

                break;

            default: throw new WebSocketException("Unexpected header option '" + CurrentHeader.Flags.Option.ToString() + "'");
            }
        }
 internal Int32 ReadInternal(Byte[] buffer, Int32 offset, Int32 count)
 {
     try
     {
         var readed = _clientStream.Read(buffer, offset, count);
         CurrentHeader.DecodeBytes(buffer, offset, readed);
         return(readed);
     }
     catch (InvalidOperationException)
     {
         this.Close(WebSocketCloseReasons.UnexpectedCondition);
         return(0);
     }
     catch (IOException)
     {
         this.Close(WebSocketCloseReasons.UnexpectedCondition);
         return(0);
     }
 }
Beispiel #6
0
        private void ProcessControlFrame(Stream clientStream)
        {
            switch (CurrentHeader.Flags.Option)
            {
            case WebSocketFrameOption.ConnectionClose:
                this.Close(WebSocketCloseReasons.NormalClose);
                break;

            case WebSocketFrameOption.Ping:
            case WebSocketFrameOption.Pong:
                Int32 contentLength = _pongBuffer.Count;
                if (CurrentHeader.ContentLength < 125)
                {
                    contentLength = (Int32)CurrentHeader.ContentLength;
                }
                Int32 readed = 0;
                while (CurrentHeader.RemainingBytes > 0)
                {
                    readed = clientStream.Read(_pongBuffer.Array, _pongBuffer.Offset + readed, contentLength - readed);
                    CurrentHeader.DecodeBytes(_pongBuffer.Array, _pongBuffer.Offset, readed);
                }

                if (CurrentHeader.Flags.Option == WebSocketFrameOption.Pong)
                {
                    _ping.NotifyPong(_pongBuffer);
                }
                else     // pong frames echo what was 'pinged'
                {
                    this.WriteInternal(_pongBuffer, readed, true, false, WebSocketFrameOption.Pong, WebSocketExtensionFlags.None);
                }

                break;

            default: throw new WebSocketException("Unexpected header option '" + CurrentHeader.Flags.Option + "'");
            }
        }