private void ProcessSocketError(SocketError socketError)
{
var webSocketErrorArgs = new WebSocketErrorEventArgs();
if (socketError == SocketError.HostDown)
{
webSocketErrorArgs.ErrorType = WebSocketExceptionType.HOST_DOWN;
}
else if (socketError == SocketError.HostNotFound)
{
webSocketErrorArgs.ErrorType = WebSocketExceptionType.UNKNOWN_HOST;
}
else if (socketError == SocketError.HostUnreachable)
{
webSocketErrorArgs.ErrorType = WebSocketExceptionType.HOST_NOT_REACHABLE;
}
else
{
webSocketErrorArgs.ErrorType = WebSocketExceptionType.UNABLE_TO_CONNECT;
}
string message = "Error connecting to host: " + _uri.Host;
OnError(webSocketErrorArgs);
_status = WebSocketStatus.CLOSED;
}
////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// send close frame and go to closing state
/// </summary>
/// <param name="code">Code.</param>
public void Close(WebSocketStatus code = WebSocketStatus.NormalClosure)
{
if (Connection != State.Open)
{
Util.Warn("[ws:{0}] Attempting to close a socket that is not open", ID);
return;
}
Detail("[ws:{0}] Sending close frame", ID);
// create close payload
var text = Encoding.UTF8.GetBytes(WebSocketUtils.CodeToString(code));
var num = BitConverter.GetBytes(Endian.HostToNetwork((ushort)code));
var data = new byte[2 + text.Length];
Array.Copy(num, 0, data, 0, 2);
Array.Copy(text, 0, data, 2, text.Length);
// close
Connection = State.Closing;
mCloseStarted = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
SendAsync(data, WebSocketOpCode.Close);
}
private void OnError(WebSocketErrorEventArgs eventArgs)
{
_status = WebSocketStatus.CLOSED;
foreach (var listener in _listeners)
{
listener.ProcessOnError(eventArgs);
}
}
private void HandshakeCompleted()
{
Debug.WriteLine("HandShake Completed");
foreach (var listener in _listeners)
{
listener.ProcessOnOpen();
}
_status = WebSocketStatus.OPEN;
//now start receiving data as a background thread
_webSocketPacketReader = new WebSocketPacketReader(_socket);
_isRunning = true;
_backgroundReceiver.RunWorkerAsync();
}
private void CheckReconnect()
{
if (mReliabilityOptions != null)
{
if (mReliabilityOptions.IsAutoReconnect)
{
if (mLog.IsDebugEnabled)
{
mLog.Debug(WebSocketMessage.CHECKING_RECONNECT);
}
mStatus = WebSocketStatus.RECONNECTING;
mReconnect = new Thread(new ThreadStart(Reconnet));
mReconnect.Start();
}
}
}
/// <summary>
/// The functions will connect the client to the specified websocket server.
/// </summary>
/// <param name="uri">The string represention of the uri of the web server to connect to.</param>
public void Connect(string uri)
{
if (_status != WebSocketStatus.CLOSED)
{
return;
}
try
{
_status = WebSocketStatus.CONNECTING;
_uri = new Uri(uri);
var webSocketHandshake = new WebSocketHandshake(_uri, SubProtocol.ToString(), WebSocketConstants.WS_VERSION_DEFAULT);
if (_socket != null && _socket.Connected)
{
_socket.Close();
}
var scheme = _uri.Scheme;
var port = _uri.Port;
var host = _uri.Host;
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_socket.NoDelay = true;
var hostEntry = new DnsEndPoint(host, port);
// Create a SocketAsyncEventArgs object to be used in the connection request
var socketEventArg = new SocketAsyncEventArgs();
socketEventArg.RemoteEndPoint = hostEntry;
socketEventArg.Completed += (sender, args) =>
{
if (args.SocketError == SocketError.Success)
{
webSocketHandshake.PerformHandShakeWithServer(_socket, HandshakeCompleted, HandshakeFailed);
}
else
{
ProcessSocketError(args.SocketError);
}
};
_socket.ConnectAsync(socketEventArg);
}
catch (Exception ex)
{
var webSocketErrorArgs = new WebSocketErrorEventArgs {
ErrorType = WebSocketExceptionType.UNABLE_TO_CONNECT, Message = ex.Message
};
OnError(webSocketErrorArgs);
}
}
public static string CodeToString(WebSocketStatus code)
{
switch (code)
{
case WebSocketStatus.NormalClosure: return("Closing connection");
case WebSocketStatus.GoingAway: return("Going away");
case WebSocketStatus.ProtocolError: return("No extended protocol negotiated");
case WebSocketStatus.PolicyViolation: return("Policy violation");
case WebSocketStatus.PayloadTooLarge: return("Max payload size exceeded");
case WebSocketStatus.InternalError: return("Fatal error");
}
return("Unknown Error");
}
private void StopIt()
{
mIsRunning = false;
mStatus = WebSocketStatus.CLOSED;
mCLose = WebSocketCloseReason.CLIENT;
try
{
mNetStream.Close();
mHeaders.GetRequestFields.Clear();
mHeaders.GetResponseFields.Clear();
}
catch (IOException lIOEx)
{
if (mLog.IsErrorEnabled)
{
mLog.Error(lIOEx.Message);
}
OnError(new WebSocketError(lIOEx.Message));
throw new WebSocketException(lIOEx.Message);
}
}
private void Receiver()
{
Thread.CurrentThread.Name = WebSocketMessage.WEBSOCKETBASECLIENT
+ WebSocketMessage.SEPARATOR + Thread.GetDomainID();
mIsRunning = true;
Ping();
ProcessHybi();
mStatus = WebSocketStatus.CLOSING;
try
{
mNetStream.Close();
if (mSocket.Connected)
{
mSocket.Close();
}
}
catch (IOException lIOEx)
{
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.ERROR_WHILE_CLOSING_SOCKET);
}
OnError(new WebSocketError(WebSocketMessage.ERROR_WHILE_CLOSING_SOCKET));
throw new WebSocketException(WebSocketMessage.ERROR_WHILE_CLOSING_SOCKET
+ WebSocketMessage.SEPARATOR + lIOEx.Message);
}
mStatus = WebSocketStatus.CLOSED;
OnCloseConnection(mCLose);
if (!mCLose.Equals(WebSocketCloseReason.CLIENT))
{
mHeaders.GetRequestFields.Clear();
mHeaders.GetResponseFields.Clear();
CheckReconnect();
}
}
private void HandshakeCompleted()
{
Debug.WriteLine("HandShake Completed");
foreach (var listener in _listeners)
{
listener.ProcessOnOpen();
}
_status = WebSocketStatus.OPEN;
//now start receiving data as a background thread
_webSocketPacketReader = new WebSocketPacketReader(_socket);
_isRunning = true;
_backgroundReceiver.RunWorkerAsync();
}
public static bool isClosed(WebSocketStatus aStatus)
{
return(aStatus.Equals(WebSocketStatus.CLOSED));
}
public void Open(string aURI, string aSubProtocol, int aTimeout, int aVersion)
{
try
{
if (mLog.IsDebugEnabled)
{
mLog.Debug(WebSocketMessage.ESTABLiSHING_CONNECTION + WebSocketMessage.SEPARATOR
+ WebSocketMessage.URL + aURI + WebSocketMessage.SEPARATOR + WebSocketMessage.SUBPROTOCOL
+ aSubProtocol + WebSocketMessage.SEPARATOR + WebSocketMessage.TIMEOUT
+ aTimeout + WebSocketMessage.SEPARATOR + WebSocketMessage.VERSION + aVersion);
}
mStatus = WebSocketStatus.OPENING;
mVersion = aVersion;
mURI = new Uri(aURI);
WebSocketHandshake lHandshake = new WebSocketHandshake(mURI, aSubProtocol, mVersion, mCookieManage);
if (mSocket != null && mSocket.Connected)
{
mSocket.Close();
}
CreateSocket();
byte[] sendBuffer = lHandshake.GenerateC2SRequest();
mNetStream.Write(sendBuffer, 0, sendBuffer.Length);
mNetStream.Flush();
mStatus = WebSocketStatus.CONNECTING;
mHeaders.ReadRequestFromBuffer(sendBuffer);
if (mLog.IsDebugEnabled)
{
mLog.Debug(WebSocketMessage.SENDING_HANDSHAKE + mHeaders.ToStringRequest());
}
WebSocketTimeout.CallWithTimeout(mHeaders.ReadResponseFromStream, aTimeout, mNetStream);
mCookieManage.AddCookies(mHeaders.GetCookies, mURI);
if (mLog.IsDebugEnabled)
{
mLog.Debug(WebSocketMessage.RECEIVING_HANDSHAKE + mHeaders.ToStringResponse());
}
lHandshake.VerifyS2CResponse(mHeaders);
string lProtocol = GetResponseHeaderField(WebSocketConstants.SEC_WEBSOCKET_PROTOCOL);
if (lProtocol != null)
{
mNegotiatedSubProtocol = new WebSocketSubProtocol(lProtocol, mEncoding);
}
else
{
mNegotiatedSubProtocol = new WebSocketSubProtocol(WebSocketConstants.WS_SUBPROT_DEFAULT,
WebSocketConstants.WS_ENCODING_DEFAULT);
}
Thread lReciver = new Thread(new ThreadStart(Receiver));
lReciver.Start();
if (mLog.IsInfoEnabled)
{
mLog.Info(WebSocketMessage.CONNECTION_HAS_BEEN_ESTABLISHED);
}
mStatus = WebSocketStatus.OPENED;
mIsRunning = true;
OnOpenConnection(mHeaders);
}
catch (TimeoutException lTe)
{
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.EXCEEDED_FOR_CONNECTION + WebSocketMessage.SEPARATOR
+ WebSocketMessage.DETAILS + lTe.Message);
}
mCLose = WebSocketCloseReason.TIMEOUT;
OnCloseConnection(mCLose);
OnError(new WebSocketError(WebSocketMessage.TIMEOUT + WebSocketMessage.EXCEEDED_FOR_CONNECTION, mCLose));
CheckReconnect();
}
catch (Exception lEx)
{
if (mLog.IsErrorEnabled)
{
mLog.Error(WebSocketMessage.NOT_ESTABLISH_CONNECTION + WebSocketMessage.SEPARATOR
+ WebSocketMessage.DETAILS + lEx.Message);
}
mCLose = WebSocketCloseReason.BROKEN;
OnCloseConnection(mCLose);
OnError(new WebSocketError(WebSocketMessage.NOT_ESTABLISH_CONNECTION, mCLose));
CheckReconnect();
}
}
public static bool isWritable(WebSocketStatus aStatus)
{
return(aStatus.Equals(WebSocketStatus.OPENED));
}
public static bool isConnected(WebSocketStatus aStatus)
{
return(aStatus.Equals(WebSocketStatus.OPENED));
}
public static bool isWritable(WebSocketStatus aStatus)
{
return (aStatus.Equals(WebSocketStatus.OPEN));
}
/// <inheritdoc />
public async void SetStatus(WebSocketStatus status)
{
await WaitTask.ConfigureAwait(false);
WebSocket.SetStatus(status);
}
private void StopIt()
{
mIsRunning = false;
mStatus = WebSocketStatus.CLOSED;
mCLose = WebSocketCloseReason.CLIENT;
try
{
mNetStream.Close();
mHeaders.GetRequestFields.Clear();
mHeaders.GetResponseFields.Clear();
}
catch (IOException lIOEx)
{
if (mLog.IsErrorEnabled)
mLog.Error(lIOEx.Message);
OnError(new WebSocketError(lIOEx.Message));
throw new WebSocketException(lIOEx.Message);
}
}
private void Receiver()
{
Thread.CurrentThread.Name = WebSocketMessage.WEBSOCKETBASECLIENT
+ WebSocketMessage.SEPARATOR + Thread.GetDomainID();
mIsRunning = true;
Ping();
ProcessHybi();
mStatus = WebSocketStatus.CLOSING;
try
{
mNetStream.Close();
if (mSocket.Connected)
mSocket.Close();
}
catch (IOException lIOEx)
{
if (mLog.IsErrorEnabled)
mLog.Error(WebSocketMessage.ERROR_WHILE_CLOSING_SOCKET);
OnError(new WebSocketError(WebSocketMessage.ERROR_WHILE_CLOSING_SOCKET));
throw new WebSocketException(WebSocketMessage.ERROR_WHILE_CLOSING_SOCKET
+ WebSocketMessage.SEPARATOR + lIOEx.Message);
}
mStatus = WebSocketStatus.CLOSED;
OnCloseConnection(mCLose);
if (!mCLose.Equals(WebSocketCloseReason.CLIENT))
{
mHeaders.GetRequestFields.Clear();
mHeaders.GetResponseFields.Clear();
CheckReconnect();
}
}
public WebSocketException(WebSocketStatus code)
{
Code = code;
}
private void OnError(WebSocketErrorEventArgs eventArgs)
{
_status = WebSocketStatus.CLOSED;
foreach (var listener in _listeners)
{
listener.ProcessOnError(eventArgs);
}
}
private void ProcessSocketError(SocketError socketError)
{
var webSocketErrorArgs = new WebSocketErrorEventArgs();
if (socketError == SocketError.HostDown)
{
webSocketErrorArgs.ErrorType = WebSocketExceptionType.HOST_DOWN;
}
else if (socketError == SocketError.HostNotFound)
{
webSocketErrorArgs.ErrorType = WebSocketExceptionType.UNKNOWN_HOST;
}
else if (socketError == SocketError.HostUnreachable)
{
webSocketErrorArgs.ErrorType = WebSocketExceptionType.HOST_NOT_REACHABLE;
}
else
{
webSocketErrorArgs.ErrorType = WebSocketExceptionType.UNABLE_TO_CONNECT;
}
string message = "Error connecting to host: " + _uri.Host;
OnError(webSocketErrorArgs);
_status = WebSocketStatus.CLOSED;
}
/// <summary>
/// The functions will connect the client to the specified websocket server.
/// </summary>
/// <param name="uri">The string represention of the uri of the web server to connect to.</param>
public void Connect(string uri)
{
if (_status != WebSocketStatus.CLOSED)
{
return;
}
try
{
_status = WebSocketStatus.CONNECTING;
_uri = new Uri(uri);
var webSocketHandshake = new WebSocketHandshake(_uri, SubProtocol.ToString(), WebSocketConstants.WS_VERSION_DEFAULT);
if (_socket != null && _socket.Connected)
_socket.Close();
var scheme = _uri.Scheme;
var port = _uri.Port;
var host = _uri.Host;
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_socket.NoDelay = true;
var hostEntry = new DnsEndPoint(host, port);
// Create a SocketAsyncEventArgs object to be used in the connection request
var socketEventArg = new SocketAsyncEventArgs();
socketEventArg.RemoteEndPoint = hostEntry;
socketEventArg.Completed += (sender, args) =>
{
if (args.SocketError == SocketError.Success)
{
webSocketHandshake.PerformHandShakeWithServer(_socket, HandshakeCompleted, HandshakeFailed);
}
else
{
ProcessSocketError(args.SocketError);
}
};
_socket.ConnectAsync(socketEventArg);
}
catch (Exception ex)
{
var webSocketErrorArgs = new WebSocketErrorEventArgs { ErrorType = WebSocketExceptionType.UNABLE_TO_CONNECT, Message = ex.Message };
OnError(webSocketErrorArgs);
}
}
public void Open(string aURI, string aSubProtocol, int aTimeout, int aVersion)
{
try
{
if (mLog.IsDebugEnabled)
mLog.Debug(WebSocketMessage.ESTABLiSHING_CONNECTION + WebSocketMessage.SEPARATOR
+ WebSocketMessage.URL + aURI + WebSocketMessage.SEPARATOR + WebSocketMessage.SUBPROTOCOL
+ aSubProtocol + WebSocketMessage.SEPARATOR + WebSocketMessage.TIMEOUT
+ aTimeout + WebSocketMessage.SEPARATOR + WebSocketMessage.VERSION + aVersion);
mStatus = WebSocketStatus.OPENING;
mVersion = aVersion;
mURI = new Uri(aURI);
WebSocketHandshake lHandshake = new WebSocketHandshake(mURI, aSubProtocol, mVersion,mCookieManage);
if (mSocket != null && mSocket.Connected)
mSocket.Close();
CreateSocket();
byte[] sendBuffer = lHandshake.GenerateC2SRequest();
mNetStream.Write(sendBuffer, 0, sendBuffer.Length);
mNetStream.Flush();
mStatus = WebSocketStatus.CONNECTING;
mHeaders.ReadRequestFromBuffer(sendBuffer);
if (mLog.IsDebugEnabled)
mLog.Debug(WebSocketMessage.SENDING_HANDSHAKE + mHeaders.ToStringRequest());
WebSocketTimeout.CallWithTimeout(mHeaders.ReadResponseFromStream, aTimeout, mNetStream);
mCookieManage.AddCookies(mHeaders.GetCookies, mURI);
if (mLog.IsDebugEnabled)
mLog.Debug(WebSocketMessage.RECEIVING_HANDSHAKE + mHeaders.ToStringResponse());
lHandshake.VerifyS2CResponse(mHeaders);
string lProtocol = GetResponseHeaderField(WebSocketConstants.SEC_WEBSOCKET_PROTOCOL);
if (lProtocol != null)
mNegotiatedSubProtocol = new WebSocketSubProtocol(lProtocol, mEncoding);
else
mNegotiatedSubProtocol = new WebSocketSubProtocol(WebSocketConstants.WS_SUBPROT_DEFAULT,
WebSocketConstants.WS_ENCODING_DEFAULT);
Thread lReciver = new Thread(new ThreadStart(Receiver));
lReciver.Start();
if (mLog.IsInfoEnabled)
mLog.Info(WebSocketMessage.CONNECTION_HAS_BEEN_ESTABLISHED);
mStatus = WebSocketStatus.OPENED;
mIsRunning = true;
OnOpenConnection(mHeaders);
}
catch (TimeoutException lTe)
{
if (mLog.IsErrorEnabled)
mLog.Error(WebSocketMessage.EXCEEDED_FOR_CONNECTION + WebSocketMessage.SEPARATOR
+ WebSocketMessage.DETAILS + lTe.Message);
mCLose = WebSocketCloseReason.TIMEOUT;
OnCloseConnection(mCLose);
OnError(new WebSocketError(WebSocketMessage.TIMEOUT + WebSocketMessage.EXCEEDED_FOR_CONNECTION, mCLose));
CheckReconnect();
}
catch (Exception lEx)
{
if (mLog.IsErrorEnabled)
mLog.Error(WebSocketMessage.NOT_ESTABLISH_CONNECTION + WebSocketMessage.SEPARATOR
+ WebSocketMessage.DETAILS + lEx.Message);
mCLose = WebSocketCloseReason.BROKEN;
OnCloseConnection(mCLose);
OnError(new WebSocketError(WebSocketMessage.NOT_ESTABLISH_CONNECTION, mCLose));
CheckReconnect();
}
}
public static bool isConnected(WebSocketStatus aStatus)
{
return (aStatus.Equals(WebSocketStatus.OPEN));
}
private void CheckReconnect()
{
if (mReliabilityOptions!=null)
{
if (mReliabilityOptions.IsAutoReconnect)
{
if (mLog.IsDebugEnabled)
mLog.Debug(WebSocketMessage.CHECKING_RECONNECT);
mStatus = WebSocketStatus.RECONNECTING;
mReconnect = new Thread(new ThreadStart(Reconnet));
mReconnect.Start();
}
}
}
public WebSocketException()
{
Code = WebSocketStatus.GoingAway;
}
/// <inheritdoc /> public void SetStatus(WebSocketStatus status) => Status = status;
public static bool isClosed(WebSocketStatus aStatus)
{
return (aStatus.Equals(WebSocketStatus.CLOSED));
}
/// <inheritdoc /> public void SetStatus(WebSocketStatus status) => ActionQueue.Enqueue(() => ToQueueFor.SetStatus(status));
