Inheritance: IDisposable
        public static WebSocket CreateClientWebSocket(Stream innerStream,
                                                      string subProtocol,
                                                      int receiveBufferSize,
                                                      int sendBufferSize,
                                                      TimeSpan keepAliveInterval,
                                                      bool useZeroMaskingKey,
                                                      ArraySegment <byte> internalBuffer)
        {
            if (!WebSocketProtocolComponent.IsSupported)
            {
                WebSocketHelpers.ThrowPlatformNotSupportedException_WSPC();
            }

            WebSocketHelpers.ValidateInnerStream(innerStream);
            WebSocketHelpers.ValidateOptions(subProtocol, receiveBufferSize, sendBufferSize, keepAliveInterval);
            WebSocketHelpers.ValidateArraySegment <byte>(internalBuffer, "internalBuffer");
            WebSocketBuffer.Validate(internalBuffer.Count, receiveBufferSize, sendBufferSize, false);

            return(new InternalClientWebSocket(innerStream,
                                               subProtocol,
                                               receiveBufferSize,
                                               sendBufferSize,
                                               keepAliveInterval,
                                               useZeroMaskingKey,
                                               internalBuffer));
        }
Example #2
0
        public void SetBuffer(int receiveBufferSize, int sendBufferSize, ArraySegment <byte> buffer)
        {
            ThrowIfReadOnly();
            WebSocketHelpers.ValidateBufferSizes(receiveBufferSize, sendBufferSize);
            WebSocketHelpers.ValidateArraySegment(buffer, "buffer");
            WebSocketBuffer.Validate(buffer.Count, receiveBufferSize, sendBufferSize, false);

            this.receiveBufferSize = receiveBufferSize;
            this.sendBufferSize    = sendBufferSize;

            // Only full-trust applications can specify their own buffer to be used as the
            // internal buffer for the WebSocket object.  This is because the contents of the
            // buffer are used internally by the WebSocket as it marshals data with embedded
            // pointers to native code.  A malicious application could use this to corrupt
            // native memory.
            if (AppDomain.CurrentDomain.IsFullyTrusted)
            {
                this.buffer = buffer;
            }
            else
            {
                // We silently ignore the passed in buffer and will create an internal
                // buffer later.
                this.buffer = null;
            }
        }
        public void SetBuffer(int receiveBufferSize, int sendBufferSize, ArraySegment <byte> buffer)
        {
            ThrowIfReadOnly();
            WebSocketHelpers.ValidateBufferSizes(receiveBufferSize, sendBufferSize);
            WebSocketHelpers.ValidateArraySegment(buffer, "buffer");
            WebSocketBuffer.Validate(buffer.Count, receiveBufferSize, sendBufferSize, false);

            this.receiveBufferSize = receiveBufferSize;
            this.sendBufferSize    = sendBufferSize;
            this.buffer            = buffer;
        }
Example #4
0
        internal static Task <HttpListenerWebSocketContext> AcceptWebSocketAsync(HttpListenerContext context,
                                                                                 string subProtocol,
                                                                                 int receiveBufferSize,
                                                                                 TimeSpan keepAliveInterval,
                                                                                 ArraySegment <byte> internalBuffer)
        {
            ValidateOptions(subProtocol, receiveBufferSize, MinSendBufferSize, keepAliveInterval);
            WebSocketValidate.ValidateArraySegment(internalBuffer, nameof(internalBuffer));
            WebSocketBuffer.Validate(internalBuffer.Count, receiveBufferSize, MinSendBufferSize, true);

            return(AcceptWebSocketAsyncCore(context, subProtocol, receiveBufferSize, keepAliveInterval, internalBuffer));
        }
Example #5
0
        public InternalClientWebSocket(Stream innerStream, string subProtocol, int receiveBufferSize, int sendBufferSize,
                                       TimeSpan keepAliveInterval, bool useZeroMaskingKey, ArraySegment <byte> internalBuffer)
            : base(innerStream, subProtocol, keepAliveInterval,
                   WebSocketBuffer.CreateClientBuffer(internalBuffer, receiveBufferSize, sendBufferSize))
        {
            m_Properties    = this.InternalBuffer.CreateProperties(useZeroMaskingKey);
            m_SessionHandle = this.CreateWebSocketHandle();

            if (m_SessionHandle == null || m_SessionHandle.IsInvalid)
            {
                WebSocketHelpers.ThrowPlatformNotSupportedException_WSPC();
            }

            StartKeepAliveTimer();
        }
        public ServerWebSocket(Stream innerStream,
                               string subProtocol,
                               int receiveBufferSize,
                               TimeSpan keepAliveInterval,
                               ArraySegment <byte> internalBuffer)
            : base(innerStream, subProtocol, keepAliveInterval,
                   WebSocketBuffer.CreateServerBuffer(internalBuffer, receiveBufferSize))
        {
            _properties    = InternalBuffer.CreateProperties(false);
            _sessionHandle = CreateWebSocketHandle();

            if (_sessionHandle == null || _sessionHandle.IsInvalid)
            {
                WebSocketValidate.ThrowPlatformNotSupportedException_WSPC();
            }

            StartKeepAliveTimer();
        }
        internal static WebSocket Create(Stream innerStream,
                                         string subProtocol,
                                         int receiveBufferSize,
                                         TimeSpan keepAliveInterval,
                                         ArraySegment <byte> internalBuffer)
        {
            if (!WebSocketProtocolComponent.IsSupported)
            {
                WebSocketValidate.ThrowPlatformNotSupportedException_WSPC();
            }

            WebSocketValidate.ValidateInnerStream(innerStream);
            WebSocketValidate.ValidateOptions(subProtocol, receiveBufferSize, WebSocketBuffer.MinSendBufferSize, keepAliveInterval);
            WebSocketValidate.ValidateArraySegment <byte>(internalBuffer, nameof(internalBuffer));
            WebSocketBuffer.Validate(internalBuffer.Count, receiveBufferSize, WebSocketBuffer.MinSendBufferSize, true);

            return(new ServerWebSocket(innerStream,
                                       subProtocol,
                                       receiveBufferSize,
                                       keepAliveInterval,
                                       internalBuffer));
        }
Example #8
0
        protected WebSocketBase(Stream innerStream,
            string subProtocol,
            TimeSpan keepAliveInterval,
            WebSocketBuffer internalBuffer)
        {
            Debug.Assert(internalBuffer != null, "'internalBuffer' MUST NOT be NULL.");
            WebSocketValidate.ValidateInnerStream(innerStream);
            WebSocketValidate.ValidateOptions(subProtocol, internalBuffer.ReceiveBufferSize,
                internalBuffer.SendBufferSize, keepAliveInterval);

            string parameters = string.Empty;

            if (NetEventSource.IsEnabled)
            {
                parameters = string.Format(CultureInfo.InvariantCulture,
                    "ReceiveBufferSize: {0}, SendBufferSize: {1},  Protocols: {2}, KeepAliveInterval: {3}, innerStream: {4}, internalBuffer: {5}",
                    internalBuffer.ReceiveBufferSize,
                    internalBuffer.SendBufferSize,
                    subProtocol,
                    keepAliveInterval,
                    NetEventSource.GetHashCode(innerStream),
                    NetEventSource.GetHashCode(internalBuffer));

                NetEventSource.Enter(this, parameters);
            }

            _thisLock = new object();

            try
            {
                _innerStream = innerStream;
                _internalBuffer = internalBuffer;
                if (NetEventSource.IsEnabled)
                {
                    NetEventSource.Associate(this, _innerStream);
                    NetEventSource.Associate(this, _internalBuffer);
                }

                _closeOutstandingOperationHelper = new OutstandingOperationHelper();
                _closeOutputOutstandingOperationHelper = new OutstandingOperationHelper();
                _receiveOutstandingOperationHelper = new OutstandingOperationHelper();
                _sendOutstandingOperationHelper = new OutstandingOperationHelper();
                _state = WebSocketState.Open;
                _subProtocol = subProtocol;
                _sendFrameThrottle = new SemaphoreSlim(1, 1);
                _closeStatus = null;
                _closeStatusDescription = null;
                _innerStreamAsWebSocketStream = innerStream as IWebSocketStream;
                if (_innerStreamAsWebSocketStream != null)
                {
                    _innerStreamAsWebSocketStream.SwitchToOpaqueMode(this);
                }
                _keepAliveTracker = KeepAliveTracker.Create(keepAliveInterval);
            }
            finally
            {
                if (NetEventSource.IsEnabled)
                {
                    NetEventSource.Exit(this, parameters);
                }
            }
        }
Example #9
0
        protected WebSocketBase(Stream innerStream,
            string subProtocol,
            TimeSpan keepAliveInterval,
            WebSocketBuffer internalBuffer)
        {
            Contract.Assert(internalBuffer != null, "'internalBuffer' MUST NOT be NULL.");
            WebSocketHelpers.ValidateInnerStream(innerStream);
            WebSocketHelpers.ValidateOptions(subProtocol, internalBuffer.ReceiveBufferSize,
                internalBuffer.SendBufferSize, keepAliveInterval);

            s_LoggingEnabled = Logging.On && Logging.WebSockets.Switch.ShouldTrace(TraceEventType.Critical);
            string parameters = string.Empty;

            if (s_LoggingEnabled)
            {
                parameters = string.Format(CultureInfo.InvariantCulture,
                    "ReceiveBufferSize: {0}, SendBufferSize: {1},  Protocols: {2}, KeepAliveInterval: {3}, innerStream: {4}, internalBuffer: {5}",
                    internalBuffer.ReceiveBufferSize,
                    internalBuffer.SendBufferSize,
                    subProtocol,
                    keepAliveInterval,
                    Logging.GetObjectLogHash(innerStream),
                    Logging.GetObjectLogHash(internalBuffer));

                Logging.Enter(Logging.WebSockets, this, Methods.Initialize, parameters);
            }

            m_ThisLock = new object();

            try
            {
                m_InnerStream = innerStream;
                m_InternalBuffer = internalBuffer;
                if (s_LoggingEnabled)
                {
                    Logging.Associate(Logging.WebSockets, this, m_InnerStream);
                    Logging.Associate(Logging.WebSockets, this, m_InternalBuffer);
                }

                m_CloseOutstandingOperationHelper = new OutstandingOperationHelper();
                m_CloseOutputOutstandingOperationHelper = new OutstandingOperationHelper();
                m_ReceiveOutstandingOperationHelper = new OutstandingOperationHelper();
                m_SendOutstandingOperationHelper = new OutstandingOperationHelper();
                m_State = WebSocketState.Open;
                m_SubProtocol = subProtocol;
                m_SendFrameThrottle = new SemaphoreSlim(1, 1);
                m_CloseStatus = null;
                m_CloseStatusDescription = null;
                m_InnerStreamAsWebSocketStream = innerStream as IWebSocketStream;
                if (m_InnerStreamAsWebSocketStream != null)
                {
                    m_InnerStreamAsWebSocketStream.SwitchToOpaqueMode(this);
                }
                m_KeepAliveTracker = KeepAliveTracker.Create(keepAliveInterval);
            }
            finally
            {
                if (s_LoggingEnabled)
                {
                    Logging.Exit(Logging.WebSockets, this, Methods.Initialize, parameters);
                }
            }
        }
        public static ArraySegment <byte> CreateServerBuffer(int receiveBufferSize)
        {
            WebSocketHelpers.ValidateBufferSizes(receiveBufferSize, WebSocketBuffer.MinSendBufferSize);

            return(WebSocketBuffer.CreateInternalBufferArraySegment(receiveBufferSize, WebSocketBuffer.MinSendBufferSize, true));
        }
        public static ArraySegment <byte> CreateClientBuffer(int receiveBufferSize, int sendBufferSize)
        {
            WebSocketHelpers.ValidateBufferSizes(receiveBufferSize, sendBufferSize);

            return(WebSocketBuffer.CreateInternalBufferArraySegment(receiveBufferSize, sendBufferSize, false));
        }