#region License

/*

* WebSocket.cs

*

* A C# implementation of the WebSocket interface.

*

* This code is derived from WebSocket.java

* (http://github.com/adamac/Java-WebSocket-client).

*

* The MIT License

*

* Copyright (c) 2009 Adam MacBeth

* Copyright (c) 2010-2016 sta.blockhead

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

*/

#endregion

#region Contributors

/*

* Contributors:

* - Frank Razenberg <frank@zzattack.org>

* - David Wood <dpwood@gmail.com>

* - Liryna <liryna.stark@gmail.com>

*/

#endregion

using System;

using System.Collections;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.Diagnostics;

using System.IO;

using System.Net.Security;

using System.Net.Sockets;

using System.Security.Cryptography;

using System.Text;

using System.Threading;

using WebSocketSharp.Net;

using WebSocketSharp.Net.WebSockets;

namespace WebSocketSharp

{

/// <summary>

/// Implements the WebSocket interface.

/// </summary>

/// <remarks>

/// The WebSocket class provides a set of methods and properties for two-way communication using

/// the WebSocket protocol (<see href="http://tools.ietf.org/html/rfc6455">RFC 6455</see>).

/// </remarks>

public class WebSocket : IDisposable

{

#region Private Fields

private AuthenticationChallenge _authChallenge;

private string _base64Key;

private bool _client;

private Action _closeContext;

private CompressionMethod _compression;

private WebSocketContext _context;

private CookieCollection _cookies;

private NetworkCredential _credentials;

private bool _emitOnPing;

private bool _enableRedirection;

private AutoResetEvent _exitReceiving;

private string _extensions;

private bool _extensionsRequested;

private object _forConn;

private object _forMessageEventQueue;

private object _forSend;

private MemoryStream _fragmentsBuffer;

private bool _fragmentsCompressed;

private Opcode _fragmentsOpcode;

private const string _guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

private Func<WebSocketContext, string> _handshakeRequestChecker;

private bool _ignoreExtensions;

private bool _inContinuation;

private volatile bool _inMessage;

private volatile Logger _logger;

private Action<MessageEventArgs> _message;

private Queue<MessageEventArgs> _messageEventQueue;

private uint _nonceCount;

private string _origin;

private bool _preAuth;

private string _protocol;

private string[] _protocols;

private bool _protocolsRequested;

private NetworkCredential _proxyCredentials;

private Uri _proxyUri;

private volatile WebSocketState _readyState;

private AutoResetEvent _receivePong;

private bool _secure;

private ClientSslConfiguration _sslConfig;

private Stream _stream;

private TcpClient _tcpClient;

private Uri _uri;

private const string _version = "13";

private TimeSpan _waitTime;

#endregion

#region Internal Fields

/// <summary>

/// Represents the empty array of <see cref="byte"/> used internally.

/// </summary>

internal static readonly byte[] EmptyBytes;

/// <summary>

/// Represents the length used to determine whether the data should be fragmented in sending.

/// </summary>

/// <remarks>

/// <para>

/// The data will be fragmented if that length is greater than the value of this field.

/// </para>

/// <para>

/// If you would like to change the value, you must set it to a value between <c>125</c> and

/// <c>Int32.MaxValue - 14</c> inclusive.

/// </para>

/// </remarks>

internal static readonly int FragmentLength;

/// <summary>

/// Represents the random number generator used internally.

/// </summary>

internal static readonly RandomNumberGenerator RandomNumber;

#endregion

#region Static Constructor

static WebSocket ()

{

EmptyBytes = new byte[0];

FragmentLength = 1016;

RandomNumber = new RNGCryptoServiceProvider ();

}

#endregion

#region Internal Constructors

// As server

internal WebSocket (HttpListenerWebSocketContext context, string protocol)

{

_context = context;

_protocol = protocol;

_closeContext = context.Close;

_logger = context.Log;

_message = messages;

_secure = context.IsSecureConnection;

_stream = context.Stream;

_waitTime = TimeSpan.FromSeconds (1);

init ();

}

// As server

internal WebSocket (TcpListenerWebSocketContext context, string protocol)

{

_context = context;

_protocol = protocol;

_closeContext = context.Close;

_logger = context.Log;

_message = messages;

_secure = context.IsSecureConnection;

_stream = context.Stream;

_waitTime = TimeSpan.FromSeconds (1);

init ();

}

#endregion

#region Public Constructors

/// <summary>

/// Initializes a new instance of the <see cref="WebSocket"/> class with

/// the specified WebSocket URL and subprotocols.

/// </summary>

/// <param name="url">

/// A <see cref="string"/> that represents the WebSocket URL to connect.

/// </param>

/// <param name="protocols">

/// An array of <see cref="string"/> that contains the WebSocket subprotocols if any.

/// Each value of <paramref name="protocols"/> must be a token defined in

/// <see href="http://tools.ietf.org/html/rfc2616#section-2.2">RFC 2616</see>.

/// </param>

/// <exception cref="ArgumentNullException">

/// <paramref name="url"/> is <see langword="null"/>.

/// </exception>

/// <exception cref="ArgumentException">

/// <para>

/// <paramref name="url"/> is invalid.

/// </para>

/// <para>

/// -or-

/// </para>

/// <para>

/// <paramref name="protocols"/> is invalid.

/// </para>

/// </exception>

public WebSocket (string url, params string[] protocols)

{

if (url == null)

throw new ArgumentNullException ("url");

if (url.Length == 0)

throw new ArgumentException ("An empty string.", "url");

string msg;

if (!url.TryCreateWebSocketUri (out _uri, out msg))

throw new ArgumentException (msg, "url");

if (protocols != null && protocols.Length > 0) {

msg = protocols.CheckIfValidProtocols ();

if (msg != null)

throw new ArgumentException (msg, "protocols");

_protocols = protocols;

}

_base64Key = CreateBase64Key ();

_client = true;

_logger = new Logger ();

_message = messagec;

_secure = _uri.Scheme == "wss";

_waitTime = TimeSpan.FromSeconds (5);

init ();

}

#endregion

#region Internal Properties

internal CookieCollection CookieCollection {

get {

return _cookies;

}

}

// As server

internal Func<WebSocketContext, string> CustomHandshakeRequestChecker {

get {

return _handshakeRequestChecker;

}

set {

_handshakeRequestChecker = value;

}

}

internal bool HasMessage {

get {

lock (_forMessageEventQueue)

return _messageEventQueue.Count > 0;

}

}

// As server

internal bool IgnoreExtensions {

get {

return _ignoreExtensions;

}

set {

_ignoreExtensions = value;

}

}

internal bool IsConnected {

get {

return _readyState == WebSocketState.Open || _readyState == WebSocketState.Closing;

}

}

#endregion

#region Public Properties

/// <summary>

/// Gets or sets the compression method used to compress a message on the WebSocket connection.

/// </summary>

/// <value>

/// One of the <see cref="CompressionMethod"/> enum values, specifies the compression method

/// used to compress a message. The default value is <see cref="CompressionMethod.None"/>.

/// </value>

public CompressionMethod Compression {

get {

return _compression;

}

set {

lock (_forConn) {

var msg = checkIfAvailable (true, false, true, false, false, true);

if (msg != null) {

_logger.Error (msg);

error ("An error has occurred in setting the compression.", null);

return;

}

_compression = value;

}

}

}

/// <summary>

/// Gets the HTTP cookies included in the WebSocket connection request and response.

/// </summary>

/// <value>

/// An <see cref="T:System.Collections.Generic.IEnumerable{WebSocketSharp.Net.Cookie}"/>

/// instance that provides an enumerator which supports the iteration over the collection of

/// the cookies.

/// </value>

public IEnumerable<Cookie> Cookies {

get {

lock (_cookies.SyncRoot)

foreach (Cookie cookie in _cookies)

yield return cookie;

}

}

/// <summary>

/// Gets the credentials for the HTTP authentication (Basic/Digest).

/// </summary>

/// <value>

/// A <see cref="NetworkCredential"/> that represents the credentials for

/// the authentication. The default value is <see langword="null"/>.

/// </value>

public NetworkCredential Credentials {

get {

return _credentials;

}

}

/// <summary>

/// Gets or sets a value indicating whether the <see cref="WebSocket"/> emits

/// a <see cref="OnMessage"/> event when receives a ping.

/// </summary>

/// <value>

/// <c>true</c> if the <see cref="WebSocket"/> emits a <see cref="OnMessage"/> event

/// when receives a ping; otherwise, <c>false</c>. The default value is <c>false</c>.

/// </value>

public bool EmitOnPing {

get {

return _emitOnPing;

}

set {

_emitOnPing = value;

}

}

/// <summary>

/// Gets or sets a value indicating whether the <see cref="WebSocket"/> redirects

/// the connection request to the new URL located in the connection response.

/// </summary>

/// <value>

/// <c>true</c> if the <see cref="WebSocket"/> redirects the connection request to

/// the new URL; otherwise, <c>false</c>. The default value is <c>false</c>.

/// </value>

public bool EnableRedirection {

get {

return _enableRedirection;

}

set {

lock (_forConn) {

var msg = checkIfAvailable (true, false, true, false, false, true);

if (msg != null) {

_logger.Error (msg);

error ("An error has occurred in setting the enable redirection.", null);

return;

}

_enableRedirection = value;

}

}

}

/// <summary>

/// Gets the WebSocket extensions selected by the server.

/// </summary>

/// <value>

/// A <see cref="string"/> that represents the extensions if any.

/// The default value is <see cref="String.Empty"/>.

/// </value>

public string Extensions {

get {

return _extensions ?? String.Empty;

}

}

/// <summary>

/// Gets a value indicating whether the WebSocket connection is alive.

/// </summary>

/// <value>

/// <c>true</c> if the connection is alive; otherwise, <c>false</c>.

/// </value>

public bool IsAlive {

get {

return Ping ();

}

}

/// <summary>

/// Gets a value indicating whether the WebSocket connection is secure.

/// </summary>

/// <value>

/// <c>true</c> if the connection is secure; otherwise, <c>false</c>.

/// </value>

public bool IsSecure {

get {

return _secure;

}

}

/// <summary>

/// Gets the logging functions.

/// </summary>

/// <remarks>

/// The default logging level is <see cref="LogLevel.Error"/>. If you would like to change it,

/// you should set this <c>Log.Level</c> property to any of the <see cref="LogLevel"/> enum

/// values.

/// </remarks>

/// <value>

/// A <see cref="Logger"/> that provides the logging functions.

/// </value>

public Logger Log {

get {

return _logger;

}

internal set {

_logger = value;

}

}

/// <summary>

/// Gets or sets the value of the HTTP Origin header to send with

/// the WebSocket connection request to the server.

/// </summary>

/// <remarks>

/// The <see cref="WebSocket"/> sends the Origin header if this property has any.

/// </remarks>

/// <value>

/// <para>

/// A <see cref="string"/> that represents the value of

/// the <see href="http://tools.ietf.org/html/rfc6454#section-7">Origin</see> header to send.

/// The default value is <see langword="null"/>.

/// </para>

/// <para>

/// The Origin header has the following syntax:

/// <c>&lt;scheme&gt;://&lt;host&gt;[:&lt;port&gt;]</c>

/// </para>

/// </value>

public string Origin {

get {

return _origin;

}

set {

lock (_forConn) {

var msg = checkIfAvailable (true, false, true, false, false, true);

if (msg == null) {

if (value.IsNullOrEmpty ()) {

_origin = value;

return;

}

Uri origin;

if (!Uri.TryCreate (value, UriKind.Absolute, out origin) || origin.Segments.Length > 1)

msg = "The syntax of an origin must be '<scheme>://<host>[:<port>]'.";

}

if (msg != null) {

_logger.Error (msg);

error ("An error has occurred in setting the origin.", null);

return;

}

_origin = value.TrimEnd ('/');

}

}

}

/// <summary>

/// Gets the WebSocket subprotocol selected by the server.

/// </summary>

/// <value>

/// A <see cref="string"/> that represents the subprotocol if any.

/// The default value is <see cref="String.Empty"/>.

/// </value>

public string Protocol {

get {

return _protocol ?? String.Empty;

}

internal set {

_protocol = value;

}

}

/// <summary>

/// Gets the state of the WebSocket connection.

/// </summary>

/// <value>

/// One of the <see cref="WebSocketState"/> enum values, indicates the state of the connection.

/// The default value is <see cref="WebSocketState.Connecting"/>.

/// </value>

public WebSocketState ReadyState {

get {

return _readyState;

}

}

/// <summary>

/// Gets or sets the SSL configuration used to authenticate the server and

/// optionally the client for secure connection.

/// </summary>

/// <value>

/// A <see cref="ClientSslConfiguration"/> that represents the configuration used

/// to authenticate the server and optionally the client for secure connection,

/// or <see langword="null"/> if the <see cref="WebSocket"/> is used in a server.

/// </value>

public ClientSslConfiguration SslConfiguration {

get {

return _client

? (_sslConfig ?? (_sslConfig = new ClientSslConfiguration (_uri.DnsSafeHost)))

: null;

}

set {

lock (_forConn) {

var msg = checkIfAvailable (true, false, true, false, false, true);

if (msg != null) {

_logger.Error (msg);

error ("An error has occurred in setting the ssl configuration.", null);

return;

}

_sslConfig = value;

}

}

}

/// <summary>

/// Gets the WebSocket URL used to connect, or accepted.

/// </summary>

/// <value>

/// A <see cref="Uri"/> that represents the URL used to connect, or accepted.

/// </value>

public Uri Url {

get {

return _client ? _uri : _context.RequestUri;

}

}

/// <summary>

/// Gets or sets the wait time for the response to the Ping or Close.

/// </summary>

/// <value>

/// A <see cref="TimeSpan"/> that represents the wait time. The default value is the same as

/// 5 seconds, or 1 second if the <see cref="WebSocket"/> is used in a server.

/// </value>

public TimeSpan WaitTime {

get {

return _waitTime;

}

set {

lock (_forConn) {

var msg = checkIfAvailable (true, true, true, false, false, true) ??

value.CheckIfValidWaitTime ();

if (msg != null) {

_logger.Error (msg);

error ("An error has occurred in setting the wait time.", null);

return;

}

_waitTime = value;

}

}

}

#endregion

#region Public Events

/// <summary>

/// Occurs when the WebSocket connection has been closed.

/// </summary>

public event EventHandler<CloseEventArgs> OnClose;

/// <summary>

/// Occurs when the <see cref="WebSocket"/> gets an error.

/// </summary>

public event EventHandler<ErrorEventArgs> OnError;

/// <summary>

/// Occurs when the <see cref="WebSocket"/> receives a message.

/// </summary>

public event EventHandler<MessageEventArgs> OnMessage;

/// <summary>

/// Occurs when the WebSocket connection has been established.

/// </summary>

public event EventHandler OnOpen;

#endregion

#region Private Methods

// As server

private bool accept ()

{

lock (_forConn) {

var msg = _readyState.CheckIfAvailable (true, false, false, false);

if (msg != null) {

_logger.Error (msg);

error ("An error has occurred in accepting.", null);

return false;

}

try {

if (acceptHandshake ()) {

_readyState = WebSocketState.Open;

return true;

}

}

catch (Exception ex) {

_logger.Fatal (ex.ToString ());

fatal ("An exception has occurred while accepting.", ex);

}

return false;

}

}

// As server

private bool acceptHandshake ()

{

_logger.Debug (String.Format ("A request from {0}:\n{1}", _context.UserEndPoint, _context));

string msg;

if (!checkHandshakeRequest (_context, out msg)) {

sendHttpResponse (createHandshakeFailureResponse (HttpStatusCode.BadRequest));

_logger.Fatal (msg);

fatal ("An error has occurred while accepting.", CloseStatusCode.ProtocolError);

return false;

}

if (!customCheckHandshakeRequest (_context, out msg)) {

sendHttpResponse (createHandshakeFailureResponse (HttpStatusCode.BadRequest));

_logger.Fatal (msg);

fatal ("An error has occurred while accepting.", CloseStatusCode.PolicyViolation);

return false;

}

_base64Key = _context.Headers["Sec-WebSocket-Key"];

if (_protocol != null)

processSecWebSocketProtocolHeader (_context.SecWebSocketProtocols);

if (!_ignoreExtensions)

processSecWebSocketExtensionsClientHeader (_context.Headers["Sec-WebSocket-Extensions"]);

return sendHttpResponse (createHandshakeResponse ());

}

// As server

private bool checkHandshakeRequest (WebSocketContext context, out string message)

{

message = null;

if (context.RequestUri == null) {

message = "Specifies an invalid Request-URI.";

return false;

}

if (!context.IsWebSocketRequest) {

message = "Not a WebSocket handshake request.";

return false;

}

var headers = context.Headers;

if (!validateSecWebSocketKeyHeader (headers["Sec-WebSocket-Key"])) {

message = "Includes no Sec-WebSocket-Key header, or it has an invalid value.";

return false;

}

if (!validateSecWebSocketVersionClientHeader (headers["Sec-WebSocket-Version"])) {

message = "Includes no Sec-WebSocket-Version header, or it has an invalid value.";

return false;

}

if (!validateSecWebSocketProtocolClientHeader (headers["Sec-WebSocket-Protocol"])) {

message = "Includes an invalid Sec-WebSocket-Protocol header.";

return false;

}

if (!_ignoreExtensions

&& !validateSecWebSocketExtensionsClientHeader (headers["Sec-WebSocket-Extensions"])

) {

message = "Includes an invalid Sec-WebSocket-Extensions header.";

return false;

}

return true;

}

// As client

private bool checkHandshakeResponse (HttpResponse response, out string message)

{

message = null;

if (response.IsRedirect) {

message = "Indicates the redirection.";

return false;

}

if (response.IsUnauthorized) {

message = "Requires the authentication.";

return false;

}

if (!response.IsWebSocketResponse) {

message = "Not a WebSocket handshake response.";

return false;

}

var headers = response.Headers;

if (!validateSecWebSocketAcceptHeader (headers["Sec-WebSocket-Accept"])) {

message = "Includes no Sec-WebSocket-Accept header, or it has an invalid value.";

return false;

}

if (!validateSecWebSocketProtocolServerHeader (headers["Sec-WebSocket-Protocol"])) {

message = "Includes no Sec-WebSocket-Protocol header, or it has an invalid value.";

return false;

}

if (!validateSecWebSocketExtensionsServerHeader (headers["Sec-WebSocket-Extensions"])) {

message = "Includes an invalid Sec-WebSocket-Extensions header.";

return false;

}

if (!validateSecWebSocketVersionServerHeader (headers["Sec-WebSocket-Version"])) {

message = "Includes an invalid Sec-WebSocket-Version header.";

return false;

}

return true;

}

private string checkIfAvailable (

bool client, bool server, bool connecting, bool open, bool closing, bool closed)

{

return !client && _client

? "This operation isn't available in: client"

: !server && !_client

? "This operation isn't available in: server"

: _readyState.CheckIfAvailable (connecting, open, closing, closed);

}

private bool checkReceivedFrame (WebSocketFrame frame, out string message)

{

message = null;

var masked = frame.IsMasked;

if (_client && masked) {

message = "A frame from the server is masked.";

return false;

}

if (!_client && !masked) {

message = "A frame from a client isn't masked.";

return false;

}

if (_inContinuation && frame.IsData) {

message = "A data frame has been received while receiving continuation frames.";

return false;

}

if (frame.IsCompressed && _compression == CompressionMethod.None) {

message = "A compressed frame has been received without any agreement for it.";

return false;

}

if (frame.Rsv2 == Rsv.On) {

message = "The RSV2 of a frame is non-zero without any negotiation for it.";

return false;

}

if (frame.Rsv3 == Rsv.On) {

message = "The RSV3 of a frame is non-zero without any negotiation for it.";

return false;

}

return true;

}

private void close (CloseEventArgs e, bool send, bool receive, bool received)

{

lock (_forConn) {

if (_readyState == WebSocketState.Closing) {

_logger.Info ("The closing is already in progress.");

return;

}

if (_readyState == WebSocketState.Closed) {

_logger.Info ("The connection has been closed.");

return;

}

send = send && _readyState == WebSocketState.Open;

receive = receive && send;

_readyState = WebSocketState.Closing;

}

_logger.Trace ("Begin closing the connection.");

var bytes = send ? WebSocketFrame.CreateCloseFrame (e.PayloadData, _client).ToArray () : null;

e.WasClean = closeHandshake (bytes, receive, received);

releaseResources ();

_logger.Trace ("End closing the connection.");

_readyState = WebSocketState.Closed;

try {

OnClose.Emit (this, e);

}

catch (Exception ex) {

_logger.Error (ex.ToString ());

error ("An exception has occurred during the OnClose event.", ex);

}

}

private void closeAsync (CloseEventArgs e, bool send, bool receive, bool received)

{

Action<CloseEventArgs, bool, bool, bool> closer = close;

closer.BeginInvoke (e, send, receive, received, ar => closer.EndInvoke (ar), null);

}

private bool closeHandshake (byte[] frameAsBytes, bool receive, bool received)

{

var sent = frameAsBytes != null && sendBytes (frameAsBytes);

received = received ||

(receive && sent && _exitReceiving != null && _exitReceiving.WaitOne (_waitTime));

var ret = sent && received;

_logger.Debug (

String.Format ("Was clean?: {0}\n sent: {1}\n received: {2}", ret, sent, received));

return ret;

}

// As client

private bool connect ()

{

lock (_forConn) {

var msg = _readyState.CheckIfAvailable (true, false, false, true);

if (msg != null) {

_logger.Error (msg);

error ("An error has occurred in connecting.", null);

return false;

}

_readyState = WebSocketState.Connecting;

try {

if (doHandshake ()) {

_readyState = WebSocketState.Open;

return true;

}

}

catch (Exception ex) {

_logger.Fatal (ex.ToString ());

fatal ("An exception has occurred while connecting.", ex);

}

return false;

}

}

// As client

private string createExtensions ()

{

var buff = new StringBuilder (80);

if (_compression != CompressionMethod.None) {

var str = _compression.ToExtensionString (

"server_no_context_takeover", "client_no_context_takeover");

buff.AppendFormat ("{0}, ", str);

}

var len = buff.Length;

if (len > 2) {

buff.Length = len - 2;

return buff.ToString ();

}

return null;

}

// As server

private HttpResponse createHandshakeFailureResponse (HttpStatusCode code)

{

var ret = HttpResponse.CreateCloseResponse (code);

ret.Headers["Sec-WebSocket-Version"] = _version;

return ret;

}

// As client

private HttpRequest createHandshakeRequest ()

{

var ret = HttpRequest.CreateWebSocketRequest (_uri);

var headers = ret.Headers;

if (!_origin.IsNullOrEmpty ())

headers["Origin"] = _origin;

headers["Sec-WebSocket-Key"] = _base64Key;

_protocolsRequested = _protocols != null;

if (_protocolsRequested)

headers["Sec-WebSocket-Protocol"] = _protocols.ToString (", ");

_extensionsRequested = _compression != CompressionMethod.None;

if (_extensionsRequested)

headers["Sec-WebSocket-Extensions"] = createExtensions ();

headers["Sec-WebSocket-Version"] = _version;

AuthenticationResponse authRes = null;

if (_authChallenge != null && _credentials != null) {

authRes = new AuthenticationResponse (_authChallenge, _credentials, _nonceCount);

_nonceCount = authRes.NonceCount;

}

else if (_preAuth) {

authRes = new AuthenticationResponse (_credentials);

}

if (authRes != null)

headers["Authorization"] = authRes.ToString ();

if (_cookies.Count > 0)

ret.SetCookies (_cookies);

return ret;

}

// As server

private HttpResponse createHandshakeResponse ()

{

var ret = HttpResponse.CreateWebSocketResponse ();

var headers = ret.Headers;

headers["Sec-WebSocket-Accept"] = CreateResponseKey (_base64Key);

if (_protocol != null)

headers["Sec-WebSocket-Protocol"] = _protocol;

if (_extensions != null)

headers["Sec-WebSocket-Extensions"] = _extensions;