WebSocket.cs

#region License

/*
 * WebSocket.cs
 *
 * 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
 * Copyright © 2016 Nivloc Enterprises Ltd
 *
 * 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.Text;
#if SSHARP
using Crestron.SimplSharp;
using Crestron.SimplSharp.CrestronIO;
using Crestron.SimplSharp.Cryptography;
using TcpClient = Crestron.SimplSharp.CrestronSockets.TCPClient;
using Crestron.SimplSharp.CrestronSockets;
using CookieCollection = WebSocketSharp.Net.CookieCollection;
using SSMono.Net;
using SSMono.Threading;
using NetworkCredential = WebSocketSharp.Net.NetworkCredential;
#if BUFFERED
using SSMono.Net.Sockets;
#endif
#if BCC
using Org.BouncyCastle.Crypto.Tls;
using Org.BouncyCastle.X509;
#elif SSL
using Mono.Security.Protocol.Tls;
using SSMono.Security.Cryptography.X509Certificates;
using SSMono.Security.Authentication;
using SSMono.Net.Security;
#endif
#else
using System.Diagnostics;
using System.IO;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Threading;
#endif
using WebSocketSharp.Net;
using WebSocketSharp.Net.WebSockets;

namespace WebSocketSharp
	{
	/// <summary>
	/// Implements the WebSocket interface.
	/// </summary>
	/// <remarks>
	///   <para>
	///   This class provides a set of methods and properties for two-way
	///   communication using the WebSocket protocol.
	///   </para>
	///   <para>
	///   The WebSocket protocol is defined in
	///   <see href="http://tools.ietf.org/html/rfc6455">RFC 6455</see>.
	///   </para>
	/// </remarks>
	public class WebSocket : IDisposable
		{
		#region Private Fields

		private AuthenticationChallenge _authChallenge;
		private string _base64Key;
		private bool _client;
#if !CLIENT
		private Action _closeContext;
#endif
		private CompressionMethod _compression;
#if !CLIENT
		private WebSocketContext _context;
#endif
		private CookieCollection _cookies;
		private NetworkCredential _credentials;
		private bool _emitOnPing;
		private bool _enableRedirection;
		private string _extensions;
		private bool _extensionsRequested;
		private object _forMessageEventQueue;
		private object _forPing;
		private object _forSend;
		private object _forState;
		private MemoryStream _fragmentsBuffer;
		private bool _fragmentsCompressed;
		private Opcode _fragmentsOpcode;
		private const string _guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
#if !CLIENT
		private Func<WebSocketContext, string> _handshakeRequestChecker;
		private bool _ignoreExtensions;
#endif
		private bool _inContinuation;
		private volatile bool _inMessage;
		private volatile Logger _logger;
		private static readonly int _maxRetryCountForConnect;
		private Action<MessageEventArgs> _message;
		private Queue<MessageEventArgs> _messageEventQueue;
		private uint _nonceCount;
		private string _origin;
		private ManualResetEvent _pongReceived;
		private bool _preAuth;
		private string _protocol;
		private string[] _protocols;
		private bool _protocolsRequested;
		private NetworkCredential _proxyCredentials;
		private Uri _proxyUri;
		private volatile WebSocketState _readyState;
		private ManualResetEvent _receivingExited;
		private int _retryCountForConnect;
		private bool _secure;
#if !NETCF || BCC || SSL
		private ClientSslConfiguration _sslConfig;
#endif
		private Stream _stream;
		private TcpClient _tcpClient;
		private Uri _uri;
		private const string _version = "13";
		private TimeSpan _waitTime;

		private DateTime _lastReceivedTime = DateTime.MinValue;

		#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 to used internally.
		/// </summary>
		internal static readonly RandomNumberGenerator RandomNumber;

		#endregion

		#region Static Constructor

		static WebSocket ()
			{
			_maxRetryCountForConnect = 10;
			EmptyBytes = new byte[0];
			FragmentLength = 1016;
			RandomNumber = new RNGCryptoServiceProvider ();
			}

		#endregion

		#region Internal Constructors

#if !CLIENT
		// 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 ();
			}
#endif

		#endregion

		#region Public Constructors

		/// <summary>
		/// Initializes a new instance of the <see cref="WebSocket"/> class with
		/// <paramref name="url"/> and optionally <paramref name="protocols"/>.
		/// </summary>
		/// <param name="url">
		///   <para>
		///   A <see cref="string"/> that specifies the URL to which to connect.
		///   </para>
		///   <para>
		///   The scheme of the URL must be ws or wss.
		///   </para>
		///   <para>
		///   The new instance uses a secure connection if the scheme is wss.
		///   </para>
		/// </param>
		/// <param name="protocols">
		///   <para>
		///   An array of <see cref="string"/> that specifies the names of
		///   the subprotocols if necessary.
		///   </para>
		///   <para>
		///   Each value of the array must be a token defined in
		///   <see href="http://tools.ietf.org/html/rfc2616#section-2.2">
		///   RFC 2616</see>.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="url"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="url"/> is an empty string.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="url"/> is an invalid WebSocket URL string.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="protocols"/> contains a value that is not a token.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="protocols"/> contains a value twice.
		///   </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)
				{
				if (!checkProtocols (protocols, out msg))
					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; }
			}

		internal bool HasMessage
			{
			get
				{
				lock (_forMessageEventQueue)
					return _messageEventQueue.Count > 0;
				}
			}

#if !CLIENT
		// As server
		internal Func<WebSocketContext, string> CustomHandshakeRequestChecker
			{
			get { return _handshakeRequestChecker; }

			set { _handshakeRequestChecker = value; }
			}

		// As server
		internal bool IgnoreExtensions
			{
			get { return _ignoreExtensions; }

			set { _ignoreExtensions = value; }
			}
#endif

		internal bool IsConnected
			{
			get { return _readyState == WebSocketState.Open || _readyState == WebSocketState.Closing; }
			}

		internal DateTime LastReceivedTime
			{
			get { return _lastReceivedTime; }
			}

		#endregion

		#region Public Properties

		/// <summary>
		/// Gets or sets the compression method used to compress a message.
		/// </summary>
		/// <remarks>
		/// The set operation does nothing if the connection has already been
		/// established or it is closing.
		/// </remarks>
		/// <value>
		///   <para>
		///   One of the <see cref="CompressionMethod"/> enum values.
		///   </para>
		///   <para>
		///   It specifies the compression method used to compress a message.
		///   </para>
		///   <para>
		///   The default value is <see cref="CompressionMethod.None"/>.
		///   </para>
		/// </value>
		/// <exception cref="InvalidOperationException">
		/// The set operation is not available if this instance is not a client.
		/// </exception>
		public CompressionMethod Compression
			{
			get { return _compression; }

			set
				{
				string msg = null;

				if (!_client)
					{
					msg = "This instance is not a client.";
					throw new InvalidOperationException (msg);
					}

				if (!canSet (out msg))
					{
					_logger.Warn (msg);
					return;
					}

				lock (_forState)
					{
					if (!canSet (out msg))
						{
						_logger.Warn (msg);
						return;
						}

					_compression = value;
					}
				}
			}

		/// <summary>
		/// Gets the HTTP cookies included in the handshake request/response.
		/// </summary>
		/// <value>
		///   <para>
		///   An <see cref="T:System.Collections.Generic.IEnumerable{WebSocketSharp.Net.Cookie}"/>
		///   instance.
		///   </para>
		///   <para>
		///   It provides an enumerator which supports the iteration over
		///   the collection of the cookies.
		///   </para>
		/// </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>
		///   <para>
		///   A <see cref="NetworkCredential"/> that represents the credentials
		///   used to authenticate the client.
		///   </para>
		///   <para>
		///   The default value is <see langword="null"/>.
		///   </para>
		/// </value>
		public NetworkCredential Credentials
			{
			get { return _credentials; }
			}

		/// <summary>
		/// Gets or sets a value indicating whether a <see cref="OnMessage"/> event
		/// is emitted when a ping is received.
		/// </summary>
		/// <value>
		///   <para>
		///   <c>true</c> if this instance emits a <see cref="OnMessage"/> event
		///   when receives a ping; otherwise, <c>false</c>.
		///   </para>
		///   <para>
		///   The default value is <c>false</c>.
		///   </para>
		/// </value>
		public bool EmitOnPing
			{
			get { return _emitOnPing; }

			set { _emitOnPing = value; }
			}

		/// <summary>
		/// Gets or sets a value indicating whether the URL redirection for
		/// the handshake request is allowed.
		/// </summary>
		/// <remarks>
		/// The set operation does nothing if the connection has already been
		/// established or it is closing.
		/// </remarks>
		/// <value>
		///   <para>
		///   <c>true</c> if this instance allows the URL redirection for
		///   the handshake request; otherwise, <c>false</c>.
		///   </para>
		///   <para>
		///   The default value is <c>false</c>.
		///   </para>
		/// </value>
		/// <exception cref="InvalidOperationException">
		/// The set operation is not available if this instance is not a client.
		/// </exception>
		public bool EnableRedirection
			{
			get { return _enableRedirection; }

			set
				{
				string msg = null;

				if (!_client)
					{
					msg = "This instance is not a client.";
					throw new InvalidOperationException (msg);
					}

				if (!canSet (out msg))
					{
					_logger.Warn (msg);
					return;
					}

				lock (_forState)
					{
					if (!canSet (out msg))
						{
						_logger.Warn (msg);
						}

					_enableRedirection = value;
					}
				}
			}

		/// <summary>
		/// Gets the extensions selected by server.
		/// </summary>
		/// <value>
		/// A <see cref="string"/> that will be a list of the extensions
		/// negotiated between client and server, or an empty string if
		/// not specified or selected.
		/// </value>
		public string Extensions
			{
			get { return _extensions ?? String.Empty; }
			}

		/// <summary>
		/// Gets a value indicating whether the connection is alive.
		/// </summary>
		/// <remarks>
		/// The get operation returns the value by using a ping/pong
		/// if the current state of the connection is Open.
		/// </remarks>
		/// <value>
		/// <c>true</c> if the connection is alive; otherwise, <c>false</c>.
		/// </value>
		public bool IsAlive
			{
			get { return ping (EmptyBytes); }
			}

		/// <summary>
		/// Gets a value indicating whether a secure connection is used.
		/// </summary>
		/// <value>
		/// <c>true</c> if this instance uses a secure connection; otherwise,
		/// <c>false</c>.
		/// </value>
		public bool IsSecure
			{
			get { return _secure; }
			}

		/// <summary>
		/// Gets the logging function.
		/// </summary>
		/// <remarks>
		/// The default logging level is <see cref="LogLevel.Error"/>.
		/// </remarks>
		/// <value>
		/// A <see cref="Logger"/> that provides the logging function.
		/// </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 handshake request.
		/// </summary>
		/// <remarks>
		///   <para>
		///   The HTTP Origin header is defined in
		///   <see href="http://tools.ietf.org/html/rfc6454#section-7">
		///   Section 7 of RFC 6454</see>.
		///   </para>
		///   <para>
		///   This instance sends the Origin header if this property has any.
		///   </para>
		///   <para>
		///   The set operation does nothing if the connection has already been
		///   established or it is closing.
		///   </para>
		/// </remarks>
		/// <value>
		///   <para>
		///   A <see cref="string"/> that represents the value of the Origin
		///   header to send.
		///   </para>
		///   <para>
		///   The syntax is &lt;scheme&gt;://&lt;host&gt;[:&lt;port&gt;].
		///   </para>
		///   <para>
		///   The default value is <see langword="null"/>.
		///   </para>
		/// </value>
		/// <exception cref="InvalidOperationException">
		/// The set operation is not available if this instance is not a client.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   The value specified for a set operation is not an absolute URI string.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The value specified for a set operation includes the path segments.
		///   </para>
		/// </exception>
		public string Origin
			{
			get { return _origin; }

			set
				{
				string msg = null;

				if (!_client)
					{
					msg = "This instance is not a client.";
					throw new InvalidOperationException (msg);
					}

				if (!value.IsNullOrEmpty ())
					{
					Uri uri;
					if (!Uri.TryCreate (value, UriKind.Absolute, out uri))
						{
						msg = "Not an absolute URI string.";
						throw new ArgumentException (msg, "value");
						}

					if (uri.Segments.Length > 1)
						{
						msg = "It includes the path segments.";
						throw new ArgumentException (msg, "value");
						}
					}

				if (!canSet (out msg))
					{
					_logger.Warn (msg);
					return;
					}

				lock (_forState)
					{
					if (!canSet (out msg))
						{
						_logger.Warn (msg);
						return;
						}

					_origin = !value.IsNullOrEmpty () ? value.TrimEnd ('/') : value;
					}
				}
			}

		/// <summary>
		/// Gets the name of subprotocol selected by the server.
		/// </summary>
		/// <value>
		///   <para>
		///   A <see cref="string"/> that will be one of the names of
		///   subprotocols specified by client.
		///   </para>
		///   <para>
		///   An empty string if not specified or selected.
		///   </para>
		/// </value>
		public string Protocol
			{
			get { return _protocol ?? String.Empty; }

			internal set { _protocol = value; }
			}

		/// <summary>
		/// Gets the current state of the connection.
		/// </summary>
		/// <value>
		///   <para>
		///   One of the <see cref="WebSocketState"/> enum values.
		///   </para>
		///   <para>
		///   It indicates the current state of the connection.
		///   </para>
		///   <para>
		///   The default value is <see cref="WebSocketState.Connecting"/>.
		///   </para>
		/// </value>
		public WebSocketState ReadyState
			{
			get { return _readyState; }
			}

#if !NETCF || BCC || SSL
		/// <summary>
		/// Gets the configuration for secure connection.
		/// </summary>
		/// <remarks>
		/// This configuration will be referenced when attempts to connect,
		/// so it must be configured before any connect method is called.
		/// </remarks>
		/// <value>
		/// A <see cref="ClientSslConfiguration"/> that represents
		/// the configuration used to establish a secure connection.
		/// </value>
		/// <exception cref="InvalidOperationException">
		///   <para>
		///   This instance is not a client.
		///   </para>
		///   <para>
		///   This instance does not use a secure connection.
		///   </para>
		/// </exception>
		public ClientSslConfiguration SslConfiguration
			{
			get
				{
				if (!_client)
					{
					var msg = "This instance is not a client.";
					throw new InvalidOperationException (msg);
					}

				if (!_secure)
					{
					var msg = "This instance does not use a secure connection.";
					throw new InvalidOperationException (msg);
					}

				return getSslConfiguration ();
				}
			}
#endif

		/// <summary>
		/// Gets the URL to which to connect.
		/// </summary>
		/// <value>
		/// A <see cref="Uri"/> that represents the URL to which to connect.
		/// </value>
		public Uri Url
			{
			get
				{
#if CLIENT
				return _uri;
#else
				return _client ? _uri : _context.RequestUri;
#endif
				}
			}

		/// <summary>
		/// Gets or sets the time to wait for the response to the ping or close.
		/// </summary>
		/// <remarks>
		/// The set operation does nothing if the connection has already been
		/// established or it is closing.
		/// </remarks>
		/// <value>
		///   <para>
		///   A <see cref="TimeSpan"/> to wait for the response.
		///   </para>
		///   <para>
		///   The default value is the same as 5 seconds if this instance is
		///   a client.
		///   </para>
		/// </value>
		/// <exception cref="ArgumentOutOfRangeException">
		/// The value specified for a set operation is zero or less.
		/// </exception>
		public TimeSpan WaitTime
			{
			get { return _waitTime; }

			set
				{
				if (value <= TimeSpan.Zero)
					throw new ArgumentOutOfRangeException ("value", "Zero or less.");

				string msg;
				if (!canSet (out msg))
					{
					_logger.Warn (msg);
					return;
					}

				lock (_forState)
					{
					if (!canSet (out msg))
						{
						_logger.Warn (msg);
						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

#if !CLIENT
		// As server
		private bool accept ()
			{
			if (_readyState == WebSocketState.Open)
				{
				var msg = "The handshake request has already been accepted.";
				_logger.Warn (msg);

				return false;
				}

			lock (_forState)
				{
				if (_readyState == WebSocketState.Open)
					{
					var msg = "The handshake request has already been accepted.";
					_logger.Warn (msg);

					return false;
					}

				if (_readyState == WebSocketState.Closing)
					{
					var msg = "The close process has set in.";
					_logger.Error (msg);

					msg = "An interruption has occurred while attempting to accept.";
					error (msg, null);

					return false;
					}

				if (_readyState == WebSocketState.Closed)
					{
					var msg = "The connection has been closed.";
					_logger.Error (msg);

					msg = "An interruption has occurred while attempting to accept.";
					error (msg, null);

					return false;
					}

				try
					{
					if (!acceptHandshake ())
						return false;
					}
				catch (Exception ex)
					{
					_logger.Fatal (ex.Message);
					_logger.Debug (ex.ToString ());

					var msg = "An exception has occurred while attempting to accept.";
					fatal (msg, ex);

					return false;
					}

				_readyState = WebSocketState.Open;
				return true;
				}
			}

		// As server
		private bool acceptHandshake ()
			{
			_logger.Debug (String.Format ("A handshake request from {0}:\n{1}", _context.UserEndPoint, _context));

			string msg;
			if (!checkHandshakeRequest (_context, out msg))
				{
				_logger.Error (msg);

				refuseHandshake (CloseStatusCode.ProtocolError, "A handshake error has occurred while attempting to accept.");

				return false;
				}

			if (!customCheckHandshakeRequest (_context, out msg))
				{
				_logger.Error (msg);

				refuseHandshake (CloseStatusCode.PolicyViolation, "A handshake error has occurred while attempting to accept.");

				return false;
				}

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

			if (_protocol != null)
				processSecWebSocketProtocolClientHeader (_context.SecWebSocketProtocols);

			if (!_ignoreExtensions)
				{
				var val = _context.Headers["Sec-WebSocket-Extensions"];
				processSecWebSocketExtensionsClientHeader (val);
				}

			return sendHttpResponse (createHandshakeResponse ());
			}
#endif

		private bool canSet (out string message)
			{
			message = null;

			if (_readyState == WebSocketState.Open)
				{
				message = "The connection has already been established.";
				return false;
				}

			if (_readyState == WebSocketState.Closing)
				{
				message = "The connection is closing.";
				return false;
				}

			return true;
			}

#if !CLIENT
		// As server
		private bool checkHandshakeRequest (WebSocketContext context, out string message)
			{
			message = null;

			if (!context.IsWebSocketRequest)
				{
				message = "Not a WebSocket handshake request.";
				return false;
				}

			if (context.RequestUri == null)
				{
				message = "Specifies an invalid Request-URI.";
				return false;
				}

			var headers = context.Headers;

			var key = headers["Sec-WebSocket-Key"];
			if (key == null)
				{
				message = "It includes no Sec-WebSocket-Key header.";
				return false;
				}

			if (key.Length == 0)
				{
				message = "It includes an invalid Sec-WebSocket-Key header.";
				return false;
				}

			var version = headers["Sec-WebSocket-Version"];
			if (version == null)
				{
				message = "It includes no Sec-WebSocket-Version header.";
				return false;
				}

			if (version != _version)
				{
				message = "It includes an invalid Sec-WebSocket-Version header.";
				return false;
				}

			var protocol = headers["Sec-WebSocket-Protocol"];
			if (protocol != null && protocol.Length == 0)
				{
				message = "It includes an invalid Sec-WebSocket-Protocol header.";
				return false;
				}

			if (!_ignoreExtensions)
				{
				var extensions = headers["Sec-WebSocket-Extensions"];
				if (extensions != null && extensions.Length == 0)
					{
					message = "It includes an invalid Sec-WebSocket-Extensions header.";
					return false;
					}
				}

			return true;
			}
#endif

		// 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 static bool checkProtocols (string[] protocols, out string message)
			{
			message = null;

			Func<string, bool> cond = protocol => protocol.IsNullOrEmpty ()
			                                      || !protocol.IsToken ();

			if (protocols.Contains (cond))
				{
				message = "It contains a value that is not a token.";
				return false;
				}

			if (protocols.ContainsTwice ())
				{
				message = "It contains a value twice.";
				return false;
				}

			return true;
			}

		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 is not 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 (ushort code, string reason)
			{
			if (_readyState == WebSocketState.Closing)
				{
				_logger.Info ("The closing is already in progress.");
				return;
				}

			if (_readyState == WebSocketState.Closed)
				{
				_logger.Info ("The connection has already been closed.");
				return;
				}

			if (code == 1005)
				{
				// == no status
				close (PayloadData.Empty, true, true, false);
				return;
				}

			var send = !code.IsReserved ();
			close (new PayloadData (code, reason), send, send, false);
			}

		private void close (PayloadData payloadData, bool send, bool receive, bool received)
			{
			lock (_forState)
				{
				if (_readyState == WebSocketState.Closing)
					{
					_logger.Info ("The closing is already in progress.");
					return;
					}

				if (_readyState == WebSocketState.Closed)
					{
					_logger.Info ("The connection has already been closed.");
					return;
					}

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

				_readyState = WebSocketState.Closing;
				}

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

			var res = closeHandshake (payloadData, send, receive, received);
			releaseResources ();

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

			_readyState = WebSocketState.Closed;

			var e = new CloseEventArgs (payloadData);
			e.WasClean = res;

			try
				{
				OnClose.Emit (this, e);
				}
			catch (Exception ex)
				{
				_logger.Error (ex.ToString ());
				error ("An error has occurred during the OnClose event.", ex);
				}
			}

		private void closeAsync (ushort code, string reason)
			{
			if (_readyState == WebSocketState.Closing)
				{
				_logger.Info ("The closing is already in progress.");
				return;
				}

			if (_readyState == WebSocketState.Closed)
				{
				_logger.Info ("The connection has already been closed.");
				return;
				}

			if (code == 1005)
				{
				// == no status
				closeAsync (PayloadData.Empty, true, true, false);
				return;
				}

			var send = !code.IsReserved ();
			closeAsync (new PayloadData (code, reason), send, send, false);
			}

		private void closeAsync (PayloadData payloadData, bool send, bool receive, bool received)
			{
			Action<PayloadData, bool, bool, bool> closer = close;
			closer.BeginInvoke (
				payloadData, send, receive, received, ar => closer.EndInvoke (ar), null
				);
			}

		private bool closeHandshake (byte[] frameAsBytes, bool receive, bool received)
			{
			var sent = frameAsBytes != null && sendBytes (frameAsBytes);

			var wait = !received && sent && receive && _receivingExited != null;
			if (wait)
				received = _receivingExited.WaitOne (_waitTime);

			var ret = sent && received;
			_logger.Debug (
				String.Format ("Was clean?: {0}\nsent: {1} received: {2}", ret, sent, received));

			return ret;
			}

		private bool closeHandshake (PayloadData payloadData, bool send, bool receive, bool received)
			{
			var sent = false;
			if (send)
				{
				var frame = WebSocketFrame.CreateCloseFrame (payloadData, _client);
				sent = sendBytes (frame.ToArray ());

				if (_client)
					frame.Unmask ();
				}

			var wait = !received && sent && receive && _receivingExited != null;
			if (wait)
				received = _receivingExited.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 ()
			{
			if (_readyState == WebSocketState.Open)
				{
				var msg = "The connection has already been established.";
				_logger.Warn (msg);

				return false;
				}

			lock (_forState)
				{
				if (_readyState == WebSocketState.Open)
					{
					var msg = "The connection has already been established.";
					_logger.Warn (msg);

					return false;
					}

				if (_readyState == WebSocketState.Closing)
					{
					var msg = "The close process has set in.";
					_logger.Error (msg);

					msg = "An interruption has occurred while attempting to connect.";
					error (msg, null);

					return false;
					}

				if (_retryCountForConnect > _maxRetryCountForConnect)
					{
					var msg = "An opportunity for reconnecting has been lost.";
					_logger.Error (msg);

					msg = "An interruption has occurred while attempting to connect.";
					error (msg, null);

					return false;
					}

				_readyState = WebSocketState.Connecting;

				try
					{
					doHandshake ();
					}
				catch (Exception ex)
					{
					_retryCountForConnect++;

					_logger.Fatal (ex.Message);
					_logger.Debug (ex.ToString ());

					var msg = "An exception has occurred while attempting to connect.";
					fatal (msg, ex);

					return false;
					}

				_retryCountForConnect = 1;
				_readyState = WebSocketState.Open;

				return true;
				}
			}

		// 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;
			}

#if !CLIENT
		// As server
		private HttpResponse createHandshakeFailureResponse (HttpStatusCode code)
			{
			var ret = HttpResponse.CreateCloseResponse (code);
			ret.Headers["Sec-WebSocket-Version"] = _version;

			return ret;
			}
#endif

		// 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;
			}

#if !CLIENT
		// 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;

			if (_cookies.Count > 0)
				ret.SetCookies (_cookies);

			return ret;
			}

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

			if (_handshakeRequestChecker == null)
				return true;

			message = _handshakeRequestChecker (context);
			return message == null;
			}

		private MessageEventArgs dequeueFromMessageEventQueue ()
			{
			lock (_forMessageEventQueue)
				return _messageEventQueue.Count > 0 ? _messageEventQueue.Dequeue () : null;
			}
#endif

		// As client
		private void doHandshake ()
			{
			setClientStream ();
			var res = sendHandshakeRequest ();

			string msg;
			if (!checkHandshakeResponse (res, out msg))
				throw new WebSocketException (CloseStatusCode.ProtocolError, msg);

			if (_protocolsRequested)
				_protocol = res.Headers["Sec-WebSocket-Protocol"];

			if (_extensionsRequested)
				processSecWebSocketExtensionsServerHeader (res.Headers["Sec-WebSocket-Extensions"]);

			processCookies (res.Cookies);
			}

		private void enqueueToMessageEventQueue (MessageEventArgs e)
			{
			lock (_forMessageEventQueue)
				_messageEventQueue.Enqueue (e);
			}

		private void error (string message, Exception exception)
			{
			try
				{
				OnError.Emit (this, new ErrorEventArgs (message, exception));
				}
			catch (Exception ex)
				{
				_logger.Error (ex.Message);
				_logger.Debug (ex.ToString ());
				}
			}

		private void fatal (string message, Exception exception)
			{
			var code = exception is WebSocketException
				? ((WebSocketException)exception).Code
				: CloseStatusCode.Abnormal;

			fatal (message, (ushort)code);
			}

		private void fatal (string message, ushort code)
			{
			var payload = new PayloadData (code, message);
			close (payload, !code.IsReserved (), false, false);
			}

		private void fatal (string message, CloseStatusCode code)
			{
			fatal (message, (ushort)code);
			}

		private ClientSslConfiguration getSslConfiguration ()
			{
			if (_sslConfig == null)
				_sslConfig = new ClientSslConfiguration (_uri.DnsSafeHost);

			return _sslConfig;
			}

		private void init ()
			{
			_compression = CompressionMethod.None;
			_cookies = new CookieCollection ();
			_forPing = new object ();
			_forSend = new object ();
			_forState = new object ();
			_messageEventQueue = new Queue<MessageEventArgs> ();
			_forMessageEventQueue = ((ICollection)_messageEventQueue).SyncRoot;
			_readyState = WebSocketState.Connecting;
			}

		private void message ()
			{
			MessageEventArgs e = null;
			lock (_forMessageEventQueue)
				{
				if (_inMessage || _messageEventQueue.Count == 0 || _readyState != WebSocketState.Open)
					return;

				_inMessage = true;
				e = _messageEventQueue.Dequeue ();
				}

			_message (e);
			}

		private void messagec (MessageEventArgs e)
			{
			do
				{
				try
					{
					OnMessage.Emit (this, e);
					}
				catch (Exception ex)
					{
					_logger.Error (ex.ToString ());
					error ("An error has occurred during an OnMessage event.", ex);
					}

				lock (_forMessageEventQueue)
					{
					if (_messageEventQueue.Count == 0 || _readyState != WebSocketState.Open)
						{
						_inMessage = false;
						break;
						}

					e = _messageEventQueue.Dequeue ();
					}
				} while (true);
			}

#if !CLIENT
		private void messages (MessageEventArgs e)
			{
			try
				{
				OnMessage.Emit (this, e);
				}
			catch (Exception ex)
				{
				_logger.Error (ex.ToString ());
				error ("An error has occurred during an OnMessage event.", ex);
				}

			lock (_forMessageEventQueue)
				{
				if (_messageEventQueue.Count == 0 || _readyState != WebSocketState.Open)
					{
					_inMessage = false;
					return;
					}

				e = _messageEventQueue.Dequeue ();
				}

			ThreadPool.QueueUserWorkItem (state => messages (e));
			}
#endif

		private void open ()
			{
			_inMessage = true;
			startReceiving ();
			try
				{
				OnOpen.Emit (this, EventArgs.Empty);
				}
			catch (Exception ex)
				{
				_logger.Error (ex.ToString ());
				error ("An error has occurred during the OnOpen event.", ex);
				}

			MessageEventArgs e = null;
			lock (_forMessageEventQueue)
				{
				if (_messageEventQueue.Count == 0 || _readyState != WebSocketState.Open)
					{
					_inMessage = false;
					return;
					}

				e = _messageEventQueue.Dequeue ();
				}

#if SSHARP
			_message.BeginInvokeEx (ar => _message.EndInvokeEx (ar), null, e);
#elif NETCF
			ThreadPool.QueueUserWorkItem (o =>
				{
					var t = (Tuple<Action<MessageEventArgs>, MessageEventArgs>)o;
					t.Item1 (t.Item2);
				}, Tuple.Create (_message, e));
#else
			_message.BeginInvoke (e, ar => _message.EndInvoke (ar), null);
#endif
			}

		private bool ping (byte[] data)
			{
			if (_readyState != WebSocketState.Open)
				return false;

			var receivePong = _pongReceived;
			if (receivePong == null)
				return false;

			lock (_forPing)
				{
				try
					{
					receivePong.Reset ();
					if (!send (Fin.Final, Opcode.Ping, data, false))
						return false;

					return receivePong.WaitOne (_waitTime);
					}
				catch (ObjectDisposedException)
					{
					return false;
					}
				}
			}

		private bool processCloseFrame (WebSocketFrame frame)
			{
			var payload = frame.PayloadData;
			close (payload, !payload.HasReservedCode, false, true);

			return false;
			}

		// As client
		private void processCookies (CookieCollection cookies)
			{
			if (cookies.Count == 0)
				return;

			_cookies.SetOrRemove (cookies);
			}

		private bool processDataFrame (WebSocketFrame frame)
			{
			enqueueToMessageEventQueue (
				frame.IsCompressed
					? new MessageEventArgs (
						frame.Opcode, frame.PayloadData.ApplicationData.Decompress (_compression))
					: new MessageEventArgs (frame));

			return true;
			}

		private bool processFragmentFrame (WebSocketFrame frame)
			{
			if (!_inContinuation)
				{
				// Must process first fragment.
				if (frame.IsContinuation)
					return true;

				_fragmentsOpcode = frame.Opcode;
				_fragmentsCompressed = frame.IsCompressed;
				_fragmentsBuffer = new MemoryStream ();
				_inContinuation = true;
				}

			_fragmentsBuffer.WriteBytes (frame.PayloadData.ApplicationData, 1024);
			if (frame.IsFinal)
				{
				using (_fragmentsBuffer)
					{
					var data = _fragmentsCompressed
						? _fragmentsBuffer.DecompressToArray (_compression)
						: _fragmentsBuffer.ToArray ();

					enqueueToMessageEventQueue (new MessageEventArgs (_fragmentsOpcode, data));
					}

				_fragmentsBuffer = null;
				_inContinuation = false;
				}

			return true;
			}

		private bool processPingFrame (WebSocketFrame frame)
			{
			_logger.Trace ("A ping was received.");

			var pong = WebSocketFrame.CreatePongFrame (frame.PayloadData, _client);

			lock (_forState)
				{
				if (_readyState != WebSocketState.Open)
					{
					_logger.Error ("The connection is closing.");
					return true;
					}

				if (!sendBytes (pong.ToArray ()))
					return false;
				}

			_logger.Trace ("A pong to this ping has been sent.");

			if (_emitOnPing)
				{
				if (_client)
					pong.Unmask ();

				enqueueToMessageEventQueue (new MessageEventArgs (frame));
				}

			return true;
			}

		private bool processPongFrame (WebSocketFrame frame)
			{
			_logger.Trace ("A pong was received.");

			try
				{
				_pongReceived.Set ();
				}
			catch (NullReferenceException ex)
				{
				_logger.Error (ex.Message);
				_logger.Debug (ex.ToString ());

				return false;
				}
			catch (ObjectDisposedException ex)
				{
				_logger.Error (ex.Message);
				_logger.Debug (ex.ToString ());

				return false;
				}

			_logger.Trace ("It has been signaled.");

			return true;
			}

		private bool processReceivedFrame (WebSocketFrame frame)
			{
			string msg;
			if (!checkReceivedFrame (frame, out msg))
				throw new WebSocketException (CloseStatusCode.ProtocolError, msg);

			frame.Unmask ();
			return frame.IsFragment
				? processFragmentFrame (frame)
				: frame.IsData
					? processDataFrame (frame)
					: frame.IsPing
						? processPingFrame (frame)
						: frame.IsPong
							? processPongFrame (frame)
							: frame.IsClose
								? processCloseFrame (frame)
								: processUnsupportedFrame (frame);
			}

#if !CLIENT
		// As server
		private void processSecWebSocketExtensionsClientHeader (string value)
			{
			if (value == null)
				return;

			var buff = new StringBuilder (80);
			var comp = false;
			foreach (var elm in value.SplitHeaderValue (','))
				{
				var extension = elm.Trim ();
				if (extension.Length == 0)
					continue;

				if (!comp)
					{
					if (extension.IsCompressionExtension (CompressionMethod.Deflate))
						{
						_compression = CompressionMethod.Deflate;

						buff.AppendFormat ("{0}, ",_compression.ToExtensionString ("client_no_context_takeover", "server_no_context_takeover"));

						comp = true;
						}
					}
				}

			var len = buff.Length;
			if (len <= 2)
				return;

			buff.Length = len - 2;
			_extensions = buff.ToString ();
			}
#endif

		// As client
		private void processSecWebSocketExtensionsServerHeader (string value)
			{
			if (value == null)
				{
				_compression = CompressionMethod.None;
				return;
				}

			_extensions = value;
			}

#if !CLIENT
		// As server
		private void processSecWebSocketProtocolClientHeader (IEnumerable<string> values)
			{
			if (values.Contains (val => val == _protocol))
				return;

			_protocol = null;
			}

#endif

		private bool processUnsupportedFrame (WebSocketFrame frame)
			{
			_logger.Fatal ("An unsupported frame:" + frame.PrintToString (false));
			fatal ("There is no way to handle it.", CloseStatusCode.PolicyViolation);

			return false;
			}

#if !CLIENT
		// As server
		private void refuseHandshake (CloseStatusCode code, string reason)
			{
			_readyState = WebSocketState.Closing;

			var res = createHandshakeFailureResponse (HttpStatusCode.BadRequest);
			sendHttpResponse (res);

			releaseServerResources ();

			_readyState = WebSocketState.Closed;

			var e = new CloseEventArgs (code, reason);

			try
				{
				OnClose.Emit (this, e);
				}
			catch (Exception ex)
				{
				_logger.Error (ex.Message);
				_logger.Debug (ex.ToString ());
				}
			}
#endif

		// As client
		private void releaseClientResources ()
			{
			if (_stream != null)
				{
				_stream.Dispose ();
				_stream = null;
				}

			if (_tcpClient != null)
				{
				_tcpClient.Close ();
				_tcpClient = null;
				}
			}

		private void releaseCommonResources ()
			{
			if (_fragmentsBuffer != null)
				{
				_fragmentsBuffer.Dispose ();
				_fragmentsBuffer = null;
				_inContinuation = false;
				}

			if (_pongReceived != null)
				{
				_pongReceived.Close ();
				_pongReceived = null;
				}

			if (_receivingExited != null)
				{
				_receivingExited.Close ();
				_receivingExited = null;
				}
			}

		private void releaseResources ()
			{
			if (_client)
				releaseClientResources ();
#if !CLIENT
			else
				releaseServerResources ();
#endif
			releaseCommonResources ();
			}

#if !CLIENT
		// As server
		private void releaseServerResources ()
			{
			if (_closeContext == null)
				return;

			_closeContext ();
			_closeContext = null;
			_stream = null;
			_context = null;
			}
#endif

		private bool send (Opcode opcode, Stream stream)
			{
			lock (_forSend)
				{
				var src = stream;
				var compressed = false;
				var sent = false;
				try
					{
					if (_compression != CompressionMethod.None)
						{
						stream = stream.Compress (_compression);
						compressed = true;
						}

					sent = send (opcode, stream, compressed);
					if (!sent)
						error ("A send has been interrupted.", null);
					}
				catch (Exception ex)
					{
					_logger.Error (ex.ToString ());
					error ("An error has occurred during a send.", ex);
					}
				finally
					{
					if (compressed)
						stream.Dispose ();

					src.Dispose ();
					}

				return sent;
				}
			}

		private bool send (Opcode opcode, Stream stream, bool compressed)
			{
			var len = stream.Length;
			if (len == 0)
				return send (Fin.Final, opcode, EmptyBytes, false);

			var quo = len/FragmentLength;
			var rem = (int)(len%FragmentLength);

			byte[] buff = null;
			if (quo == 0)
				{
				buff = new byte[rem];
				return stream.Read (buff, 0, rem) == rem
				       && send (Fin.Final, opcode, buff, compressed);
				}

			if (quo == 1 && rem == 0)
				{
				buff = new byte[FragmentLength];
				return stream.Read (buff, 0, FragmentLength) == FragmentLength
				       && send (Fin.Final, opcode, buff, compressed);
				}

			/* Send fragments */

			// Begin
			buff = new byte[FragmentLength];
			var sent = stream.Read (buff, 0, FragmentLength) == FragmentLength
			           && send (Fin.More, opcode, buff, compressed);

			if (!sent)
				return false;

			var n = rem == 0 ? quo - 2 : quo - 1;
			for (long i = 0; i < n; i++)
				{
				sent = stream.Read (buff, 0, FragmentLength) == FragmentLength && send (Fin.More, Opcode.Cont, buff, false);

				if (!sent)
					return false;
				}

			// End
			if (rem == 0)
				rem = FragmentLength;
			else
				buff = new byte[rem];

			return stream.Read (buff, 0, rem) == rem
			       && send (Fin.Final, Opcode.Cont, buff, false);
			}

		private bool send (Fin fin, Opcode opcode, byte[] data, bool compressed)
			{
			lock (_forState)
				{
				if (_readyState != WebSocketState.Open)
					{
					_logger.Error ("The connection is closing.");
					return false;
					}

				var frame = new WebSocketFrame (fin, opcode, data, compressed, _client);
				return sendBytes (frame.ToArray ());
				}
			}

		private void sendAsync (Opcode opcode, Stream stream, Action<bool> completed)
			{
#if SSHARP
			Func<Opcode, Stream, bool> sender = send;
			sender.BeginInvokeEx (
				ar =>
					{
					try
						{
						var sent = sender.EndInvokeEx<bool> (ar);
						if (completed != null)
							completed (sent);
						}
					catch (Exception ex)
						{
						_logger.Error (ex.ToString ());
						error ("An error has occurred during the callback for an async send.", ex);
						}
					},
				null,
				opcode,
				stream
				);
#elif NETCF
			ThreadPool.QueueUserWorkItem (o =>
				{
					var t = (Tuple<Opcode, Stream, Action<bool>>)o;
					var sent = send (t.Item1, t.Item2);
					try
						{
						if (t.Item3 != null)
							t.Item3 (sent);
						}
					catch (Exception ex)
						{
						_logger.Error (ex.ToString ());
						error ("An exception has occurred during the callback for an async send.", ex);

						}
				}, Tuple.Create (opcode, stream, completed));
#else
			Func<Opcode, Stream, bool> sender = send;
			sender.BeginInvoke (
			  opcode,
			  stream,
			  ar =>
				  {
				  try
					  {
					  var sent = sender.EndInvoke (ar);
					  if (completed != null)
						  completed (sent);
					  }
				  catch (Exception ex)
					  {
					  _logger.Error (ex.ToString ());
					  error ("An exception has occurred during the callback for an async send.", ex);
					  }
				  },
			  null);
#endif
			}

		private bool sendBytes (byte[] bytes)
			{
			try
				{
				_stream.Write (bytes, 0, bytes.Length);
				}
			catch (Exception ex)
				{
				_logger.Error (ex.Message);
				_logger.Debug (ex.ToString ());

				return false;
				}

			return true;
			}

		// As client
		private HttpResponse sendHandshakeRequest ()
			{
			var req = createHandshakeRequest ();
			var res = sendHttpRequest (req, 90000);
			if (res.IsUnauthorized)
				{
				var chal = res.Headers["WWW-Authenticate"];
				_logger.Warn (String.Format ("Received an authentication requirement for '{0}'.", chal));
				if (chal.IsNullOrEmpty ())
					{
					_logger.Error ("No authentication challenge is specified.");
					return res;
					}

				_authChallenge = AuthenticationChallenge.Parse (chal);
				if (_authChallenge == null)
					{
					_logger.Error ("An invalid authentication challenge is specified.");
					return res;
					}

				if (_credentials != null &&
				    (!_preAuth || _authChallenge.Scheme == AuthenticationSchemes.Digest))
					{
					if (res.HasConnectionClose)
						{
						releaseClientResources ();
						setClientStream ();
						}

					var authRes = new AuthenticationResponse (_authChallenge, _credentials, _nonceCount);
					_nonceCount = authRes.NonceCount;
					req.Headers["Authorization"] = authRes.ToString ();
					res = sendHttpRequest (req, 15000);
					}
				}

			if (res.IsRedirect)
				{
				var url = res.Headers["Location"];
				_logger.Warn (String.Format ("Received a redirection to '{0}'.", url));
				if (_enableRedirection)
					{
					if (url.IsNullOrEmpty ())
						{
						_logger.Error ("No url to redirect is located.");
						return res;
						}

					Uri uri;
					string msg;
					if (!url.TryCreateWebSocketUri (out uri, out msg))
						{
						_logger.Error ("An invalid url to redirect is located: " + msg);
						return res;
						}

					releaseClientResources ();

					_uri = uri;
					_secure = uri.Scheme == "wss";

					setClientStream ();
					return sendHandshakeRequest ();
					}
				}

			return res;
			}

		// As client
		private HttpResponse sendHttpRequest (HttpRequest request, int millisecondsTimeout)
			{
			_logger.Debug ("A request to the server:\n" + request.ToString ());
			var res = request.GetResponse (_stream, millisecondsTimeout);
			_logger.Debug ("A response to this request:\n" + res.ToString ());

			return res;
			}

#if !CLIENT
		// As server
		private bool sendHttpResponse (HttpResponse response)
			{
			_logger.Debug (String.Format ("A response to {0}:\n{1}", _context.UserEndPoint, response));

			return sendBytes (response.ToByteArray ());
			}
#endif

		// As client
		private void sendProxyConnectRequest ()
			{
			var req = HttpRequest.CreateConnectRequest (_uri);
			var res = sendHttpRequest (req, 90000);
			if (res.IsProxyAuthenticationRequired)
				{
				var chal = res.Headers["Proxy-Authenticate"];
				_logger.Warn (
					String.Format ("Received a proxy authentication requirement for '{0}'.", chal));

				if (chal.IsNullOrEmpty ())
					throw new WebSocketException ("No proxy authentication challenge is specified.");

				var authChal = AuthenticationChallenge.Parse (chal);
				if (authChal == null)
					throw new WebSocketException ("An invalid proxy authentication challenge is specified.");

				if (_proxyCredentials != null)
					{
					if (res.HasConnectionClose)
						{
						releaseClientResources ();
						_tcpClient = new TcpClient (_proxyUri.DnsSafeHost, _proxyUri.Port
#if SSHARP
							, 8192
#endif
							);
#if SSHARP
						_tcpClient.ConnectToServer ();
#endif
						_stream = _tcpClient.GetStream ();
#if BUFFERED
						_stream = new BufferedNetworkStream ((NetworkStream)_stream);
#endif
						}

					var authRes = new AuthenticationResponse (authChal, _proxyCredentials, 0);
					req.Headers["Proxy-Authorization"] = authRes.ToString ();
					res = sendHttpRequest (req, 15000);
					}

				if (res.IsProxyAuthenticationRequired)
					throw new WebSocketException ("A proxy authentication is required.");
				}

			if (res.StatusCode[0] != '2')
				throw new WebSocketException (
					"The proxy has failed a connection to the requested host and port.");
			}

		// As client
		private void setClientStream ()
			{
			if (_proxyUri != null)
				{
#if SSHARP
				_tcpClient = new TcpClient (new IPEndPoint (DnsEx.GetHostAddresses (_proxyUri.DnsSafeHost)[0], _proxyUri.Port), 8192)
					{
					Nagle = true
					};

				_tcpClient.ConnectToServer ();
#else
				_tcpClient = new TcpClient (_proxyUri.DnsSafeHost, _proxyUri.Port
#endif
				_stream = _tcpClient.GetStream ();
#if BUFFERED
				_stream = new BufferedNetworkStream ((NetworkStream)_stream);
#endif
				sendProxyConnectRequest ();
				}
			else
				{
#if SSHARP
				_tcpClient = new TCPClient (new IPEndPoint (DnsEx.GetHostAddresses (_uri.DnsSafeHost)[0], _uri.Port), 8192)
					{
					Nagle = true
					};
				_tcpClient.ConnectToServer ();
#else
				_tcpClient = new TcpClient (_uri.DnsSafeHost, _uri.Port);
#endif
				_stream = _tcpClient.GetStream ();
#if BUFFERED
				_stream = new BufferedNetworkStream ((NetworkStream)_stream);
#endif
				}

#if !NETCF || BCC || SSL
			if (_secure)
				{
				var conf = getSslConfiguration ();
				var host = conf.TargetHost;
				if (host != _uri.DnsSafeHost)
					throw new WebSocketException (
						CloseStatusCode.TlsHandshakeFailure, "An invalid host name is specified.");

				try
					{
					var sslStream = new SslStream (
						_stream,
						false,
						conf.ServerCertificateValidationCallback,
						conf.ClientCertificateSelectionCallback);

					sslStream.AuthenticateAsClient (
						host,
						conf.ClientCertificates,
						conf.EnabledSslProtocols,
						conf.CheckCertificateRevocation);

					_stream = sslStream;
					}
				catch (Exception ex)
					{
					throw new WebSocketException (CloseStatusCode.TlsHandshakeFailure, ex);
					}
				}
#endif
			}

		private void startReceiving ()
			{
			if (_messageEventQueue.Count > 0)
				_messageEventQueue.Clear ();

			_receivingExited = new ManualResetEvent (false);
			_pongReceived = new ManualResetEvent (false);

			Action receive = null;
			receive =
				() =>
					WebSocketFrame.ReadFrameAsync (
						_stream,
						false,
						frame =>
							{
							if (!processReceivedFrame (frame) || _readyState == WebSocketState.Closed)
								{
								var exit = _receivingExited;
								if (exit != null)
									exit.Set ();

								return;
								}

							_lastReceivedTime = DateTime.Now;

							// Receive next asap because the Ping or Close needs a response to it.
							receive ();

							if (_inMessage || !HasMessage || _readyState != WebSocketState.Open)
								return;

							message ();
							},
						ex =>
							{
							_logger.Fatal (ex.ToString ());
							fatal ("An exception has occurred while receiving.", ex);
							}
						);

			receive ();
			}

		// As client
		private bool validateSecWebSocketAcceptHeader (string value)
			{
			return value != null && value == CreateResponseKey (_base64Key);
			}

		// As client
		private bool validateSecWebSocketExtensionsServerHeader (string value)
			{
			if (value == null)
				return true;

			if (value.Length == 0)
				return false;

			if (!_extensionsRequested)
				return false;

			var comp = _compression != CompressionMethod.None;
			foreach (var e in value.SplitHeaderValue (','))
				{
				var ext = e.Trim ();
				if (comp && ext.IsCompressionExtension (_compression))
					{
					if (!ext.Contains ("server_no_context_takeover"))
						{
						_logger.Error ("The server hasn't sent back 'server_no_context_takeover'.");
						return false;
						}

					if (!ext.Contains ("client_no_context_takeover"))
						_logger.Warn ("The server hasn't sent back 'client_no_context_takeover'.");

					var method = _compression.ToExtensionString ();
					var invalid =
						ext.SplitHeaderValue (';').Contains (
							t =>
								{
								t = t.Trim ();
								return t != method
								       && t != "server_no_context_takeover"
								       && t != "client_no_context_takeover";
								}
							);

					if (invalid)
						return false;
					}
				else
					{
					return false;
					}
				}

			return true;
			}

		// As client
		private bool validateSecWebSocketProtocolServerHeader (string value)
			{
			if (value == null)
				return !_protocolsRequested;

			if (value.Length == 0)
				return false;

			return _protocolsRequested && _protocols.Contains (p => p == value);
			}

		// As client
		private bool validateSecWebSocketVersionServerHeader (string value)
			{
			return value == null || value == _version;
			}

		#endregion

		#region Internal Methods

#if !CLIENT
		// As server
		internal void Close (HttpResponse response)
			{
			_readyState = WebSocketState.Closing;

			sendHttpResponse (response);
			releaseServerResources ();

			_readyState = WebSocketState.Closed;
			}

		// As server
		internal void Close (PayloadData payloadData, byte[] frameAsBytes)
			{
			lock (_forState)
				{
				if (_readyState == WebSocketState.Closing)
					{
					_logger.Info ("The closing is already in progress.");
					return;
					}

				if (_readyState == WebSocketState.Closed)
					{
					_logger.Info ("The connection has already been closed.");
					return;
					}

				_readyState = WebSocketState.Closing;
				}

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

			var sent = frameAsBytes != null && sendBytes (frameAsBytes);
			var received = sent && _receivingExited != null
				? _receivingExited.WaitOne (_waitTime)
				: false;

			var res = sent && received;

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

			releaseServerResources ();
			releaseCommonResources ();

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

			_readyState = WebSocketState.Closed;

			var e = new CloseEventArgs (payloadData);
			e.WasClean = res;

			try
				{
				OnClose.Emit (this, e);
				}
			catch (Exception ex)
				{
				_logger.Error (ex.ToString ());
				}
			}

		// As server
		internal void Close (HttpStatusCode code)
			{
			Close (createHandshakeFailureResponse (code));
			}

#endif

		// As client
		internal static string CreateBase64Key ()
			{
			var src = new byte[16];
			RandomNumber.GetBytes (src);

			return Convert.ToBase64String (src);
			}

		internal static string CreateResponseKey (string base64Key)
			{
			var buff = new StringBuilder (base64Key, 64);
			buff.Append (_guid);
			SHA1 sha1 = new SHA1CryptoServiceProvider ();
			var src = sha1.ComputeHash (buff.ToString ().UTF8Encode ());

			return Convert.ToBase64String (src);
			}

#if !CLIENT
		// As server
		internal void InternalAccept ()
			{
			try
				{
				if (!acceptHandshake ())
					return;
				}
			catch (Exception ex)
				{
				_logger.Fatal (ex.Message);
				_logger.Debug (ex.ToString ());

				var msg = "An exception has occurred while attempting to accept.";
				fatal (msg, ex);

				return;
				}

			_readyState = WebSocketState.Open;

			open ();
			}
#endif

		internal bool Ping (byte[] frameAsBytes, TimeSpan timeout)
			{
			if (_readyState != WebSocketState.Open)
				return false;

			var receivePong = _pongReceived;
			if (receivePong == null)
				return false;

			lock (_forPing)
				{
				try
					{
					receivePong.Reset ();

					lock (_forState)
						{
						if (_readyState != WebSocketState.Open)
							return false;

						if (!sendBytes (frameAsBytes))
							return false;
						}

					return receivePong.WaitOne (timeout);
					}
				catch (ObjectDisposedException)
					{
					return false;
					}
				}
			}

#if !CLIENT
		// As server
		internal void Send (Opcode opcode, byte[] data, Dictionary<CompressionMethod, byte[]> cache)
			{
			lock (_forSend)
				{
				lock (_forState)
					{
					if (_readyState != WebSocketState.Open)
						{
						_logger.Error ("The connection is closing.");
						return;
						}

					byte[] found;
					if (!cache.TryGetValue (_compression, out found))
						{
						found = new WebSocketFrame (
							Fin.Final,
							opcode,
							data.Compress (_compression),
							_compression != CompressionMethod.None,
							false
							)
							.ToArray ();

						cache.Add (_compression, found);
						}

					sendBytes (found);
					}
				}
			}

		// As server
		internal void Send (Opcode opcode, Stream stream, Dictionary<CompressionMethod, Stream> cache)
			{
			lock (_forSend)
				{
				Stream found;
				if (!cache.TryGetValue (_compression, out found))
					{
					found = stream.Compress (_compression);
					cache.Add (_compression, found);
					}
				else
					{
					found.Position = 0;
					}

				send (opcode, found, _compression != CompressionMethod.None);
				}
			}
#endif

		#endregion

		#region Public Methods

#if !CLIENT
		/// <summary>
		/// Accepts the handshake request.
		/// </summary>
		/// <remarks>
		/// This method does nothing if the handshake request has already been
		/// accepted.
		/// </remarks>
		/// <exception cref="InvalidOperationException">
		///   <para>
		///   This instance is a client.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The close process is in progress.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The connection has already been closed.
		///   </para>
		/// </exception>
		public void Accept ()
			{
			if (_client)
				{
				var msg = "This instance is a client.";
				throw new InvalidOperationException (msg);
				}

			if (_readyState == WebSocketState.Closing)
				{
				var msg = "The close process is in progress.";
				throw new InvalidOperationException (msg);
				}

			if (_readyState == WebSocketState.Closed)
				{
				var msg = "The connection has already been closed.";
				throw new InvalidOperationException (msg);
				}

			if (accept ())
				open ();
			}

		/// <summary>
		/// Accepts the handshake request asynchronously.
		/// </summary>
		/// <remarks>
		///   <para>
		///   This method does not wait for the accept process to be complete.
		///   </para>
		///   <para>
		///   This method does nothing if the handshake request has already been
		///   accepted.
		///   </para>
		/// </remarks>
		/// <exception cref="InvalidOperationException">
		///   <para>
		///   This instance is a client.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The close process is in progress.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The connection has already been closed.
		///   </para>
		/// </exception>
		public void AcceptAsync ()
			{
			if (_client)
				{
				var msg = "This instance is a client.";
				throw new InvalidOperationException (msg);
				}

			if (_readyState == WebSocketState.Closing)
				{
				var msg = "The close process is in progress.";
				throw new InvalidOperationException (msg);
				}

			if (_readyState == WebSocketState.Closed)
				{
				var msg = "The connection has already been closed.";
				throw new InvalidOperationException (msg);
				}

#if SSHARP
			Func<bool> acceptor = accept;
			acceptor.BeginInvokeEx (
				ar =>
					{
					if (acceptor.EndInvokeEx<bool> (ar))
						open ();
					},
				null);
#elif NETCF
			ThreadPool.QueueUserWorkItem (o =>
				{
					if (accept ())
						open ();
				});
#else
			Func<bool> acceptor = accept;
			acceptor.BeginInvoke (
			  ar =>
				  {
				  if (acceptor.EndInvoke (ar))
					  open ();
				  },
			  null);
#endif
			}
#endif

		/// <summary>
		/// Closes the connection.
		/// </summary>
		/// <remarks>
		/// This method does nothing if the current state of the connection is
		/// Closing or Closed.
		/// </remarks>
		public void Close ()
			{
			close (1005, String.Empty);
			}

		/// <summary>
		/// Closes the connection with the specified code.
		/// </summary>
		/// <remarks>
		/// This method does nothing if the current state of the connection is
		/// Closing or Closed.
		/// </remarks>
		/// <param name="code">
		///   <para>
		///   A <see cref="ushort"/> that represents the status code indicating
		///   the reason for the close.
		///   </para>
		///   <para>
		///   The status codes are defined in
		///   <see href="http://tools.ietf.org/html/rfc6455#section-7.4">
		///   Section 7.4</see> of RFC 6455.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentOutOfRangeException">
		/// <paramref name="code"/> is less than 1000 or greater than 4999.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="code"/> is 1011 (server error).
		///   It cannot be used by clients.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is 1010 (mandatory extension).
		///   It cannot be used by servers.
		///   </para>
		/// </exception>
		public void Close (ushort code)
			{
			if (!code.IsCloseStatusCode ())
				{
				var msg = "Less than 1000 or greater than 4999.";
				throw new ArgumentOutOfRangeException ("code", msg);
				}

			if (_client && code == 1011)
				{
				var msg = "1011 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (!_client && code == 1010)
				{
				var msg = "1010 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			close (code, String.Empty);
			}

		/// <summary>
		/// Closes the connection with the specified code.
		/// </summary>
		/// <remarks>
		/// This method does nothing if the current state of the connection is
		/// Closing or Closed.
		/// </remarks>
		/// <param name="code">
		///   <para>
		///   One of the <see cref="CloseStatusCode"/> enum values.
		///   </para>
		///   <para>
		///   It represents the status code indicating the reason for the close.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.ServerError"/>.
		///   It cannot be used by clients.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.MandatoryExtension"/>.
		///   It cannot be used by servers.
		///   </para>
		/// </exception>
		public void Close (CloseStatusCode code)
			{
			if (_client && code == CloseStatusCode.ServerError)
				{
				var msg = "ServerError cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (!_client && code == CloseStatusCode.MandatoryExtension)
				{
				var msg = "MandatoryExtension cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			close ((ushort)code, String.Empty);
			}

		/// <summary>
		/// Closes the connection with the specified code and reason.
		/// </summary>
		/// <remarks>
		/// This method does nothing if the current state of the connection is
		/// Closing or Closed.
		/// </remarks>
		/// <param name="code">
		///   <para>
		///   A <see cref="ushort"/> that represents the status code
		///   indicating the reason for the close.
		///   </para>
		///   <para>
		///   The status codes are defined in
		///   <see href="http://tools.ietf.org/html/rfc6455#section-7.4">
		///   Section 7.4</see> of RFC 6455.
		///   </para>
		/// </param>
		/// <param name="reason">
		///   <para>
		///   A <see cref="string"/> that represents the reason for the close.
		///   </para>
		///   <para>
		///   The size must be 123 bytes or less in UTF-8.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentOutOfRangeException">
		///   <para>
		///   <paramref name="code"/> is less than 1000 or greater than 4999.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The size of <paramref name="reason"/> is greater than 123 bytes.
		///   </para>
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="code"/> is 1011 (server error).
		///   It cannot be used by clients.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is 1010 (mandatory extension).
		///   It cannot be used by servers.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is 1005 (no status) and there is reason.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="reason"/> could not be UTF-8-encoded.
		///   </para>
		/// </exception>
		public void Close (ushort code, string reason)
			{
			if (!code.IsCloseStatusCode ())
				{
				var msg = "Less than 1000 or greater than 4999.";
				throw new ArgumentOutOfRangeException ("code", msg);
				}

			if (_client && code == 1011)
				{
				var msg = "1011 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (!_client && code == 1010)
				{
				var msg = "1010 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (reason.IsNullOrEmpty ())
				{
				close (code, String.Empty);
				return;
				}

			if (code == 1005)
				{
				var msg = "1005 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			byte[] bytes;
			if (!reason.TryGetUTF8EncodedBytes (out bytes))
				{
				var msg = "It could not be UTF-8-encoded.";
				throw new ArgumentException (msg, "reason");
				}

			if (bytes.Length > 123)
				{
				var msg = "Its size is greater than 123 bytes.";
				throw new ArgumentOutOfRangeException ("reason", msg);
				}

			close (code, reason);
			}

		/// <summary>
		/// Closes the connection with the specified code and reason.
		/// </summary>
		/// <remarks>
		/// This method does nothing if the current state of the connection is
		/// Closing or Closed.
		/// </remarks>
		/// <param name="code">
		///   <para>
		///   One of the <see cref="CloseStatusCode"/> enum values.
		///   </para>
		///   <para>
		///   It represents the status code indicating the reason for the close.
		///   </para>
		/// </param>
		/// <param name="reason">
		///   <para>
		///   A <see cref="string"/> that represents the reason for the close.
		///   </para>
		///   <para>
		///   The size must be 123 bytes or less in UTF-8.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.ServerError"/>.
		///   It cannot be used by clients.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.MandatoryExtension"/>.
		///   It cannot be used by servers.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.NoStatus"/> and there is reason.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="reason"/> could not be UTF-8-encoded.
		///   </para>
		/// </exception>
		/// <exception cref="ArgumentOutOfRangeException">
		/// The size of <paramref name="reason"/> is greater than 123 bytes.
		/// </exception>
		public void Close (CloseStatusCode code, string reason)
			{
			if (_client && code == CloseStatusCode.ServerError)
				{
				var msg = "ServerError cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (!_client && code == CloseStatusCode.MandatoryExtension)
				{
				var msg = "MandatoryExtension cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (reason.IsNullOrEmpty ())
				{
				close ((ushort)code, String.Empty);
				return;
				}

			if (code == CloseStatusCode.NoStatus)
				{
				var msg = "NoStatus cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			byte[] bytes;
			if (!reason.TryGetUTF8EncodedBytes (out bytes))
				{
				var msg = "It could not be UTF-8-encoded.";
				throw new ArgumentException (msg, "reason");
				}

			if (bytes.Length > 123)
				{
				var msg = "Its size is greater than 123 bytes.";
				throw new ArgumentOutOfRangeException ("reason", msg);
				}

			close ((ushort)code, reason);
			}

		/// <summary>
		/// Closes the connection asynchronously.
		/// </summary>
		/// <remarks>
		///   <para>
		///   This method does not wait for the close to be complete.
		///   </para>
		///   <para>
		///   This method does nothing if the current state of the connection is
		///   Closing or Closed.
		///   </para>
		/// </remarks>
		public void CloseAsync ()
			{
			closeAsync (1005, String.Empty);
			}

		/// <summary>
		/// Closes the connection asynchronously with the specified code.
		/// </summary>
		/// <remarks>
		///   <para>
		///   This method does not wait for the close to be complete.
		///   </para>
		///   <para>
		///   This method does nothing if the current state of the connection is
		///   Closing or Closed.
		///   </para>
		/// </remarks>
		/// <param name="code">
		///   <para>
		///   A <see cref="ushort"/> that represents the status code
		///   indicating the reason for the close.
		///   </para>
		///   <para>
		///   The status codes are defined in
		///   <see href="http://tools.ietf.org/html/rfc6455#section-7.4">
		///   Section 7.4</see> of RFC 6455.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentOutOfRangeException">
		/// <paramref name="code"/> is less than 1000 or greater than 4999.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="code"/> is 1011 (server error).
		///   It cannot be used by clients.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is 1010 (mandatory extension).
		///   It cannot be used by servers.
		///   </para>
		/// </exception>
		public void CloseAsync (ushort code)
			{
			if (!code.IsCloseStatusCode ())
				{
				var msg = "Less than 1000 or greater than 4999.";
				throw new ArgumentOutOfRangeException ("code", msg);
				}

			if (_client && code == 1011)
				{
				var msg = "1011 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (!_client && code == 1010)
				{
				var msg = "1010 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			closeAsync (code, String.Empty);
			}

		/// <summary>
		/// Closes the connection asynchronously with the specified code.
		/// </summary>
		/// <remarks>
		///   <para>
		///   This method does not wait for the close to be complete.
		///   </para>
		///   <para>
		///   This method does nothing if the current state of the connection is
		///   Closing or Closed.
		///   </para>
		/// </remarks>
		/// <param name="code">
		///   <para>
		///   One of the <see cref="CloseStatusCode"/> enum values.
		///   </para>
		///   <para>
		///   It represents the status code indicating the reason for the close.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.ServerError"/>.
		///   It cannot be used by clients.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.MandatoryExtension"/>.
		///   It cannot be used by servers.
		///   </para>
		/// </exception>
		public void CloseAsync (CloseStatusCode code)
			{
			if (_client && code == CloseStatusCode.ServerError)
				{
				var msg = "ServerError cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (!_client && code == CloseStatusCode.MandatoryExtension)
				{
				var msg = "MandatoryExtension cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			closeAsync ((ushort)code, String.Empty);
			}

		/// <summary>
		/// Closes the connection asynchronously with the specified code and reason.
		/// </summary>
		/// <remarks>
		///   <para>
		///   This method does not wait for the close to be complete.
		///   </para>
		///   <para>
		///   This method does nothing if the current state of the connection is
		///   Closing or Closed.
		///   </para>
		/// </remarks>
		/// <param name="code">
		///   <para>
		///   A <see cref="ushort"/> that represents the status code
		///   indicating the reason for the close.
		///   </para>
		///   <para>
		///   The status codes are defined in
		///   <see href="http://tools.ietf.org/html/rfc6455#section-7.4">
		///   Section 7.4</see> of RFC 6455.
		///   </para>
		/// </param>
		/// <param name="reason">
		///   <para>
		///   A <see cref="string"/> that represents the reason for the close.
		///   </para>
		///   <para>
		///   The size must be 123 bytes or less in UTF-8.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentOutOfRangeException">
		///   <para>
		///   <paramref name="code"/> is less than 1000 or greater than 4999.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The size of <paramref name="reason"/> is greater than 123 bytes.
		///   </para>
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="code"/> is 1011 (server error).
		///   It cannot be used by clients.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is 1010 (mandatory extension).
		///   It cannot be used by servers.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is 1005 (no status) and there is reason.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="reason"/> could not be UTF-8-encoded.
		///   </para>
		/// </exception>
		public void CloseAsync (ushort code, string reason)
			{
			if (!code.IsCloseStatusCode ())
				{
				var msg = "Less than 1000 or greater than 4999.";
				throw new ArgumentOutOfRangeException ("code", msg);
				}

			if (_client && code == 1011)
				{
				var msg = "1011 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (!_client && code == 1010)
				{
				var msg = "1010 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (reason.IsNullOrEmpty ())
				{
				closeAsync (code, String.Empty);
				return;
				}

			if (code == 1005)
				{
				var msg = "1005 cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			byte[] bytes;
			if (!reason.TryGetUTF8EncodedBytes (out bytes))
				{
				var msg = "It could not be UTF-8-encoded.";
				throw new ArgumentException (msg, "reason");
				}

			if (bytes.Length > 123)
				{
				var msg = "Its size is greater than 123 bytes.";
				throw new ArgumentOutOfRangeException ("reason", msg);
				}

			closeAsync (code, reason);
			}

		/// <summary>
		/// Closes the connection asynchronously with the specified code and reason.
		/// </summary>
		/// <remarks>
		///   <para>
		///   This method does not wait for the close to be complete.
		///   </para>
		///   <para>
		///   This method does nothing if the current state of the connection is
		///   Closing or Closed.
		///   </para>
		/// </remarks>
		/// <param name="code">
		///   <para>
		///   One of the <see cref="CloseStatusCode"/> enum values.
		///   </para>
		///   <para>
		///   It represents the status code indicating the reason for the close.
		///   </para>
		/// </param>
		/// <param name="reason">
		///   <para>
		///   A <see cref="string"/> that represents the reason for the close.
		///   </para>
		///   <para>
		///   The size must be 123 bytes or less in UTF-8.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.ServerError"/>.
		///   It cannot be used by clients.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.MandatoryExtension"/>.
		///   It cannot be used by servers.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="code"/> is
		///   <see cref="CloseStatusCode.NoStatus"/> and there is reason.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="reason"/> could not be UTF-8-encoded.
		///   </para>
		/// </exception>
		/// <exception cref="ArgumentOutOfRangeException">
		/// The size of <paramref name="reason"/> is greater than 123 bytes.
		/// </exception>
		public void CloseAsync (CloseStatusCode code, string reason)
			{
			if (_client && code == CloseStatusCode.ServerError)
				{
				var msg = "ServerError cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (!_client && code == CloseStatusCode.MandatoryExtension)
				{
				var msg = "MandatoryExtension cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			if (reason.IsNullOrEmpty ())
				{
				closeAsync ((ushort)code, String.Empty);
				return;
				}

			if (code == CloseStatusCode.NoStatus)
				{
				var msg = "NoStatus cannot be used.";
				throw new ArgumentException (msg, "code");
				}

			byte[] bytes;
			if (!reason.TryGetUTF8EncodedBytes (out bytes))
				{
				var msg = "It could not be UTF-8-encoded.";
				throw new ArgumentException (msg, "reason");
				}

			if (bytes.Length > 123)
				{
				var msg = "Its size is greater than 123 bytes.";
				throw new ArgumentOutOfRangeException ("reason", msg);
				}

			closeAsync ((ushort)code, reason);
			}

		/// <summary>
		/// Establishes a connection.
		/// </summary>
		/// <remarks>
		/// This method does nothing if the connection has already been established.
		/// </remarks>
		/// <exception cref="InvalidOperationException">
		///   <para>
		///   This instance is not a client.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The close process is in progress.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   A series of reconnecting has failed.
		///   </para>
		/// </exception>
		public void Connect ()
			{
			if (!_client)
				{
				var msg = "This instance is not a client.";
				throw new InvalidOperationException (msg);
				}

			if (_readyState == WebSocketState.Closing)
				{
				var msg = "The close process is in progress.";
				throw new InvalidOperationException (msg);
				}

			if (_retryCountForConnect > _maxRetryCountForConnect)
				{
				var msg = "A series of reconnecting has failed.";
				throw new InvalidOperationException (msg);
				}

			if (connect ())
				open ();
			}

		/// <summary>
		/// Establishes a connection asynchronously.
		/// </summary>
		/// <remarks>
		///   <para>
		///   This method does not wait for the connect process to be complete.
		///   </para>
		///   <para>
		///   This method does nothing if the connection has already been
		///   established.
		///   </para>
		/// </remarks>
		/// <exception cref="InvalidOperationException">
		///   <para>
		///   This instance is not a client.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The close process is in progress.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   A series of reconnecting has failed.
		///   </para>
		/// </exception>
		public void ConnectAsync ()
			{
			if (!_client)
				{
				var msg = "This instance is not a client.";
				throw new InvalidOperationException (msg);
				}

			if (_readyState == WebSocketState.Closing)
				{
				var msg = "The close process is in progress.";
				throw new InvalidOperationException (msg);
				}

			if (_retryCountForConnect > _maxRetryCountForConnect)
				{
				var msg = "A series of reconnecting has failed.";
				throw new InvalidOperationException (msg);
				}

#if SSHARP
			Func<bool> connector = connect;
			connector.BeginInvokeEx (
				ar =>
					{
					if (connector.EndInvokeEx<bool> (ar))
						open ();
					},
				null);
#elif NETCF
			ThreadPool.QueueUserWorkItem (o =>
				{
					if (connect ())
						open ();
				});
#else
			Func<bool> connector = connect;
			connector.BeginInvoke (
			  ar =>
				  {
				  if (connector.EndInvoke (ar))
					  open ();
				  },
			  null);
#endif
			}

		/// <summary>
		/// Sends a ping using the WebSocket connection.
		/// </summary>
		/// <returns>
		/// <c>true</c> if the send has done with no error and a pong has been
		/// received within a time; otherwise, <c>false</c>.
		/// </returns>
		public bool Ping ()
			{
			return ping (EmptyBytes);
			}

		/// <summary>
		/// Sends a ping with <paramref name="message"/> using the WebSocket
		/// connection.
		/// </summary>
		/// <returns>
		/// <c>true</c> if the send has done with no error and a pong has been
		/// received within a time; otherwise, <c>false</c>.
		/// </returns>
		/// <param name="message">
		///   <para>
		///   A <see cref="string"/> that represents the message to send.
		///   </para>
		///   <para>
		///   The size must be 125 bytes or less in UTF-8.
		///   </para>
		/// </param>
		/// <exception cref="ArgumentException">
		/// <paramref name="message"/> could not be UTF-8-encoded.
		/// </exception>
		/// <exception cref="ArgumentOutOfRangeException">
		/// The size of <paramref name="message"/> is greater than 125 bytes.
		/// </exception>
		public bool Ping (string message)
			{
			if (message.IsNullOrEmpty ())
				return ping (EmptyBytes);

			byte[] bytes;
			if (!message.TryGetUTF8EncodedBytes (out bytes))
				{
				var msg = "It could not be UTF-8-encoded.";
				throw new ArgumentException (msg, "message");
				}

			if (bytes.Length > 125)
				{
				var msg = "Its size is greater than 125 bytes.";
				throw new ArgumentOutOfRangeException ("message", msg);
				}

			return ping (bytes);
			}

		/// <summary>
		/// Sends the specified data using the WebSocket connection.
		/// </summary>
		/// <param name="data">
		/// An array of <see cref="byte"/> that represents the binary data to send.
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="data"/> is <see langword="null"/>.
		/// </exception>
		public void Send (byte[] data)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (data == null)
				throw new ArgumentNullException ("data");

			send (Opcode.Binary, new MemoryStream (data));
			}

		/// <summary>
		/// Sends the specified file using the WebSocket connection.
		/// </summary>
		/// <param name="fileInfo">
		///   <para>
		///   A <see cref="FileInfo"/> that specifies the file to send.
		///   </para>
		///   <para>
		///   The file is sent as the binary data.
		///   </para>
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="fileInfo"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   The file does not exist.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The file could not be opened.
		///   </para>
		/// </exception>
		public void Send (FileInfo fileInfo)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (fileInfo == null)
				throw new ArgumentNullException ("fileInfo");

			if (!fileInfo.Exists)
				{
				var msg = "The file does not exist.";
				throw new ArgumentException (msg, "fileInfo");
				}

			FileStream stream;
			if (!fileInfo.TryOpenRead (out stream))
				{
				var msg = "The file could not be opened.";
				throw new ArgumentException (msg, "fileInfo");
				}

			send (Opcode.Binary, stream);
			}

#if SSHARP
		/// <summary>
		/// Sends the specified file using the WebSocket connection.
		/// </summary>
		/// <param name="fileInfo">
		///   <para>
		///   A <see cref="SSMono.IO.FileInfo"/> that specifies the file to send.
		///   </para>
		///   <para>
		///   The file is sent as the binary data.
		///   </para>
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="fileInfo"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   The file does not exist.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The file could not be opened.
		///   </para>
		/// </exception>
		public void Send (SSMono.IO.FileInfo fileInfo)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (fileInfo == null)
				throw new ArgumentNullException ("fileInfo");

			if (!fileInfo.Exists)
				{
				var msg = "The file does not exist.";
				throw new ArgumentException (msg, "fileInfo");
				}

			FileStream stream;
			if (!fileInfo.TryOpenRead (out stream))
				{
				var msg = "The file could not be opened.";
				throw new ArgumentException (msg, "fileInfo");
				}

			send (Opcode.Binary, stream);
			}
#endif

		/// <summary>
		/// Sends the specified data using the WebSocket connection.
		/// </summary>
		/// <param name="data">
		/// A <see cref="string"/> that represents the text data to send.
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="data"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		/// <paramref name="data"/> could not be UTF-8-encoded.
		/// </exception>
		public void Send (string data)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (data == null)
				throw new ArgumentNullException ("data");

			byte[] bytes;
			if (!data.TryGetUTF8EncodedBytes (out bytes))
				{
				var msg = "It could not be UTF-8-encoded.";
				throw new ArgumentException (msg, "data");
				}

			send (Opcode.Text, new MemoryStream (bytes));
			}

		/// <summary>
		/// Sends the data from the specified stream using the WebSocket connection.
		/// </summary>
		/// <param name="stream">
		///   <para>
		///   A <see cref="Stream"/> instance from which to read the data to send.
		///   </para>
		///   <para>
		///   The data is sent as the binary data.
		///   </para>
		/// </param>
		/// <param name="length">
		/// An <see cref="int"/> that specifies the number of bytes to send.
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="stream"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="stream"/> cannot be read.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="length"/> is less than 1.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   No data could be read from <paramref name="stream"/>.
		///   </para>
		/// </exception>
		public void Send (Stream stream, int length)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (stream == null)
				throw new ArgumentNullException ("stream");

			if (!stream.CanRead)
				{
				var msg = "It cannot be read.";
				throw new ArgumentException (msg, "stream");
				}


			if (length < 1)
				{
				var msg = "Less than 1.";
				throw new ArgumentException (msg, "length");
				}

			var bytes = stream.ReadBytes (length);

			var len = bytes.Length;
			if (len == 0)
				{
				var msg = "No data could be read from it.";
				throw new ArgumentException (msg, "stream");
				}

			if (len < length)
				{
				_logger.Warn (
					String.Format (
						"Only {0} byte(s) of data could be read from the stream.",
						len
						)
					);
				}

			send (Opcode.Binary, new MemoryStream (bytes));
			}

		/// <summary>
		/// Sends the specified data asynchronously using the WebSocket connection.
		/// </summary>
		/// <remarks>
		/// This method does not wait for the send to be complete.
		/// </remarks>
		/// <param name="data">
		/// An array of <see cref="byte"/> that represents the binary data to send.
		/// </param>
		/// <param name="completed">
		///   <para>
		///   An <c>Action&lt;bool&gt;</c> delegate or <see langword="null"/>
		///   if not needed.
		///   </para>
		///   <para>
		///   The delegate invokes the method called when the send is complete.
		///   </para>
		///   <para>
		///   <c>true</c> is passed to the method if the send has done with
		///   no error; otherwise, <c>false</c>.
		///   </para>
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="data"/> is <see langword="null"/>.
		/// </exception>
		public void SendAsync (byte[] data, Action<bool> completed)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (data == null)
				throw new ArgumentNullException ("data");

			sendAsync (Opcode.Binary, new MemoryStream (data), completed);
			}

		/// <summary>
		/// Sends the specified file asynchronously using the WebSocket connection.
		/// </summary>
		/// <remarks>
		/// This method does not wait for the send to be complete.
		/// </remarks>
		/// <param name="fileInfo">
		///   <para>
		///   A <see cref="FileInfo"/> that specifies the file to send.
		///   </para>
		///   <para>
		///   The file is sent as the binary data.
		///   </para>
		/// </param>
		/// <param name="completed">
		///   <para>
		///   An <c>Action&lt;bool&gt;</c> delegate or <see langword="null"/>
		///   if not needed.
		///   </para>
		///   <para>
		///   The delegate invokes the method called when the send is complete.
		///   </para>
		///   <para>
		///   <c>true</c> is passed to the method if the send has done with
		///   no error; otherwise, <c>false</c>.
		///   </para>
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="fileInfo"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   The file does not exist.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The file could not be opened.
		///   </para>
		/// </exception>
		public void SendAsync (FileInfo fileInfo, Action<bool> completed)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (fileInfo == null)
				throw new ArgumentNullException ("fileInfo");

			if (!fileInfo.Exists)
				{
				var msg = "The file does not exist.";
				throw new ArgumentException (msg, "fileInfo");
				}

			FileStream stream;
			if (!fileInfo.TryOpenRead (out stream))
				{
				var msg = "The file could not be opened.";
				throw new ArgumentException (msg, "fileInfo");
				}

			sendAsync (Opcode.Binary, stream, completed);
			}

#if SSHARP
		/// <summary>
		/// Sends the specified file asynchronously using the WebSocket connection.
		/// </summary>
		/// <remarks>
		/// This method does not wait for the send to be complete.
		/// </remarks>
		/// <param name="fileInfo">
		///   <para>
		///   A <see cref="SSMono.IO.FileInfo"/> that specifies the file to send.
		///   </para>
		///   <para>
		///   The file is sent as the binary data.
		///   </para>
		/// </param>
		/// <param name="completed">
		///   <para>
		///   An <c>Action&lt;bool&gt;</c> delegate or <see langword="null"/>
		///   if not needed.
		///   </para>
		///   <para>
		///   The delegate invokes the method called when the send is complete.
		///   </para>
		///   <para>
		///   <c>true</c> is passed to the method if the send has done with
		///   no error; otherwise, <c>false</c>.
		///   </para>
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="fileInfo"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   The file does not exist.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The file could not be opened.
		///   </para>
		/// </exception>
		public void SendAsync (SSMono.IO.FileInfo fileInfo, Action<bool> completed)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (fileInfo == null)
				throw new ArgumentNullException ("fileInfo");

			if (!fileInfo.Exists)
				{
				var msg = "The file does not exist.";
				throw new ArgumentException (msg, "fileInfo");
				}

			FileStream stream;
			if (!fileInfo.TryOpenRead (out stream))
				{
				var msg = "The file could not be opened.";
				throw new ArgumentException (msg, "fileInfo");
				}

			sendAsync (Opcode.Binary, stream, completed);
			}
#endif

		/// <summary>
		/// Sends the specified data asynchronously using the WebSocket connection.
		/// </summary>
		/// <remarks>
		/// This method does not wait for the send to be complete.
		/// </remarks>
		/// <param name="data">
		/// A <see cref="string"/> that represents the text data to send.
		/// </param>
		/// <param name="completed">
		///   <para>
		///   An <c>Action&lt;bool&gt;</c> delegate or <see langword="null"/>
		///   if not needed.
		///   </para>
		///   <para>
		///   The delegate invokes the method called when the send is complete.
		///   </para>
		///   <para>
		///   <c>true</c> is passed to the method if the send has done with
		///   no error; otherwise, <c>false</c>.
		///   </para>
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="data"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		/// <paramref name="data"/> could not be UTF-8-encoded.
		/// </exception>
		public void SendAsync (string data, Action<bool> completed)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (data == null)
				throw new ArgumentNullException ("data");

			byte[] bytes;
			if (!data.TryGetUTF8EncodedBytes (out bytes))
				{
				var msg = "It could not be UTF-8-encoded.";
				throw new ArgumentException (msg, "data");
				}

			sendAsync (Opcode.Text, new MemoryStream (bytes), completed);
			}

		/// <summary>
		/// Sends the data from the specified stream asynchronously using
		/// </summary>
		/// <remarks>
		/// This method does not wait for the send to be complete.
		/// </remarks>
		/// <param name="stream">
		///   <para>
		///   A <see cref="Stream"/> instance from which to read the data to send.
		///   </para>
		///   <para>
		///   The data is sent as the binary data.
		///   </para>
		/// </param>
		/// <param name="length">
		/// An <see cref="int"/> that specifies the number of bytes to send.
		/// </param>
		/// <param name="completed">
		///   <para>
		///   An <c>Action&lt;bool&gt;</c> delegate or <see langword="null"/>
		///   if not needed.
		///   </para>
		///   <para>
		///   The delegate invokes the method called when the send is complete.
		///   </para>
		///   <para>
		///   <c>true</c> is passed to the method if the send has done with
		///   no error; otherwise, <c>false</c>.
		///   </para>
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// The current state of the connection is not Open.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="stream"/> is <see langword="null"/>.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="stream"/> cannot be read.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="length"/> is less than 1.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   No data could be read from <paramref name="stream"/>.
		///   </para>
		/// </exception>
		public void SendAsync (Stream stream, int length, Action<bool> completed)
			{
			if (_readyState != WebSocketState.Open)
				{
				var msg = "The current state of the connection is not Open.";
				throw new InvalidOperationException (msg);
				}

			if (stream == null)
				throw new ArgumentNullException ("stream");

			if (!stream.CanRead)
				{
				var msg = "It cannot be read.";
				throw new ArgumentException (msg, "stream");
				}

			if (length < 1)
				{
				var msg = "Less than 1.";
				throw new ArgumentException (msg, "length");
				}

			var bytes = stream.ReadBytes (length);

			var len = bytes.Length;
			if (len == 0)
				{
				var msg = "No data could be read from it.";
				throw new ArgumentException (msg, "stream");
				}

			if (len < length)
				{
				_logger.Warn (String.Format ("Only {0} byte(s) of data could be read from the stream.", len));
				}

			sendAsync (Opcode.Binary, new MemoryStream (bytes), completed);
			}

		/// <summary>
		/// Sets an HTTP cookie to send with the handshake request.
		/// </summary>
		/// <remarks>
		/// This method does nothing if the connection has already been
		/// established or it is closing.
		/// </remarks>
		/// <param name="cookie">
		/// A <see cref="Cookie"/> that represents the cookie to send.
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// This instance is not a client.
		/// </exception>
		/// <exception cref="ArgumentNullException">
		/// <paramref name="cookie"/> is <see langword="null"/>.
		/// </exception>
		public void SetCookie (Cookie cookie)
			{
			string msg = null;
			if (!_client)
				{
				msg = "This instance is not a client.";
				throw new InvalidOperationException (msg);
				}

			if (cookie == null)
				throw new ArgumentNullException ("cookie");

			if (!canSet (out msg))
				{
				_logger.Warn (msg);

				return;
				}

			lock (_forState)
				{
				if (!canSet (out msg))
					{
					_logger.Warn (msg);

					return;
					}

				lock (_cookies.SyncRoot)
					_cookies.SetOrRemove (cookie);
				}
			}

		/// <summary>
		/// Sets the credentials for the HTTP authentication (Basic/Digest).
		/// </summary>
		/// <remarks>
		/// This method does nothing if the connection has already been
		/// established or it is closing.
		/// </remarks>
		/// <param name="username">
		///   <para>
		///   A <see cref="string"/> that represents the username associated with
		///   the credentials.
		///   </para>
		///   <para>
		///   <see langword="null"/> or an empty string if initializes
		///   the credentials.
		///   </para>
		/// </param>
		/// <param name="password">
		///   <para>
		///   A <see cref="string"/> that represents the password for the username
		///   associated with the credentials.
		///   </para>
		///   <para>
		///   <see langword="null"/> or an empty string if not necessary.
		///   </para>
		/// </param>
		/// <param name="preAuth">
		/// <c>true</c> if sends the credentials for the Basic authentication in
		/// advance with the first handshake request; otherwise, <c>false</c>.
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// This instance is not a client.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="username"/> contains an invalid character.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="password"/> contains an invalid character.
		///   </para>
		/// </exception>
		public void SetCredentials (string username, string password, bool preAuth)
			{
			string msg = null;

			if (!_client)
				{
				msg = "This instance is not a client.";
				throw new InvalidOperationException (msg);
				}

			if (!username.IsNullOrEmpty ())
				{
				if (username.Contains (':') || !username.IsText ())
					{
					msg = "It contains an invalid character.";
					throw new ArgumentException (msg, "username");
					}
				}

			if (!password.IsNullOrEmpty ())
				{
				if (!password.IsText ())
					{
					msg = "It contains an invalid character.";
					throw new ArgumentException (msg, "password");
					}
				}

			if (!canSet (out msg))
				{
				_logger.Warn (msg);
				return;
				}

			lock (_forState)
				{
				if (!canSet (out msg))
					{
					_logger.Warn (msg);

					return;
					}

				if (username.IsNullOrEmpty ())
					{
					_credentials = null;
					_preAuth = false;

					return;
					}

				_credentials = new NetworkCredential (username, password, _uri.PathAndQuery);
				_preAuth = preAuth;
				}
			}

		/// <summary>
		/// Sets the URL of the HTTP proxy server through which to connect and
		/// the credentials for the HTTP proxy authentication (Basic/Digest).
		/// </summary>
		/// <remarks>
		/// This method does nothing if the connection has already been
		/// established or it is closing.
		/// </remarks>
		/// <param name="url">
		///   <para>
		///   A <see cref="string"/> that represents the URL of the proxy server
		///   through which to connect.
		///   </para>
		///   <para>
		///   The syntax is http://&lt;host&gt;[:&lt;port&gt;].
		///   </para>
		///   <para>
		///   <see langword="null"/> or an empty string if initializes the URL and
		///   the credentials.
		///   </para>
		/// </param>
		/// <param name="username">
		///   <para>
		///   A <see cref="string"/> that represents the username associated with
		///   the credentials.
		///   </para>
		///   <para>
		///   <see langword="null"/> or an empty string if the credentials are not
		///   necessary.
		///   </para>
		/// </param>
		/// <param name="password">
		///   <para>
		///   A <see cref="string"/> that represents the password for the username
		///   associated with the credentials.
		///   </para>
		///   <para>
		///   <see langword="null"/> or an empty string if not necessary.
		///   </para>
		/// </param>
		/// <exception cref="InvalidOperationException">
		/// This instance is not a client.
		/// </exception>
		/// <exception cref="ArgumentException">
		///   <para>
		///   <paramref name="url"/> is not an absolute URI string.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   The scheme of <paramref name="url"/> is not http.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="url"/> includes the path segments.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="username"/> contains an invalid character.
		///   </para>
		///   <para>
		///   -or-
		///   </para>
		///   <para>
		///   <paramref name="password"/> contains an invalid character.
		///   </para>
		/// </exception>
		public void SetProxy (string url, string username, string password)
			{
			string msg = null;

			if (!_client)
				{
				msg = "This instance is not a client.";
				throw new InvalidOperationException (msg);
				}

			Uri uri = null;

			if (!url.IsNullOrEmpty ())
				{
				if (!Uri.TryCreate (url, UriKind.Absolute, out uri))
					{
					msg = "Not an absolute URI string.";
					throw new ArgumentException (msg, "url");
					}

				if (uri.Scheme != "http")
					{
					msg = "The scheme part is not http.";
					throw new ArgumentException (msg, "url");
					}

				if (uri.Segments.Length > 1)
					{
					msg = "It includes the path segments.";
					throw new ArgumentException (msg, "url");
					}
				}

			if (!username.IsNullOrEmpty ())
				{
				if (username.Contains (':') || !username.IsText ())
					{
					msg = "It contains an invalid character.";
					throw new ArgumentException (msg, "username");
					}
				}

			if (!password.IsNullOrEmpty ())
				{
				if (!password.IsText ())
					{
					msg = "It contains an invalid character.";
					throw new ArgumentException (msg, "password");
					}
				}

			if (!canSet (out msg))
				{
				_logger.Warn (msg);
				return;
				}

			lock (_forState)
				{
				if (!canSet (out msg))
					{
					_logger.Warn (msg);
					return;
					}

				if (url.IsNullOrEmpty ())
					{
					_proxyUri = null;
					_proxyCredentials = null;

					return;
					}

				_proxyUri = uri;
				_proxyCredentials = !username.IsNullOrEmpty ()
					? new NetworkCredential (
						username,
						password,
						String.Format (
							"{0}:{1}", _uri.DnsSafeHost, _uri.Port
							)
						)
					: null;
				}
			}

		#endregion

		#region Explicit Interface Implementations

		/// <summary>
		/// Closes the connection and releases all associated resources.
		/// </summary>
		/// <remarks>
		///	<para>
		///	This method closes the connection with status code 1001 (going away).
		///	</para>
		///	<para>
		///   And this method does nothing if the current state of the connection is
		///   Closing or Closed.
		///	</para>
		/// </remarks>
		void IDisposable.Dispose ()
			{
			close (1001, String.Empty);
			}

		#endregion
		}
	}