/// <summary>
/// Creates the socket used to listen for incoming connections
/// </summary>
protected override UvStreamHandle CreateListenSocket()
{
var socket = new UvTcpHandle(Log);
socket.Init(Thread.Loop, Thread.QueueCloseHandle);
socket.NoDelay(NoDelay);
socket.Bind(ServerAddress);
socket.Listen(Constants.ListenBacklog, (stream, status, error, state) => ConnectionCallback(stream, status, error, state), this);
return(socket);
}
private void Listen()
{
// TODO: Error handling
_listenSocket = new UvTcpHandle();
_listenSocket.Init(_thread.Loop, null);
_listenSocket.NoDelay(true);
_listenSocket.Bind(_endpoint);
_listenSocket.Listen(10, _onConnectionCallback, this);
// Don't complete the task on the UV thread
Task.Run(() => _startedTcs.TrySetResult(null));
}
private void Listen()
{
// TODO: Error handling
_listenSocket = new UvTcpHandle();
_listenSocket.Init(_thread.Loop, null);
_listenSocket.NoDelay(true);
_listenSocket.Bind(_endpoint);
_listenSocket.Listen(10, _onConnectionCallback, this);
// Don't complete the task on the UV thread
Task.Run(() => _startedTcs.TrySetResult(null));
}
/// <summary>
/// Creates the socket used to listen for incoming connections
/// </summary>
protected override UvStreamHandle CreateListenSocket()
{
var socket = new UvTcpHandle(Log);
socket.Init(Thread.Loop, Thread.QueueCloseHandle);
socket.NoDelay(ServerOptions.NoDelay);
socket.Bind(ServerAddress);
// If requested port was "0", replace with assigned dynamic port.
ServerAddress.Port = socket.GetSockIPEndPoint().Port;
socket.Listen(Constants.ListenBacklog, (stream, status, error, state) => ConnectionCallback(stream, status, error, state), this);
return(socket);
}
private UvTcpHandle AcceptTcp()
{
var socket = new UvTcpHandle(TransportContext.Log);
try
{
socket.Init(Thread.Loop, Thread.QueueCloseHandle);
socket.NoDelay(EndPointInformation.NoDelay);
}
catch
{
socket.Dispose();
throw;
}
return(socket);
}
/// <summary>
/// Handle an incoming connection
/// </summary>
/// <param name="listenSocket">Socket being used to listen on</param>
/// <param name="status">Connection status</param>
protected override void OnConnection(UvStreamHandle listenSocket, int status)
{
var acceptSocket = new UvTcpHandle(Log);
try
{
acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle);
acceptSocket.NoDelay(ServerOptions.NoDelay);
listenSocket.Accept(acceptSocket);
DispatchConnection(acceptSocket);
}
catch (UvException ex)
{
Log.LogError(0, ex, "TcpListener.OnConnection");
acceptSocket.Dispose();
}
}
/// <summary>
/// Handles an incoming connection
/// </summary>
/// <param name="listenSocket">Socket being used to listen on</param>
/// <param name="status">Connection status</param>
protected override void OnConnection(UvStreamHandle listenSocket, int status)
{
var acceptSocket = new UvTcpHandle(Log);
acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle);
acceptSocket.NoDelay(NoDelay);
try
{
listenSocket.Accept(acceptSocket);
}
catch (UvException ex)
{
Log.LogError("TcpListenerPrimary.OnConnection", ex);
return;
}
DispatchConnection(acceptSocket);
}
private UvTcpHandle AcceptTcp()
{
var socket = new UvTcpHandle(TransportContext.Log);
try
{
socket.Init(Thread.Loop, Thread.QueueCloseHandle);
#pragma warning disable CS0618
socket.NoDelay(TransportContext.Options.NoDelay);
#pragma warning restore CS0618
}
catch
{
socket.Dispose();
throw;
}
return(socket);
}
/// <summary>
/// Handle an incoming connection
/// </summary>
/// <param name="listenSocket">Socket being used to listen on</param>
/// <param name="status">Connection status</param>
protected override void OnConnection(UvStreamHandle listenSocket, int status)
{
var acceptSocket = new UvTcpHandle();
try
{
acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle);
acceptSocket.NoDelay(true);
acceptSocket.KeepAlive(true);
listenSocket.Accept(acceptSocket);
DispatchConnection(acceptSocket);
}
catch (UvException)
{
//Service.Logger.Log(ex);
acceptSocket.Dispose();
return;
}
}
private static void OnConnectionCallback(UvStreamHandle listenSocket, int status, Exception error, object state)
{
var listener = (UvTcpListener)state;
var acceptSocket = new UvTcpHandle();
try
{
acceptSocket.Init(listener._thread.Loop, null);
acceptSocket.NoDelay(true);
listenSocket.Accept(acceptSocket);
var connection = new UvTcpConnection(listener._thread, acceptSocket);
ExecuteCallback(listener, connection);
}
catch (UvException)
{
acceptSocket.Dispose();
}
}
private void RunLoop()
{
Uv = new Uv();
Loop = new UvLoopHandle();
Loop.Init(Uv);
_shutdownPostHandle = new UvAsyncHandle();
_shutdownPostHandle.Init(Loop, OnPost, _queueCloseCallback);
_listenSocket = new UvTcpHandle();
_listenSocket.Init(Loop, _queueCloseCallback);
_listenSocket.NoDelay(true);
_listenSocket.Bind(new IPEndPoint(_ip, _port));
_listenSocket.Listen(10, _onConnectionCallback, this);
Uv.run(Loop, 0);
}
private static void OnConnectionCallback(UvStreamHandle listenSocket, int status, Exception error, object state)
{
var listener = (UvTcpListener)state;
var acceptSocket = new UvTcpHandle();
try
{
acceptSocket.Init(listener._thread.Loop, null);
acceptSocket.NoDelay(true);
listenSocket.Accept(acceptSocket);
var connection = new UvTcpConnection(listener._thread, acceptSocket);
ExecuteCallback(listener, connection);
}
catch (UvException)
{
acceptSocket.Dispose();
}
}
private static void OnConnectionCallback(UvStreamHandle listenSocket, int status, Exception error, object state)
{
var listener = (UvTcpListener)state;
var acceptSocket = new UvTcpHandle();
try
{
acceptSocket.Init(listener._thread.Loop, UvThread._queueCloseCallback);
acceptSocket.NoDelay(true);
listenSocket.Accept(acceptSocket);
var connection = new UvTcpServerConnection(listener._thread, acceptSocket);
listener._callback?.Invoke(connection);
}
catch (UvException)
{
acceptSocket.Dispose();
}
}
private static void OnConnectionCallback(UvStreamHandle listenSocket, int status, Exception error, object state)
{
var listener = (UvTcpListener)state;
var acceptSocket = new UvTcpHandle(listener.Log);
try
{
acceptSocket.Init(listener.Loop, _queueCloseCallback);
acceptSocket.NoDelay(true);
listenSocket.Accept(acceptSocket);
var connection = new UvTcpConnection(listener, acceptSocket);
listener._callback?.Invoke(connection);
}
catch (UvException ex)
{
listener.Log.LogError(0, ex, "UvTcpListener.OnConnection");
acceptSocket.Dispose();
}
}
private void RunLoop()
{
Uv = new Uv();
Loop = new UvLoopHandle();
Loop.Init(Uv);
_shutdownPostHandle = new UvAsyncHandle();
_shutdownPostHandle.Init(Loop, OnPost, _queueCloseCallback);
_connectSocket = new UvTcpHandle();
_connectSocket.Init(Loop, _queueCloseCallback);
_connectSocket.NoDelay(true);
var connectReq = new UvConnectRequest();
connectReq.Init(Loop);
connectReq.Connect(_connectSocket, new IPEndPoint(_ip, _port), OnConnection, this);
Uv.run(Loop, 0);
}
/// <summary>
/// Creates the socket used to listen for incoming connections
/// </summary>
protected override UvStreamHandle CreateListenSocket()
{
var socket = new UvTcpHandle(Log);
try
{
socket.Init(Thread.Loop, Thread.QueueCloseHandle);
socket.NoDelay(ServerOptions.NoDelay);
socket.Bind(ServerAddress);
// If requested port was "0", replace with assigned dynamic port.
ServerAddress.Port = socket.GetSockIPEndPoint().Port;
}
catch
{
socket.Dispose();
throw;
}
return(socket);
}
private void RunLoop()
{
Uv = new Libuv();
Log = new KestrelTrace(new LoggerFactory().CreateLogger <UvTcpListener>());
Loop = new UvLoopHandle(Log);
Loop.Init(Uv);
_shutdownPostHandle = new UvAsyncHandle(Log);
_shutdownPostHandle.Init(Loop, OnPost, _queueCloseCallback);
_listenSocket = new UvTcpHandle(Log);
_listenSocket.Init(Loop, _queueCloseCallback);
_listenSocket.NoDelay(true);
string host = null;
if (_ip == IPAddress.Any)
{
host = "*";
}
else if (_ip == IPAddress.Loopback)
{
host = "localhost";
}
else
{
host = _ip.ToString();
}
var url = $"http://{host}:{_port}";
var address = Microsoft.AspNetCore.Server.Kestrel.ServerAddress.FromUrl(url);
_listenSocket.Bind(address);
_listenSocket.Listen(10, _onConnectionCallback, this);
Uv.run(Loop, 0);
}
/// <summary>
/// Creates a connection for a remote endpoint.
/// </summary>
/// <param name="context">The listener context to use.</param>
/// <param name="remote">The endpoint to connect to.</param>
public static Task <Connection> ConnectAsync(ListenerContext context, IPEndPoint remote)
{
var tcs = new TaskCompletionSource <Connection>();
context.Thread.PostAsync((state) =>
{
var socket = new UvTcpHandle();
try
{
socket.Init(context.Thread.Loop, context.Thread.QueueCloseHandle);
socket.NoDelay(true);
socket.Connect(context.Thread.Loop, ServiceAddress.FromIPEndPoint(remote), (request, status, ex, sender) =>
{
request.Dispose();
if (ex != null)
{
// Error has occured, set the exception
socket.Dispose();
tcs.SetException(ex);
return;
}
// Create the connection and notify
var connection = new Connection(context, socket);
tcs.SetResult(connection.Start() ? connection : null);
}, tcs);
}
catch (UvException ex)
{
//Service.Logger.Log(ex);
socket.Dispose();
tcs.SetException(ex);
}
}, tcs);
return(tcs.Task);
}