using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Authentication;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Fleck.Handlers;
using Fleck.Helpers;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("statenjason")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright Jason Staten 2010-2018. All rights reserved.")]
[assembly: AssemblyDescription("C# WebSocket Implementation")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0")]
[assembly: AssemblyProduct("Fleck")]
[assembly: AssemblyTitle("Fleck")]
[assembly: AssemblyVersion("1.2.0.0")]
namespace Fleck
{
public class ConnectionNotAvailableException : Exception
{
public ConnectionNotAvailableException()
{
}
public ConnectionNotAvailableException(string message)
: base(message)
{
}
public ConnectionNotAvailableException(string message, Exception innerException)
: base(message, innerException)
{
}
}
public enum LogLevel
{
Debug,
Info,
Warn,
Error
}
public class FleckLog
{
public static LogLevel Level = LogLevel.Info;
public static Action<LogLevel, string, Exception> LogAction = delegate(LogLevel level, string message, Exception ex)
{
if (level >= Level)
{
Console.WriteLine("{0} [{1}] {2} {3}", DateTime.Now, level, message, ex);
}
};
public static void Warn(string message, Exception ex = null)
{
LogAction(LogLevel.Warn, message, ex);
}
public static void Error(string message, Exception ex = null)
{
LogAction(LogLevel.Error, message, ex);
}
public static void Debug(string message, Exception ex = null)
{
LogAction(LogLevel.Debug, message, ex);
}
public static void Info(string message, Exception ex = null)
{
LogAction(LogLevel.Info, message, ex);
}
}
public enum FrameType : byte
{
Continuation = 0,
Text = 1,
Binary = 2,
Close = 8,
Ping = 9,
Pong = 10
}
public class HandlerFactory
{
public static IHandler BuildHandler(WebSocketHttpRequest request, Action<string> onMessage, Action onClose, Action<byte[]> onBinary, Action<byte[]> onPing, Action<byte[]> onPong)
{
switch (GetVersion(request))
{
case "76":
return Draft76Handler.Create(request, onMessage);
case "7":
case "8":
case "13":
return Hybi13Handler.Create(request, onMessage, onClose, onBinary, onPing, onPong);
case "policy-file-request":
return FlashSocketPolicyRequestHandler.Create(request);
default:
throw new WebSocketException(1003);
}
}
public static string GetVersion(WebSocketHttpRequest request)
{
if (request.Headers.TryGetValue("Sec-WebSocket-Version", out var value))
{
return value;
}
if (request.Headers.TryGetValue("Sec-WebSocket-Draft", out value))
{
return value;
}
if (request.Headers.ContainsKey("Sec-WebSocket-Key1"))
{
return "76";
}
if (request.Body != null && request.Body.ToLower().Contains("policy-file-request"))
{
return "policy-file-request";
}
return "75";
}
}
public interface IHandler
{
byte[] CreateHandshake(string subProtocol = null);
void Receive(IEnumerable<byte> data);
byte[] FrameText(string text);
byte[] FrameBinary(byte[] bytes);
byte[] FramePing(byte[] bytes);
byte[] FramePong(byte[] bytes);
byte[] FrameClose(int code);
}
public interface ISocket
{
bool Connected { get; }
string RemoteIpAddress { get; }
int RemotePort { get; }
Stream Stream { get; }
bool NoDelay { get; set; }
EndPoint LocalEndPoint { get; }
Task<ISocket> Accept(Action<ISocket> callback, Action<Exception> error);
Task Send(byte[] buffer, Action callback, Action<Exception> error);
Task<int> Receive(byte[] buffer, Action<int> callback, Action<Exception> error, int offset = 0);
Task Authenticate(X509Certificate2 certificate, SslProtocols enabledSslProtocols, Action callback, Action<Exception> error);
void Dispose();
void Close();
void Bind(EndPoint ipLocal);
void Listen(int backlog);
}
public interface IWebSocketConnection
{
Action OnOpen { get; set; }
Action OnClose { get; set; }
Action<string> OnMessage { get; set; }
Action<byte[]> OnBinary { get; set; }
Action<byte[]> OnPing { get; set; }
Action<byte[]> OnPong { get; set; }
Action<Exception> OnError { get; set; }
IWebSocketConnectionInfo ConnectionInfo { get; }
bool IsAvailable { get; }
Task Send(string message);
Task Send(byte[] message);
Task SendPing(byte[] message);
Task SendPong(byte[] message);
void Close();
void Close(int code);
}
public interface IWebSocketConnectionInfo
{
string SubProtocol { get; }
string Origin { get; }
string Host { get; }
string Path { get; }
string ClientIpAddress { get; }
int ClientPort { get; }
IDictionary<string, string> Cookies { get; }
IDictionary<string, string> Headers { get; }
Guid Id { get; }
string NegotiatedSubProtocol { get; }
}
public interface IWebSocketServer : IDisposable
{
void Start(Action<IWebSocketConnection> config);
}
public static class IntExtensions
{
public static byte[] ToBigEndianBytes<T>(this int source)
{
Type typeFromHandle = typeof(T);
byte[] bytes;
if (typeFromHandle == typeof(ushort))
{
bytes = BitConverter.GetBytes((ushort)source);
}
else if (typeFromHandle == typeof(ulong))
{
bytes = BitConverter.GetBytes((ulong)source);
}
else
{
if (!(typeFromHandle == typeof(int)))
{
throw new InvalidCastException("Cannot be cast to T");
}
bytes = BitConverter.GetBytes(source);
}
if (BitConverter.IsLittleEndian)
{
Array.Reverse((Array)bytes);
}
return bytes;
}
public static int ToLittleEndianInt(this byte[] source)
{
if (BitConverter.IsLittleEndian)
{
Array.Reverse((Array)source);
}
if (source.Length == 2)
{
return BitConverter.ToUInt16(source, 0);
}
if (source.Length == 8)
{
return (int)BitConverter.ToUInt64(source, 0);
}
throw new ArgumentException("Unsupported Size");
}
}
public class QueuedStream : Stream
{
private class WriteData
{
public readonly byte[] Buffer;
public readonly int Offset;
public readonly int Count;
public readonly AsyncCallback Callback;
public readonly object State;
public readonly QueuedWriteResult AsyncResult;
public WriteData(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
Buffer = buffer;
Offset = offset;
Count = count;
Callback = callback;
State = state;
AsyncResult = new QueuedWriteResult(state);
}
}
private class QueuedWriteResult : IAsyncResult
{
private readonly object _state;
public Exception Exception { get; set; }
public IAsyncResult ActualResult { get; set; }
public object AsyncState => _state;
public WaitHandle AsyncWaitHandle
{
get
{
throw new NotSupportedException("Queued write operations do not support wait handle.");
}
}
public bool CompletedSynchronously => false;
public bool IsCompleted
{
get
{
if (ActualResult != null)
{
return ActualResult.IsCompleted;
}
return false;
}
}
public QueuedWriteResult(object state)
{
_state = state;
}
}
private readonly Stream _stream;
private readonly Queue<WriteData> _queue = new Queue<WriteData>();
private int _pendingWrite;
private bool _disposed;
public override bool CanRead => _stream.CanRead;
public override bool CanSeek => _stream.CanSeek;
public override bool CanWrite => _stream.CanWrite;
public override long Length => _stream.Length;
public override long Position
{
get
{
return _stream.Position;
}
set
{
_stream.Position = value;
}
}
public QueuedStream(Stream stream)
{
_stream = stream;
}
public override int Read(byte[] buffer, int offset, int count)
{
return _stream.Read(buffer, offset, count);
}
public override long Seek(long offset, SeekOrigin origin)
{
return _stream.Seek(offset, origin);
}
public override void SetLength(long value)
{
_stream.SetLength(value);
}
public override void Write(byte[] buffer, int offset, int count)
{
throw new NotSupportedException("QueuedStream does not support synchronous write operations yet.");
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return _stream.BeginRead(buffer, offset, count, callback, state);
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
lock (_queue)
{
WriteData writeData = new WriteData(buffer, offset, count, callback, state);
if (_pendingWrite > 0)
{
_queue.Enqueue(writeData);
return writeData.AsyncResult;
}
return BeginWriteInternal(buffer, offset, count, callback, state, writeData);
}
}
public override int EndRead(IAsyncResult asyncResult)
{
return _stream.EndRead(asyncResult);
}
public override void EndWrite(IAsyncResult asyncResult)
{
if (asyncResult is QueuedWriteResult)
{
QueuedWriteResult queuedWriteResult = asyncResult as QueuedWriteResult;
if (queuedWriteResult.Exception != null)
{
throw queuedWriteResult.Exception;
}
if (queuedWriteResult.ActualResult == null)
{
throw new NotSupportedException("QueuedStream does not support synchronous write operations. Please wait for callback to be invoked before calling EndWrite.");
}
return;
}
throw new ArgumentException();
}
public override void Flush()
{
_stream.Flush();
}
public override void Close()
{
_stream.Close();
}
protected override void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
_stream.Dispose();
}
_disposed = true;
}
base.Dispose(disposing);
}
private IAsyncResult BeginWriteInternal(byte[] buffer, int offset, int count, AsyncCallback callback, object state, WriteData queued)
{
_pendingWrite++;
IAsyncResult actualResult = _stream.BeginWrite(buffer, offset, count, delegate(IAsyncResult ar)
{
queued.AsyncResult.ActualResult = ar;
try
{
_stream.EndWrite(ar);
}
catch (Exception exception)
{
queued.AsyncResult.Exception = exception;
}
lock (_queue)
{
_pendingWrite--;
while (_queue.Count > 0)
{
WriteData writeData = _queue.Dequeue();
try
{
writeData.AsyncResult.ActualResult = BeginWriteInternal(writeData.Buffer, writeData.Offset, writeData.Count, writeData.Callback, writeData.State, writeData);
}
catch (Exception exception2)
{
_pendingWrite--;
writeData.AsyncResult.Exception = exception2;
writeData.Callback(writeData.AsyncResult);
continue;
}
break;
}
callback(queued.AsyncResult);
}
}, state);
queued.AsyncResult.ActualResult = actualResult;
return queued.AsyncResult;
}
}
public class ReadState
{
public List<byte> Data { get; private set; }
public FrameType? FrameType { get; set; }
public ReadState()
{
Data = new List<byte>();
}
public void Clear()
{
Data.Clear();
FrameType = null;
}
}
public class RequestParser
{
private const string pattern = "^(?<method>[^\\s]+)\\s(?<path>[^\\s]+)\\sHTTP\\/1\\.1\\r\\n((?<field_name>[^:\\r\\n]+):(?([^\\r\\n])\\s)*(?<field_value>[^\\r\\n]*)\\r\\n)+\\r\\n(?<body>.+)?";
private const string FlashSocketPolicyRequestPattern = "^[<]policy-file-request\\s*[/][>]";
private static readonly Regex _regex = new Regex("^(?<method>[^\\s]+)\\s(?<path>[^\\s]+)\\sHTTP\\/1\\.1\\r\\n((?<field_name>[^:\\r\\n]+):(?([^\\r\\n])\\s)*(?<field_value>[^\\r\\n]*)\\r\\n)+\\r\\n(?<body>.+)?", RegexOptions.IgnoreCase | RegexOptions.Compiled);
private static readonly Regex _FlashSocketPolicyRequestRegex = new Regex("^[<]policy-file-request\\s*[/][>]", RegexOptions.IgnoreCase | RegexOptions.Compiled);
public static WebSocketHttpRequest Parse(byte[] bytes)
{
return Parse(bytes, "ws");
}
public static WebSocketHttpRequest Parse(byte[] bytes, string scheme)
{
string @string = Encoding.UTF8.GetString(bytes);
Match match = _regex.Match(@string);
if (!match.Success)
{
match = _FlashSocketPolicyRequestRegex.Match(@string);
if (match.Success)
{
return new WebSocketHttpRequest
{
Body = @string,
Bytes = bytes
};
}
return null;
}
WebSocketHttpRequest webSocketHttpRequest = new WebSocketHttpRequest
{
Method = match.Groups["method"].Value,
Path = match.Groups["path"].Value,
Body = match.Groups["body"].Value,
Bytes = bytes,
Scheme = scheme
};
CaptureCollection captures = match.Groups["field_name"].Captures;
CaptureCollection captures2 = match.Groups["field_value"].Captures;
for (int i = 0; i < captures.Count; i++)
{
string key = captures[i].ToString();
string value = captures2[i].ToString();
webSocketHttpRequest.Headers[key] = value;
}
return webSocketHttpRequest;
}
}
public class SocketWrapper : ISocket
{
public const uint KeepAliveInterval = 60000u;
public const uint RetryInterval = 10000u;
private readonly Socket _socket;
private Stream _stream;
private CancellationTokenSource _tokenSource;
private TaskFactory _taskFactory;
public string RemoteIpAddress
{
get
{
if (!(_socket.RemoteEndPoint is IPEndPoint iPEndPoint))
{
return null;
}
return iPEndPoint.Address.ToString();
}
}
public int RemotePort
{
get
{
if (!(_socket.RemoteEndPoint is IPEndPoint iPEndPoint))
{
return -1;
}
return iPEndPoint.Port;
}
}
public bool Connected => _socket.Connected;
public Stream Stream => _stream;
public bool NoDelay
{
get
{
return _socket.NoDelay;
}
set
{
_socket.NoDelay = value;
}
}
public EndPoint LocalEndPoint => _socket.LocalEndPoint;
public void SetKeepAlive(Socket socket, uint keepAliveInterval, uint retryInterval)
{
int num = 4;
byte[] array = new byte[num * 3];
Array.Copy(BitConverter.GetBytes(1u), 0, array, 0, num);
Array.Copy(BitConverter.GetBytes(keepAliveInterval), 0, array, num, num);
Array.Copy(BitConverter.GetBytes(retryInterval), 0, array, num * 2, num);
socket.IOControl(IOControlCode.KeepAliveValues, array, null);
}
public SocketWrapper(Socket socket)
{
_tokenSource = new CancellationTokenSource();
_taskFactory = new TaskFactory(_tokenSource.Token);
_socket = socket;
if (_socket.Connected)
{
_stream = new NetworkStream(_socket);
}
if (FleckRuntime.IsRunningOnWindows())
{
SetKeepAlive(socket, 60000u, 10000u);
}
}
public Task Authenticate(X509Certificate2 certificate, SslProtocols enabledSslProtocols, Action callback, Action<Exception> error)
{
SslStream ssl = new SslStream(_stream, leaveInnerStreamOpen: false);
_stream = new QueuedStream(ssl);
Func<AsyncCallback, object, IAsyncResult> beginMethod = (AsyncCallback cb, object s) => ssl.BeginAuthenticateAsServer(certificate, clientCertificateRequired: false, enabledSslProtocols, checkCertificateRevocation: false, cb, s);
Task task = Task.Factory.FromAsync(beginMethod, ssl.EndAuthenticateAsServer, null);
task.ContinueWith(delegate
{
callback();
}, TaskContinuationOptions.NotOnFaulted).ContinueWith(delegate(Task t)
{
error(t.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
task.ContinueWith(delegate(Task t)
{
error(t.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
return task;
}
public void Listen(int backlog)
{
_socket.Listen(backlog);
}
public void Bind(EndPoint endPoint)
{
_socket.Bind(endPoint);
}
public Task<int> Receive(byte[] buffer, Action<int> callback, Action<Exception> error, int offset)
{
try
{
Func<AsyncCallback, object, IAsyncResult> beginMethod = (AsyncCallback cb, object s) => _stream.BeginRead(buffer, offset, buffer.Length, cb, s);
Task<int> task = Task.Factory.FromAsync(beginMethod, (Func<IAsyncResult, int>)_stream.EndRead, (object?)null);
task.ContinueWith(delegate(Task<int> t)
{
callback(t.Result);
}, TaskContinuationOptions.NotOnFaulted).ContinueWith(delegate(Task t)
{
error(t.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
task.ContinueWith(delegate(Task<int> t)
{
error(t.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
return task;
}
catch (Exception obj)
{
error(obj);
return null;
}
}
public Task<ISocket> Accept(Action<ISocket> callback, Action<Exception> error)
{
Func<IAsyncResult, ISocket> endMethod = (IAsyncResult r) => (!_tokenSource.Token.IsCancellationRequested) ? new SocketWrapper(_socket.EndAccept(r)) : null;
Task<ISocket> task = _taskFactory.FromAsync(_socket.BeginAccept, endMethod, null);
task.ContinueWith(delegate(Task<ISocket> t)
{
callback(t.Result);
}, TaskContinuationOptions.OnlyOnRanToCompletion).ContinueWith(delegate(Task t)
{
error(t.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
task.ContinueWith(delegate(Task<ISocket> t)
{
error(t.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
return task;
}
public void Dispose()
{
_tokenSource.Cancel();
if (_stream != null)
{
_stream.Dispose();
}
if (_socket != null)
{
_socket.Dispose();
}
}
public void Close()
{
_tokenSource.Cancel();
if (_stream != null)
{
_stream.Close();
}
if (_socket != null)
{
_socket.Close();
}
}
public int EndSend(IAsyncResult asyncResult)
{
_stream.EndWrite(asyncResult);
return 0;
}
public Task Send(byte[] buffer, Action callback, Action<Exception> error)
{
if (_tokenSource.IsCancellationRequested)
{
return null;
}
try
{
Func<AsyncCallback, object, IAsyncResult> beginMethod = (AsyncCallback cb, object s) => _stream.BeginWrite(buffer, 0, buffer.Length, cb, s);
Task task = Task.Factory.FromAsync(beginMethod, _stream.EndWrite, null);
task.ContinueWith(delegate
{
callback();
}, TaskContinuationOptions.NotOnFaulted).ContinueWith(delegate(Task t)
{
error(t.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
task.ContinueWith(delegate(Task t)
{
error(t.Exception);
}, TaskContinuationOptions.OnlyOnFaulted);
return task;
}
catch (Exception obj)
{
error(obj);
return null;
}
}
}
public class SubProtocolNegotiationFailureException : Exception
{
public SubProtocolNegotiationFailureException()
{
}
public SubProtocolNegotiationFailureException(string message)
: base(message)
{
}
public SubProtocolNegotiationFailureException(string message, Exception innerException)
: base(message, innerException)
{
}
}
public static class SubProtocolNegotiator
{
public static string Negotiate(IEnumerable<string> server, IEnumerable<string> client)
{
if (!server.Any() || !client.Any())
{
return null;
}
IEnumerable<string> source = client.Intersect(server);
if (!source.Any())
{
throw new SubProtocolNegotiationFailureException("Unable to negotiate a subprotocol");
}
return source.First();
}
}
public class WebSocketConnection : IWebSocketConnection
{
private readonly Action<IWebSocketConnection> _initialize;
private readonly Func<WebSocketHttpRequest, IHandler> _handlerFactory;
private readonly Func<IEnumerable<string>, string> _negotiateSubProtocol;
private readonly Func<byte[], WebSocketHttpRequest> _parseRequest;
private bool _closing;
private bool _closed;
private const int ReadSize = 4096;
public ISocket Socket { get; set; }
public IHandler Handler { get; set; }
public Action OnOpen { get; set; }
public Action OnClose { get; set; }
public Action<string> OnMessage { get; set; }
public Action<byte[]> OnBinary { get; set; }
public Action<byte[]> OnPing { get; set; }
public Action<byte[]> OnPong { get; set; }
public Action<Exception> OnError { get; set; }
public IWebSocketConnectionInfo ConnectionInfo { get; private set; }
public bool IsAvailable
{
get
{
if (!_closing && !_closed)
{
return Socket.Connected;
}
return false;
}
}
public WebSocketConnection(ISocket socket, Action<IWebSocketConnection> initialize, Func<byte[], WebSocketHttpRequest> parseRequest, Func<WebSocketHttpRequest, IHandler> handlerFactory, Func<IEnumerable<string>, string> negotiateSubProtocol)
{
Socket = socket;
OnOpen = delegate
{
};
OnClose = delegate
{
};
OnMessage = delegate
{
};
OnBinary = delegate
{
};
OnPing = delegate(byte[] x)
{
SendPong(x);
};
OnPong = delegate
{
};
OnError = delegate
{
};
_initialize = initialize;
_handlerFactory = handlerFactory;
_parseRequest = parseRequest;
_negotiateSubProtocol = negotiateSubProtocol;
}
public Task Send(string message)
{
return Send(message, Handler.FrameText);
}
public Task Send(byte[] message)
{
return Send(message, Handler.FrameBinary);
}
public Task SendPing(byte[] message)
{
return Send(message, Handler.FramePing);
}
public Task SendPong(byte[] message)
{
return Send(message, Handler.FramePong);
}
private Task Send<T>(T message, Func<T, byte[]> createFrame)
{
if (Handler == null)
{
throw new InvalidOperationException("Cannot send before handshake");
}
if (!IsAvailable)
{
FleckLog.Warn("Data sent while closing or after close. Ignoring.");
TaskCompletionSource<object> taskCompletionSource = new TaskCompletionSource<object>();
taskCompletionSource.SetException(new ConnectionNotAvailableException("Data sent while closing or after close. Ignoring."));
return taskCompletionSource.Task;
}
byte[] bytes = createFrame(message);
return SendBytes(bytes);
}
public void StartReceiving()
{
List<byte> data = new List<byte>(4096);
byte[] buffer = new byte[4096];
Read(data, buffer);
}
public void Close()
{
Close(1000);
}
public void Close(int code)
{
if (!IsAvailable)
{
return;
}
_closing = true;
if (Handler == null)
{
CloseSocket();
return;
}
byte[] array = Handler.FrameClose(code);
if (array.Length == 0)
{
CloseSocket();
}
else
{
SendBytes(array, CloseSocket);
}
}
public void CreateHandler(IEnumerable<byte> data)
{
WebSocketHttpRequest webSocketHttpRequest = _parseRequest(data.ToArray());
if (webSocketHttpRequest != null)
{
Handler = _handlerFactory(webSocketHttpRequest);
if (Handler != null)
{
string text = _negotiateSubProtocol(webSocketHttpRequest.SubProtocols);
ConnectionInfo = WebSocketConnectionInfo.Create(webSocketHttpRequest, Socket.RemoteIpAddress, Socket.RemotePort, text);
_initialize(this);
byte[] bytes = Handler.CreateHandshake(text);
SendBytes(bytes, OnOpen);
}
}
}
private void Read(List<byte> data, byte[] buffer)
{
if (!IsAvailable)
{
return;
}
Socket.Receive(buffer, delegate(int r)
{
if (r <= 0)
{
FleckLog.Debug("0 bytes read. Closing.");
CloseSocket();
}
else
{
FleckLog.Debug(r + " bytes read");
IEnumerable<byte> enumerable = buffer.Take(r);
if (Handler != null)
{
Handler.Receive(enumerable);
}
else
{
data.AddRange(enumerable);
CreateHandler(data);
}
Read(data, buffer);
}
}, HandleReadError);
}
private void HandleReadError(Exception e)
{
if (e is AggregateException)
{
AggregateException ex = e as AggregateException;
HandleReadError(ex.InnerException);
return;
}
if (e is ObjectDisposedException)
{
FleckLog.Debug("Swallowing ObjectDisposedException", e);
return;
}
OnError(e);
if (e is WebSocketException)
{
FleckLog.Debug("Error while reading", e);
Close(((WebSocketException)e).StatusCode);
}
else if (e is SubProtocolNegotiationFailureException)
{
FleckLog.Debug(e.Message);
Close(1002);
}
else if (e is IOException)
{
FleckLog.Debug("Error while reading", e);
Close(1006);
}
else
{
FleckLog.Error("Application Error", e);
Close(1011);
}
}
private Task SendBytes(byte[] bytes, Action callback = null)
{
return Socket.Send(bytes, delegate
{
FleckLog.Debug("Sent " + bytes.Length + " bytes");
if (callback != null)
{
callback();
}
}, delegate(Exception e)
{
if (e is IOException)
{
FleckLog.Debug("Failed to send. Disconnecting.", e);
}
else
{
FleckLog.Info("Failed to send. Disconnecting.", e);
}
CloseSocket();
});
}
private void CloseSocket()
{
_closing = true;
OnClose();
_closed = true;
Socket.Close();
Socket.Dispose();
_closing = false;
}
}
public class WebSocketConnectionInfo : IWebSocketConnectionInfo
{
private const string CookiePattern = "((;)*(\\s)*(?<cookie_name>[^=]+)=(?<cookie_value>[^\\;]+))+";
private static readonly Regex CookieRegex = new Regex("((;)*(\\s)*(?<cookie_name>[^=]+)=(?<cookie_value>[^\\;]+))+", RegexOptions.Compiled);
public string NegotiatedSubProtocol { get; private set; }
public string SubProtocol { get; private set; }
public string Origin { get; private set; }
public string Host { get; private set; }
public string Path { get; private set; }
public string ClientIpAddress { get; set; }
public int ClientPort { get; set; }
public Guid Id { get; set; }
public IDictionary<string, string> Cookies { get; private set; }
public IDictionary<string, string> Headers { get; private set; }
public static WebSocketConnectionInfo Create(WebSocketHttpRequest request, string clientIp, int clientPort, string negotiatedSubprotocol)
{
WebSocketConnectionInfo webSocketConnectionInfo = new WebSocketConnectionInfo
{
Origin = (request["Origin"] ?? request["Sec-WebSocket-Origin"]),
Host = request["Host"],
SubProtocol = request["Sec-WebSocket-Protocol"],
Path = request.Path,
ClientIpAddress = clientIp,
ClientPort = clientPort,
NegotiatedSubProtocol = negotiatedSubprotocol,
Headers = new Dictionary<string, string>(request.Headers, StringComparer.InvariantCultureIgnoreCase)
};
string text = request["Cookie"];
if (text != null)
{
Match match = CookieRegex.Match(text);
CaptureCollection captures = match.Groups["cookie_name"].Captures;
CaptureCollection captures2 = match.Groups["cookie_value"].Captures;
for (int i = 0; i < captures.Count; i++)
{
string key = captures[i].ToString();
string value = captures2[i].ToString();
webSocketConnectionInfo.Cookies[key] = value;
}
}
return webSocketConnectionInfo;
}
private WebSocketConnectionInfo()
{
Cookies = new Dictionary<string, string>();
Id = Guid.NewGuid();
}
}
public class WebSocketException : Exception
{
public ushort StatusCode { get; private set; }
public WebSocketException(ushort statusCode)
{
StatusCode = statusCode;
}
public WebSocketException(ushort statusCode, string message)
: base(message)
{
StatusCode = statusCode;
}
public WebSocketException(ushort statusCode, string message, Exception innerException)
: base(message, innerException)
{
StatusCode = statusCode;
}
}
public class WebSocketHttpRequest
{
private readonly IDictionary<string, string> _headers = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
public string Method { get; set; }
public string Path { get; set; }
public string Body { get; set; }
public string Scheme { get; set; }
public byte[] Bytes { get; set; }
public string this[string name]
{
get
{
if (!_headers.TryGetValue(name, out var value))
{
return null;
}
return value;
}
}
public IDictionary<string, string> Headers => _headers;
public string[] SubProtocols
{
get
{
if (!_headers.TryGetValue("Sec-WebSocket-Protocol", out var value))
{
return new string[0];
}
return value.Split(new char[2] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
}
}
}
public class WebSocketServer : IWebSocketServer, IDisposable
{
private readonly string _scheme;
private readonly IPAddress _locationIP;
private Action<IWebSocketConnection> _config;
public ISocket ListenerSocket { get; set; }
public string Location { get; private set; }
public bool SupportDualStack { get; }
public int Port { get; private set; }
public X509Certificate2 Certificate { get; set; }
public SslProtocols EnabledSslProtocols { get; set; }
public IEnumerable<string> SupportedSubProtocols { get; set; }
public bool RestartAfterListenError { get; set; }
public bool IsSecure
{
get
{
if (_scheme == "wss")
{
return Certificate != null;
}
return false;
}
}
public WebSocketServer(string location, bool supportDualStack = true)
{
Uri uri = new Uri(location);
Port = uri.Port;
Location = location;
SupportDualStack = supportDualStack;
_locationIP = ParseIPAddress(uri);
_scheme = uri.Scheme;
Socket socket = new Socket(_locationIP.AddressFamily, SocketType.Stream, ProtocolType.IP);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
if (SupportDualStack && !FleckRuntime.IsRunningOnMono() && FleckRuntime.IsRunningOnWindows())
{
socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, optionValue: false);
}
ListenerSocket = new SocketWrapper(socket);
SupportedSubProtocols = new string[0];
}
public void Dispose()
{
ListenerSocket.Dispose();
}
private IPAddress ParseIPAddress(Uri uri)
{
string host = uri.Host;
if (host == "0.0.0.0")
{
return IPAddress.Any;
}
if (host == "[0000:0000:0000:0000:0000:0000:0000:0000]")
{
return IPAddress.IPv6Any;
}
try
{
return IPAddress.Parse(host);
}
catch (Exception innerException)
{
throw new FormatException("Failed to parse the IP address part of the location. Please make sure you specify a valid IP address. Use 0.0.0.0 or [::] to listen on all interfaces.", innerException);
}
}
public void Start(Action<IWebSocketConnection> config)
{
IPEndPoint ipLocal = new IPEndPoint(_locationIP, Port);
ListenerSocket.Bind(ipLocal);
ListenerSocket.Listen(100);
Port = ((IPEndPoint)ListenerSocket.LocalEndPoint).Port;
FleckLog.Info($"Server started at {Location} (actual port {Port})");
if (_scheme == "wss")
{
if (Certificate == null)
{
FleckLog.Error("Scheme cannot be 'wss' without a Certificate");
return;
}
if (EnabledSslProtocols == SslProtocols.None)
{
EnabledSslProtocols = SslProtocols.Tls;
FleckLog.Debug("Using default TLS 1.0 security protocol.");
}
}
ListenForClients();
_config = config;
}
private void ListenForClients()
{
ListenerSocket.Accept(OnClientConnect, delegate(Exception e)
{
FleckLog.Error("Listener socket is closed", e);
if (RestartAfterListenError)
{
FleckLog.Info("Listener socket restarting");
try
{
ListenerSocket.Dispose();
Socket socket = new Socket(_locationIP.AddressFamily, SocketType.Stream, ProtocolType.IP);
ListenerSocket = new SocketWrapper(socket);
Start(_config);
FleckLog.Info("Listener socket restarted");
}
catch (Exception ex)
{
FleckLog.Error("Listener could not be restarted", ex);
}
}
});
}
private void OnClientConnect(ISocket clientSocket)
{
if (clientSocket == null)
{
return;
}
FleckLog.Debug($"Client connected from {clientSocket.RemoteIpAddress}:{clientSocket.RemotePort.ToString()}");
ListenForClients();
WebSocketConnection connection = null;
connection = new WebSocketConnection(clientSocket, _config, (byte[] bytes) => RequestParser.Parse(bytes, _scheme), (WebSocketHttpRequest r) => HandlerFactory.BuildHandler(r, delegate(string s)
{
connection.OnMessage(s);
}, connection.Close, delegate(byte[] b)
{
connection.OnBinary(b);
}, delegate(byte[] b)
{
connection.OnPing(b);
}, delegate(byte[] b)
{
connection.OnPong(b);
}), (IEnumerable<string> s) => SubProtocolNegotiator.Negotiate(SupportedSubProtocols, s));
if (IsSecure)
{
FleckLog.Debug("Authenticating Secure Connection");
clientSocket.Authenticate(Certificate, EnabledSslProtocols, connection.StartReceiving, delegate(Exception e)
{
FleckLog.Warn("Failed to Authenticate", e);
});
}
else
{
connection.StartReceiving();
}
}
}
public static class WebSocketStatusCodes
{
public const ushort NormalClosure = 1000;
public const ushort GoingAway = 1001;
public const ushort ProtocolError = 1002;
public const ushort UnsupportedDataType = 1003;
public const ushort NoStatusReceived = 1005;
public const ushort AbnormalClosure = 1006;
public const ushort InvalidFramePayloadData = 1007;
public const ushort PolicyViolation = 1008;
public const ushort MessageTooBig = 1009;
public const ushort MandatoryExt = 1010;
public const ushort InternalServerError = 1011;
public const ushort TLSHandshake = 1015;
public const ushort ApplicationError = 3000;
public static ushort[] ValidCloseCodes = new ushort[9] { 1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011 };
}
}
namespace Fleck.Helpers
{
internal static class FleckRuntime
{
public static bool IsRunningOnMono()
{
return Type.GetType("Mono.Runtime") != null;
}
public static bool IsRunningOnWindows()
{
return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
}
}
}
namespace Fleck.Handlers
{
public class ComposableHandler : IHandler
{
public Func<string, byte[]> Handshake = (string s) => new byte[0];
public Func<string, byte[]> TextFrame = (string x) => new byte[0];
public Func<byte[], byte[]> BinaryFrame = (byte[] x) => new byte[0];
public Action<List<byte>> ReceiveData = delegate
{
};
public Func<byte[], byte[]> PingFrame = (byte[] i) => new byte[0];
public Func<byte[], byte[]> PongFrame = (byte[] i) => new byte[0];
public Func<int, byte[]> CloseFrame = (int i) => new byte[0];
private readonly List<byte> _data = new List<byte>();
public byte[] CreateHandshake(string subProtocol = null)
{
return Handshake(subProtocol);
}
public void Receive(IEnumerable<byte> data)
{
_data.AddRange(data);
ReceiveData(_data);
}
public byte[] FrameText(string text)
{
return TextFrame(text);
}
public byte[] FrameBinary(byte[] bytes)
{
return BinaryFrame(bytes);
}
public byte[] FramePing(byte[] bytes)
{
return PingFrame(bytes);
}
public byte[] FramePong(byte[] bytes)
{
return PongFrame(bytes);
}
public byte[] FrameClose(int code)
{
return CloseFrame(code);
}
}
public static class Draft76Handler
{
private const byte End = byte.MaxValue;
private const byte Start = 0;
private const int MaxSize = 5242880;
public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage)
{
return new ComposableHandler
{
TextFrame = FrameText,
Handshake = (string sub) => Handshake(request, sub),
ReceiveData = delegate(List<byte> data)
{
ReceiveData(onMessage, data);
}
};
}
public static void ReceiveData(Action<string> onMessage, List<byte> data)
{
while (data.Count > 0)
{
if (data[0] != 0)
{
throw new WebSocketException(1007);
}
int num = data.IndexOf(byte.MaxValue);
if (num < 0)
{
break;
}
if (num > 5242880)
{
throw new WebSocketException(1009);
}
byte[] bytes = data.Skip(1).Take(num - 1).ToArray();
data.RemoveRange(0, num + 1);
string @string = Encoding.UTF8.GetString(bytes);
onMessage(@string);
}
}
public static byte[] FrameText(string data)
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
byte[] array = new byte[bytes.Length + 2];
array[0] = 0;
array[^1] = byte.MaxValue;
Array.Copy(bytes, 0, array, 1, bytes.Length);
return array;
}
public static byte[] Handshake(WebSocketHttpRequest request, string subProtocol)
{
FleckLog.Debug("Building Draft76 Response");
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("HTTP/1.1 101 WebSocket Protocol Handshake\r\n");
stringBuilder.Append("Upgrade: WebSocket\r\n");
stringBuilder.Append("Connection: Upgrade\r\n");
stringBuilder.AppendFormat("Sec-WebSocket-Origin: {0}\r\n", request["Origin"]);
stringBuilder.AppendFormat("Sec-WebSocket-Location: {0}://{1}{2}\r\n", request.Scheme, request["Host"], request.Path);
if (subProtocol != null)
{
stringBuilder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", subProtocol);
}
stringBuilder.Append("\r\n");
string key = request["Sec-WebSocket-Key1"];
string key2 = request["Sec-WebSocket-Key2"];
ArraySegment<byte> challenge = new ArraySegment<byte>(request.Bytes, request.Bytes.Length - 8, 8);
byte[] array = CalculateAnswerBytes(key, key2, challenge);
byte[] array2 = Encoding.ASCII.GetBytes(stringBuilder.ToString());
int num = array2.Length;
Array.Resize(ref array2, num + array.Length);
Array.Copy(array, 0, array2, num, array.Length);
return array2;
}
public static byte[] CalculateAnswerBytes(string key1, string key2, ArraySegment<byte> challenge)
{
byte[] sourceArray = ParseKey(key1);
byte[] sourceArray2 = ParseKey(key2);
byte[] array = new byte[16];
Array.Copy(sourceArray, 0, array, 0, 4);
Array.Copy(sourceArray2, 0, array, 4, 4);
Array.Copy(challenge.Array, challenge.Offset, array, 8, 8);
return MD5.Create().ComputeHash(array);
}
private static byte[] ParseKey(string key)
{
int num = key.Count((char x) => x == ' ');
byte[] bytes = BitConverter.GetBytes((int)(long.Parse(new string(key.Where(char.IsDigit).ToArray())) / num));
if (BitConverter.IsLittleEndian)
{
Array.Reverse((Array)bytes);
}
return bytes;
}
}
public class FlashSocketPolicyRequestHandler
{
public static string PolicyResponse = "<?xml version=\"1.0\"?>\n<cross-domain-policy>\n <allow-access-from domain=\"*\" to-ports=\"*\"/>\n <site-control permitted-cross-domain-policies=\"all\"/>\n</cross-domain-policy>\n\0";
public static IHandler Create(WebSocketHttpRequest request)
{
return new ComposableHandler
{
Handshake = (string sub) => Handshake(request, sub)
};
}
public static byte[] Handshake(WebSocketHttpRequest request, string subProtocol)
{
FleckLog.Debug("Building Flash Socket Policy Response");
return Encoding.UTF8.GetBytes(PolicyResponse);
}
}
public static class Hybi13Handler
{
private const string WebSocketResponseGuid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
public static IHandler Create(WebSocketHttpRequest request, Action<string> onMessage, Action onClose, Action<byte[]> onBinary, Action<byte[]> onPing, Action<byte[]> onPong)
{
ReadState readState = new ReadState();
return new ComposableHandler
{
Handshake = (string sub) => BuildHandshake(request, sub),
TextFrame = (string s) => FrameData(Encoding.UTF8.GetBytes(s), FrameType.Text),
BinaryFrame = (byte[] s) => FrameData(s, FrameType.Binary),
PingFrame = (byte[] s) => FrameData(s, FrameType.Ping),
PongFrame = (byte[] s) => FrameData(s, FrameType.Pong),
CloseFrame = (int i) => FrameData(i.ToBigEndianBytes<ushort>(), FrameType.Close),
ReceiveData = delegate(List<byte> d)
{
ReceiveData(d, readState, delegate(FrameType op, byte[] data)
{
ProcessFrame(op, data, onMessage, onClose, onBinary, onPing, onPong);
});
}
};
}
public static byte[] FrameData(byte[] payload, FrameType frameType)
{
MemoryStream memoryStream = new MemoryStream();
byte value = (byte)(frameType + 128);
memoryStream.WriteByte(value);
if (payload.Length > 65535)
{
memoryStream.WriteByte(127);
byte[] array = payload.Length.ToBigEndianBytes<ulong>();
memoryStream.Write(array, 0, array.Length);
}
else if (payload.Length > 125)
{
memoryStream.WriteByte(126);
byte[] array2 = payload.Length.ToBigEndianBytes<ushort>();
memoryStream.Write(array2, 0, array2.Length);
}
else
{
memoryStream.WriteByte((byte)payload.Length);
}
memoryStream.Write(payload, 0, payload.Length);
return memoryStream.ToArray();
}
public static void ReceiveData(List<byte> data, ReadState readState, Action<FrameType, byte[]> processFrame)
{
while (data.Count >= 2)
{
bool flag = (data[0] & 0x80) != 0;
int num = data[0] & 0x70;
FrameType frameType = (FrameType)(data[0] & 0xFu);
bool num2 = (data[1] & 0x80) != 0;
int num3 = data[1] & 0x7F;
if (!num2 || !Enum.IsDefined(typeof(FrameType), frameType) || num != 0 || (frameType == FrameType.Continuation && !readState.FrameType.HasValue))
{
throw new WebSocketException(1002);
}
int num4 = 2;
int num5;
switch (num3)
{
case 127:
if (data.Count < num4 + 8)
{
return;
}
num5 = data.Skip(num4).Take(8).ToArray()
.ToLittleEndianInt();
num4 += 8;
break;
case 126:
if (data.Count < num4 + 2)
{
return;
}
num5 = data.Skip(num4).Take(2).ToArray()
.ToLittleEndianInt();
num4 += 2;
break;
default:
num5 = num3;
break;
}
if (data.Count < num4 + 4)
{
break;
}
byte[] array = data.Skip(num4).Take(4).ToArray();
num4 += 4;
if (data.Count < num4 + num5)
{
break;
}
byte[] array2 = new byte[num5];
for (int i = 0; i < num5; i++)
{
array2[i] = (byte)(data[num4 + i] ^ array[i % 4]);
}
readState.Data.AddRange(array2);
data.RemoveRange(0, num4 + num5);
if (frameType != 0)
{
readState.FrameType = frameType;
}
if (flag && readState.FrameType.HasValue)
{
byte[] arg = readState.Data.ToArray();
FrameType? frameType2 = readState.FrameType;
readState.Clear();
processFrame(frameType2.Value, arg);
}
}
}
public static void ProcessFrame(FrameType frameType, byte[] data, Action<string> onMessage, Action onClose, Action<byte[]> onBinary, Action<byte[]> onPing, Action<byte[]> onPong)
{
switch (frameType)
{
case FrameType.Close:
if (data.Length == 1 || data.Length > 125)
{
throw new WebSocketException(1002);
}
if (data.Length >= 2)
{
ushort num = (ushort)data.Take(2).ToArray().ToLittleEndianInt();
if (!WebSocketStatusCodes.ValidCloseCodes.Contains(num) && (num < 3000 || num > 4999))
{
throw new WebSocketException(1002);
}
}
if (data.Length > 2)
{
ReadUTF8PayloadData(data.Skip(2).ToArray());
}
onClose();
break;
case FrameType.Binary:
onBinary(data);
break;
case FrameType.Ping:
onPing(data);
break;
case FrameType.Pong:
onPong(data);
break;
case FrameType.Text:
onMessage(ReadUTF8PayloadData(data));
break;
default:
FleckLog.Debug("Received unhandled " + frameType);
break;
}
}
public static byte[] BuildHandshake(WebSocketHttpRequest request, string subProtocol)
{
FleckLog.Debug("Building Hybi-14 Response");
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("HTTP/1.1 101 Switching Protocols\r\n");
stringBuilder.Append("Upgrade: websocket\r\n");
stringBuilder.Append("Connection: Upgrade\r\n");
if (subProtocol != null)
{
stringBuilder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", subProtocol);
}
string arg = CreateResponseKey(request["Sec-WebSocket-Key"]);
stringBuilder.AppendFormat("Sec-WebSocket-Accept: {0}\r\n", arg);
stringBuilder.Append("\r\n");
return Encoding.ASCII.GetBytes(stringBuilder.ToString());
}
public static string CreateResponseKey(string requestKey)
{
string s = requestKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
return Convert.ToBase64String(SHA1.Create().ComputeHash(Encoding.ASCII.GetBytes(s)));
}
private static string ReadUTF8PayloadData(byte[] bytes)
{
UTF8Encoding uTF8Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
try
{
return uTF8Encoding.GetString(bytes);
}
catch (ArgumentException)
{
throw new WebSocketException(1007);
}
}
}
}
