public override WebSocketPackageInfo Handle(IAppSession session, WebSocketContext context, IList<ArraySegment<byte>> data)
 {
     var total = data.Sum(d => d.Count);
     var payloadLength = context.PayloadLength;
     var text = Encoding.UTF8.GetString(data, total - payloadLength, payloadLength);
     return new WebSocketPackageInfo(text, ServiceProvider.StringParser);
 }

        // As server
        internal WebSocket(HttpListenerWebSocketContext context, string protocol)
        {
            _context = context;
            _protocol = protocol;

            _closeContext = context.Close;
            _secure = context.IsSecureConnection;
            _stream = context.Stream;

            init();
        }

 internal WebSocket(TcpListenerWebSocketContext context)
     : this()
 {
     _uri       = context.Path.ToUri();
       _context   = context;
       _tcpClient = context.Client;
       _wsStream  = context.Stream;
       _endPoint  = context.ServerEndPoint;
       _isClient  = false;
       _isSecure  = context.IsSecureConnection;
 }

 // As server
 private bool customCheckHandshakeRequest (WebSocketContext context, out string message)
 {
   message = null;
   return _handshakeRequestChecker == null
          || (message = _handshakeRequestChecker (context)) == null;
 }

 // As server
 private string checkIfValidHandshakeRequest (WebSocketContext context)
 {
   var headers = context.Headers;
   return context.RequestUri == null
          ? "Specifies an invalid Request-URI."
          : !context.IsWebSocketRequest
            ? "Not a WebSocket connection request."
            : !validateSecWebSocketKeyHeader (headers["Sec-WebSocket-Key"])
              ? "Includes an invalid Sec-WebSocket-Key header."
              : !validateSecWebSocketVersionClientHeader (headers["Sec-WebSocket-Version"])
                ? "Includes an invalid Sec-WebSocket-Version header."
                : CustomHandshakeRequestChecker (context);
 }

 // As server
 private void init(WebSocketContext context)
 {
     _context = context;
       _uri = context.Path.ToUri ();
       _secure = context.IsSecureConnection;
       _client = false;
 }

 // As server
 private string checkIfValidHandshakeRequest(WebSocketContext context)
 {
     var headers = context.Headers;
       return !context.IsWebSocketRequest
      ? "Not WebSocket connection request."
      : !validateHostHeader (headers ["Host"])
        ? "Invalid Host header."
        : !validateSecWebSocketKeyHeader (headers ["Sec-WebSocket-Key"])
          ? "Invalid Sec-WebSocket-Key header."
          : !validateSecWebSocketVersionClientHeader (headers ["Sec-WebSocket-Version"])
            ? "Invalid Sec-WebSocket-Version header."
            : CustomHandshakeRequestChecker (context);
 }

        internal void Start(WebSocketContext context, WebSocketSessionManager sessions)
        {
            if (_websocket != null) {
            _websocket.Log.Error ("This session has already been started.");
            context.WebSocket.Close (HttpStatusCode.ServiceUnavailable);

            return;
              }

              _context = context;
              _sessions = sessions;

              _websocket = context.WebSocket;
              _websocket.CustomHandshakeRequestChecker = checkIfValidConnectionRequest;
              _websocket.EmitOnPing = _emitOnPing;
              _websocket.IgnoreExtensions = _ignoreExtensions;
              _websocket.Protocol = _protocol;

              var waitTime = sessions.WaitTime;
              if (waitTime != _websocket.WaitTime)
            _websocket.WaitTime = waitTime;

              _websocket.OnOpen += onOpen;
              _websocket.OnMessage += onMessage;
              _websocket.OnError += onError;
              _websocket.OnClose += onClose;

              _websocket.ConnectAsServer ();
        }

 public override WebSocketPackageInfo Handle(IAppSession session, WebSocketContext context, IList<ArraySegment<byte>> data)
 {
     return new WebSocketPackageInfo(data, ServiceProvider.BinaryDataParser, ServiceProvider.StringParser);
 }

 public static RequestHandshake Parse(WebSocketContext context)
 {
     return new RequestHandshake {
     Headers         = context.Headers,
     HttpMethod      = "GET",
     RequestUri      = context.RequestUri,
     ProtocolVersion = HttpVersion.Version11
       };
 }

 internal void StartSession(WebSocketContext context)
 {
     var session = CreateSession ();
       session.Start (context, Sessions);
 }

 // As server
 private string checkIfValidHandshakeRequest(WebSocketContext context)
 {
     var headers = context.Headers;
       return !context.IsWebSocketRequest
      ? "Not WebSocket connection request."
      : !validateHostHeader (headers ["Host"])
        ? "Invalid Host header."
        : !validateSecWebSocketKeyHeader (headers ["Sec-WebSocket-Key"])
          ? "Invalid Sec-WebSocket-Key header."
          : !validateSecWebSocketVersionClientHeader (headers ["Sec-WebSocket-Version"])
            ? "Invalid Sec-WebSocket-Version header."
            : !validateCookies (context.CookieCollection, _cookies)
              ? "Invalid Cookies."
              : null;
 }

 public abstract WebSocketPackageInfo Handle(IAppSession session, WebSocketContext context, IList<ArraySegment<byte>> data);

 private string checkHandshakeRequest(WebSocketContext context)
 {
     return _originValidator != null && !_originValidator (context.Origin)
      ? "Includes no Origin header, or it has an invalid value."
      : _cookiesValidator != null
        && !_cookiesValidator (context.CookieCollection, context.WebSocket.CookieCollection)
        ? "Includes no cookie, or an invalid cookie exists."
        : null;
 }

        /// <summary>
        /// Starts a new session to the WebSocket service using the specified <see cref="WebSocketContext"/>.
        /// </summary>
        /// <param name="context">
        /// A <see cref="WebSocketContext"/> that contains a WebSocket connection request objects.
        /// </param>
        /// <exception cref="ArgumentNullException">
        /// <paramref name="context"/> is <see langword="null"/>.
        /// </exception>
        internal void StartSession(WebSocketContext context)
        {
            if (context == null)
            throw new ArgumentNullException ("context");

              var session = CreateSession ();
              session.Start (context, Sessions);
        }

 private string checkIfValidConnectionRequest(WebSocketContext context)
 {
     return _originValidator != null && !_originValidator (context.Origin)
      ? "Invalid Origin header."
      : _cookiesValidator != null &&
        !_cookiesValidator (context.CookieCollection, context.WebSocket.CookieCollection)
        ? "Invalid Cookies."
        : null;
 }

        // As server
        internal WebSocket(TcpListenerWebSocketContext context, string protocol, Logger logger)
        {
            _context = context;
              _protocol = protocol;
              _logger = logger;

              _closeContext = context.Close;
              _secure = context.IsSecureConnection;
              _stream = context.Stream;

              init ();
        }

        internal void Bind(WebSocketContext context, WebSocketServiceManager sessions)
        {
            if (IsBound)
            return;

              _context = context;
              _sessions = sessions;
              _websocket = context.WebSocket;
              _websocket.CookiesValidation = ValidateCookies;
              _websocket.OnOpen += onOpen;
              _websocket.OnMessage += onMessage;
              _websocket.OnError += onError;
              _websocket.OnClose += onClose;

              IsBound = true;
        }

        internal void Start(WebSocketContext context, WebSocketSessionManager sessions)
        {
            _context = context;
              _sessions = sessions;

              _websocket = context.WebSocket;
              _websocket.Protocol = _protocol;
              _websocket.CookiesValidation = ValidateCookies;

              _websocket.OnOpen += onOpen;
              _websocket.OnMessage += onMessage;
              _websocket.OnError += onError;
              _websocket.OnClose += onClose;

              _websocket.ConnectAsServer ();
        }

        // As server
        internal WebSocket(TcpListenerWebSocketContext context, Logger logger)
        {
            _context = context;
              _logger = logger;

              _closeContext = context.Close;
              _secure = context.IsSecureConnection;
              _stream = context.Stream;
              _uri = context.Path.ToUri ();

              init ();
        }