public WebSocketListener(IPEndPoint endpoint, WebSocketListenerOptions options)
{
Guard.ParameterCannotBeNull(endpoint, "endpoint");
Guard.ParameterCannotBeNull(options, "options");
options.CheckCoherence();
_options = options.Clone();
_cancel = new CancellationTokenSource();
#if NETSTANDARD || UAP
_listener = new TcpListener(endpoint);
#else
if (Type.GetType("Mono.Runtime") == null && _options.UseDualStackSocket)
_listener = TcpListener.Create(endpoint.Port);
else
_listener = new TcpListener(endpoint);
#endif
if (_options.UseNagleAlgorithm.HasValue)
_listener.Server.NoDelay = !_options.UseNagleAlgorithm.Value;
ConnectionExtensions = new WebSocketConnectionExtensionCollection(this);
Standards = new WebSocketFactoryCollection(this);
_negotiationQueue = new HttpNegotiationQueue(Standards, ConnectionExtensions, options);
}
public void BasicRoundTrip()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(6000, 60000);
var options = new WebSocketListenerOptions();
options.SubProtocols = new[] { "SignalR" };
var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener);
listener.Standards.RegisterStandard(rfc6455);
var serverTransport = listener.GenerateTransportSource();
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService<IMyService>(new MyService());
listener.Start();
var client = new ClientWebSocket();
client.Options.AddSubProtocol("SignalR");
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface<IMyService>();
client.ConnectAsync(new Uri("ws://localhost:" + port + "/"), CancellationToken.None).Wait();
var result = proxy.Add(3, 4).Result;
Assert.Equal(7, result);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public WebSocketHandshaker(WebSocketFactoryCollection factories, WebSocketListenerOptions options)
{
Guard.ParameterCannotBeNull(factories, "factories");
Guard.ParameterCannotBeNull(options, "options");
_factories = factories;
_options = options;
}
public WebSocketEventListener(IPEndPoint endpoint, WebSocketListenerOptions options)
{
_listener = new WebSocketListener(endpoint, options);
var rfc6455 = new WebSocketFactoryRfc6455(_listener);
rfc6455.MessageExtensions.RegisterExtension(new WebSocketDeflateExtension());
_listener.Standards.RegisterStandard(rfc6455);
//TODO ALLOW PEOPLE TO SET THEIR SERTS FOR WSS
//_listener.ConnectionExtensions.RegisterExtension(new WebSocketSecureConnectionExtension(ca2));
}
public WebSocketEventListener(List<IPEndPoint> endpoints, WebSocketListenerOptions options)
{
foreach (var endpoint in endpoints)
{
var listener = new WebSocketListener(endpoint, options);
var rfc6455 = new WebSocketFactoryRfc6455(listener);
listener.Standards.RegisterStandard(rfc6455);
_listeners.Add(listener);
}
}
public WebSocketHandshaker(WebSocketFactoryCollection factories, WebSocketListenerOptions options)
{
if (factories == null)
throw new ArgumentNullException("factories");
if (options == null)
throw new ArgumentNullException("options");
_factories = factories;
_options = options;
}
public WebSocketListener(IPEndPoint endpoint, WebSocketListenerOptions options)
{
Guard.ParameterCannotBeNull(endpoint, "endpoint");
Guard.ParameterCannotBeNull(options, "options");
options.CheckCoherence();
_options = options.Clone();
_cancel = new CancellationTokenSource();
_listener = new TcpListener(endpoint);
if(_options.UseNagleAlgorithm.HasValue)
_listener.Server.NoDelay = !_options.UseNagleAlgorithm.Value;
ConnectionExtensions = new WebSocketConnectionExtensionCollection(this);
Standards = new WebSocketFactoryCollection(this);
_negotiationQueue = new HttpNegotiationQueue(Standards, ConnectionExtensions, options);
}
public WebSocketListener(IPEndPoint endpoint, WebSocketListenerOptions options)
{
if (options == null)
throw new ArgumentNullException("options");
if (endpoint == null)
throw new ArgumentNullException("endpoint");
_options = options.Clone();
_cancel = new CancellationTokenSource();
_listener = new TcpListener(endpoint);
ConnectionExtensions = new WebSocketConnectionExtensionCollection(this);
Standards = new WebSocketFactoryCollection(this);
Func<Socket, Task<WebSocketNegotiationResult>> negotiate = NegotiateWebSocket;
_negotiationQueue = new TransformBlock<Socket, WebSocketNegotiationResult>(negotiate, new ExecutionDataflowBlockOptions() { CancellationToken = _cancel.Token, MaxDegreeOfParallelism = options.ParallelNegotiations, BoundedCapacity = options.NegotiationQueueCapacity });
_handShaker = new WebSocketHandshaker(Standards, _options);
}
public WebSocketListener(IPEndPoint endpoint, WebSocketListenerOptions options)
{
if (options == null)
throw new ArgumentNullException("options");
if (endpoint == null)
throw new ArgumentNullException("endpoint");
options.CheckCoherence();
_options = options.Clone();
_cancel = new CancellationTokenSource();
_listener = new TcpListener(endpoint);
if(_options.UseNagleAlgorithm.HasValue)
_listener.Server.NoDelay = !_options.UseNagleAlgorithm.Value;
ConnectionExtensions = new WebSocketConnectionExtensionCollection(this);
Standards = new WebSocketFactoryCollection(this);
_negotiationQueue = new HttpNegotiationQueue(Standards, ConnectionExtensions, options);
}
public WebSocketListener(Uri[] listenEndPoints, WebSocketListenerOptions options)
{
if (listenEndPoints == null)
{
throw new ArgumentNullException(nameof(listenEndPoints));
}
if (listenEndPoints.Length == 0)
{
throw new ArgumentException("At least one prefix should be specified.", nameof(listenEndPoints));
}
if (listenEndPoints.Any(p => p == null))
{
throw new ArgumentException("Null objects passed in array.", nameof(listenEndPoints));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
options.CheckCoherence();
this.options = options.Clone();
if (this.options.BufferManager == null)
{
this.options.BufferManager = BufferManager.CreateBufferManager(100, this.options.SendBufferSize); // create small buffer pool if not configured
}
if (this.options.Logger == null)
{
this.options.Logger = NullLogger.Instance;
}
this.log = this.options.Logger;
this.listeners = EmptyListeners;
this.localEndPoints = EmptyEndPoints;
this.listenEndPoints = listenEndPoints;
this.negotiationQueue = new HttpNegotiationQueue(options.Standards, options.ConnectionExtensions, this.options);
}
public void BasicRoundTrip()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(6000, 60000);
var options = new WebSocketListenerOptions();
options.SubProtocols = new[] { "SignalR" };
var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener);
listener.Standards.RegisterStandard(rfc6455);
var serverTransport = listener.GenerateTransportSource();
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService<IMyService>(new MyService());
listener.Start();
var client = new WebSocket("ws://localhost:" + port + "/", "SignalR", WebSocket4Net.WebSocketVersion.Rfc6455);
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface<IMyService>();
client.Open();
while (client.State != WebSocket4Net.WebSocketState.Open)
Thread.Sleep(10);
var result = proxy.Add(3, 4).Result;
Assert.Equal(7, result);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public void Benchmark()
{
var serializer = new JsonCommonSerializer();
var port = new Random().Next(6000, 60000);
var options = new WebSocketListenerOptions();
options.SubProtocols = new[] { "SignalR" };
var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options);
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener);
listener.Standards.RegisterStandard(rfc6455);
var serverTransport = listener.GenerateTransportSource();
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService<ISumService>(new SumService());
listener.Start();
var client = new WebSocket("ws://localhost:" + port + "/", "SignalR", WebSocket4Net.WebSocketVersion.Rfc6455);
var clientTransport = client.GenerateTransportSource();
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface<ISumService>();
client.Open();
while (client.State != WebSocket4Net.WebSocketState.Open)
Thread.Sleep(10);
const int randCnt = 100;
var rand = new Random(42);
var randoms = new int[randCnt];
for (int i = 0; i < randCnt; i++) randoms[i] = rand.Next(10000000, 20000000);
var sw = new Stopwatch();
long timeFromClient = 0, timeToClient = 0;
const int cnt = 1000;
for (int j = 0; j < cnt; j++)
{
sw.Start();
var sum = proxy.Sum(randoms).Result;
sw.Stop();
Assert.Equal(randoms.Sum(), sum);
for (int i = 0; i < randCnt; i++) randoms[i] = rand.Next(10000000, 20000000);
var times = proxy.TimeDiff(Stopwatch.GetTimestamp()).Result;
timeFromClient += times.Item1;
timeToClient += Stopwatch.GetTimestamp() - times.Item2;
}
_testOutputHelper.WriteLine("Completed {0} sum passes in {1}ms", cnt, sw.ElapsedMilliseconds);
_testOutputHelper.WriteLine("Client to server latency: {0}us", timeFromClient / cnt / 10);
_testOutputHelper.WriteLine("Server to client latency: {0}us", timeToClient / cnt / 10);
//sw.Reset();
//var tree = new SumServiceTree();
//SumServiceTree.FillTree(tree, rand, 2);
//_testOutputHelper.WriteLine("Starting large message transfer.");
//sw.Start();
//var result = proxy.Increment(tree).Result;
//sw.Stop();
//Assert.Equal(tree.Leaf + 1, result.Leaf);
//_testOutputHelper.WriteLine("Completed large transfer in {0}ms", sw.Elapsed.TotalMilliseconds);
clientRouter.Dispose();
clientTransport.Dispose();
client.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
listener.Dispose();
}
public abstract WebSocket CreateWebSocket(Stream stream, WebSocketListenerOptions options, IPEndPoint localEndpoint, IPEndPoint remoteEndpoint, WebSocketHttpRequest httpRequest, WebSocketHttpResponse httpResponse, List<IWebSocketMessageExtensionContext> negotiatedExtensions);
public WebSocketListener(IPEndPoint endpoint, WebSocketListenerOptions options)
: this(new[] { new Uri("tcp://" + endpoint) }, options)
{
}
public abstract WebSocket CreateWebSocket(Stream stream, Socket client, WebSocketListenerOptions options, WebSocketHandshake handshake);
public void Open()
{
IPAddress ipAddress = IPAddress.Any;
if (_endPointUri.IsLoopback)
{
ipAddress = IPAddress.Loopback;
}
else if (!"0.0.0.0".Equals(_endPointUri.DnsSafeHost))
{
ipAddress = IOUtil.GetIPAddress(_endPointUri.DnsSafeHost);
}
var options = new WebSocketListenerOptions()
{
NegotiationQueueCapacity = 128,
ParallelNegotiations = 16,
PingTimeout = Timeout.InfiniteTimeSpan,
SubProtocols = new[] {"v1.openicf.forgerock.org"},
OnHttpNegotiation = (request, response) =>
{
var authHeader = request.Headers["Authorization"];
if (authHeader != null)
{
var authHeaderVal = AuthenticationHeaderValue.Parse(authHeader);
// RFC 2617 sec 1.2, "scheme" name is case-insensitive
if (authHeaderVal.Scheme.Equals("basic",
StringComparison.OrdinalIgnoreCase) &&
authHeaderVal.Parameter != null)
{
var encoding = Encoding.GetEncoding("iso-8859-1");
var credentials = encoding.GetString(Convert.FromBase64String(authHeaderVal.Parameter));
int separator = credentials.IndexOf(':');
if (separator != -1)
{
string name = credentials.Substring(0, separator);
string password = credentials.Substring(separator + 1);
var pair = _validator.FindPrincipal(name);
if (null != pair)
{
if (ClientAuthenticationValidator.Verify(pair.Second, password))
{
request.Items["ConnectionPrincipal"] = pair.First;
}
else
{
Trace.TraceWarning("Incorrect password - username: {0}", name);
response.Status = HttpStatusCode.Forbidden;
}
}
else
{
Trace.TraceWarning("Unknown username: {0}", name);
response.Status = HttpStatusCode.Forbidden;
}
}
else
{
Trace.TraceWarning("Invalid Basic Authorization : {0}", credentials);
response.Status = HttpStatusCode.BadRequest;
}
}
else
{
Trace.TraceWarning("Basic Authorization header expected but found{0}", authHeader);
response.Status = HttpStatusCode.BadRequest;
}
}
else
{
//401 + Realm
response.Status = HttpStatusCode.Unauthorized;
}
}
};
_listener = new WebSocketListener(new IPEndPoint(ipAddress, _endPointUri.Port), options);
bool useSsl = String.Equals("https", _endPointUri.Scheme, StringComparison.OrdinalIgnoreCase) ||
String.Equals("wss", _endPointUri.Scheme, StringComparison.OrdinalIgnoreCase);
if (useSsl)
{
_listener.ConnectionExtensions.RegisterExtension(
new WebSocketSecureConnectionExtension(GetCertificate()));
}
var rfc6455 = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(_listener);
_listener.Standards.RegisterStandard(rfc6455);
_listener.Start();
Task.Run((Func<Task>) ListenAsync);
}
public abstract WebSocket CreateWebSocket(Stream stream, WebSocketListenerOptions options, IPEndPoint localEndpoint, IPEndPoint remoteEndpoint, WebSocketHttpRequest httpRequest, WebSocketHttpResponse httpResponse, List <IWebSocketMessageExtensionContext> negotiatedExtensions);
public WebSocketEventListener(IPEndPoint endpoint, WebSocketListenerOptions options)
{
_listener = new WebSocketListener(endpoint, options);
_listener.Standards.RegisterStandard(new WebSocketFactoryRfc6455(_listener));
}
public override WebSocket CreateWebSocket(Stream stream, Socket client, WebSocketListenerOptions options, WebSocketHandshake handshake)
{
return(new WebSocketRfc6455(stream, options, (IPEndPoint)client.LocalEndPoint, (IPEndPoint)client.RemoteEndPoint, handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions));
}
public abstract WebSocket CreateWebSocket(NetworkConnection networkConnection, WebSocketListenerOptions options, WebSocketHttpRequest httpRequest, WebSocketHttpResponse httpResponse, List <IWebSocketMessageExtensionContext> negotiatedExtensions);
