/// <summary>
/// 接收并处理请求
/// </summary>
/// <param name="serverHandle"></param>
/// <param name="status"></param>
/// <param name="error"></param>
/// <param name="state"></param>
private void Accept(UvStreamHandle serverHandle, int status, Exception error, object state)
{
if (error != null || status != 0)
{
return;
}
ListenHandle listenHandle = new ListenHandle();
listenHandle.Init(_loopHandle, new Action <Action <object>, object>(AsyncSendUserPostAction));
listenHandle.TcpNodealy(true);
serverHandle.Accept(listenHandle);
OwinSocket owinSocket = null;
try
{
owinSocket = new OwinSocket(listenHandle, new Action <Action <object>, object>(AsyncSendUserPostAction));
_owinHttpProcess(owinSocket);
}
catch (Exception)
{
if (owinSocket != null)
{
owinSocket.Dispose();
}
else
{
listenHandle.Close();
}
}
}
private void OnListenPipe(UvStreamHandle pipe, int status, UvException error)
{
if (status < 0)
{
return;
}
var dispatchPipe = new UvPipeHandle(Log);
// Add to the list of created pipes for disposal tracking
_createdPipes.Add(dispatchPipe);
try
{
dispatchPipe.Init(Thread.Loop, Thread.QueueCloseHandle, true);
pipe.Accept(dispatchPipe);
// Ensure client sends _pipeMessage before adding pipe to _dispatchPipes.
var readContext = new PipeReadContext(this);
dispatchPipe.ReadStart(
(handle, status2, state) => ((PipeReadContext)state).AllocCallback(handle, status2),
(handle, status2, state) => ((PipeReadContext)state).ReadCallback(handle, status2),
readContext);
}
catch (UvException ex)
{
dispatchPipe.Dispose();
Log.LogError(0, ex, "ListenerPrimary.OnListenPipe");
}
}
private void OnConnection(UvStreamHandle listenSocket, int status)
{
var acceptSocket = new UvTcpHandle();
acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle);
listenSocket.Accept(acceptSocket);
var connection = new Connection(this, acceptSocket);
connection.Start();
}
/// <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 UvPipeHandle(Log);
try
{
acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle, false);
listenSocket.Accept(acceptSocket);
DispatchConnection(acceptSocket);
}
catch (UvException ex)
{
Log.LogError(0, ex, "PipeListener.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>
private void OnConnection(UvStreamHandle listenSocket, int status)
{
UvStreamHandle acceptSocket = null;
try
{
acceptSocket = CreateAcceptSocket();
listenSocket.Accept(acceptSocket);
DispatchConnection(acceptSocket);
}
catch (UvException ex)
{
Log.LogError(0, ex, "Listener.OnConnection");
acceptSocket?.Dispose();
}
}
/// <summary>
/// 新连接回调事件
/// </summary>
/// <param name="serverHandle"></param>
/// <param name="status"></param>
/// <param name="error"></param>
/// <param name="state"></param>
private void OnNewConnectionCallback(UvStreamHandle serverHandle, int status, Exception error, object state)
{
if (error != null || status != 0)
{
return;
}
ListenHandle clientHandle = new ListenHandle();
clientHandle.Init(_loopHandle, new Action <Action <object>, object>(AsyncSendUserPostAction));
clientHandle.TcpNodealy(true);
serverHandle.Accept(clientHandle);
//int.MaxValue=2147483647
_connectCount++;
if (_connectCount > 2147483547)
{
_connectCount = 1;
}
int num2 = _connectCount % (_pipeHandleList.Count + 1);
if (num2 != _pipeHandleList.Count)
{
WriteHandleFree(clientHandle, num2);
return;
}
OwinSocket owinSocket = null;
try
{
owinSocket = new OwinSocket(clientHandle, new Action <Action <object>, object>(AsyncSendUserPostAction));
//主流程开始执行
_owinHttpProcess(owinSocket);
}
catch (Exception)
{
if (owinSocket != null)
{
owinSocket.Dispose();
}
else
{
clientHandle.Close();
}
}
}
/// <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 UvPipeHandle(Log);
try
{
acceptSocket.Init(Thread.Loop, false);
listenSocket.Accept(acceptSocket);
DispatchConnection(acceptSocket);
}
catch (UvException ex)
{
Log.LogError("ListenerPrimary.OnConnection", ex);
acceptSocket.Dispose();
return;
}
}
/// <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);
try
{
acceptSocket.Init(Thread.Loop, Thread.QueueCloseHandle);
acceptSocket.NoDelay(ServerOptions.NoDelay);
listenSocket.Accept(acceptSocket);
DispatchConnection(acceptSocket);
}
catch (UvException ex)
{
Log.LogError(0, ex, "TcpListenerPrimary.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);
try
{
listenSocket.Accept(acceptSocket);
}
catch (UvException ex)
{
Log.LogError("TcpListenerPrimary.OnConnection", ex);
return;
}
DispatchConnection(acceptSocket);
}
/// <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 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();
}
}
/// <summary>
/// Handles an incoming connection
/// </summary>
/// <param name="listenSocket">Socket being used to listen on</param>
/// <param name="status">Connection status</param>
private void OnConnection(UvStreamHandle listenSocket, int status)
{
UvStreamHandle acceptSocket = null;
try
{
acceptSocket = CreateAcceptSocket();
listenSocket.Accept(acceptSocket);
DispatchConnection(acceptSocket);
}
catch (UvException ex) when(LibuvConstants.IsConnectionReset(ex.StatusCode))
{
Log.ConnectionReset("(null)");
acceptSocket?.Dispose();
}
catch (UvException ex)
{
Log.LogError(0, ex, "Listener.OnConnection");
acceptSocket?.Dispose();
}
}
/// <summary>
/// 管道连接
/// </summary>
/// <param name="uvStreamHandle"></param>
/// <param name="num"></param>
/// <param name="ex"></param>
/// <param name="obj"></param>
private unsafe void PipeConnectionCallBack(UvStreamHandle uvStreamHandle, int num, Exception ex, object obj)
{
if (num < 0)
{
return;
}
UvPipeHandle uvPipeHandle = new UvPipeHandle();
uvPipeHandle.Init(_loopHandle, true);
try
{
uvStreamHandle.Accept(uvPipeHandle);
}
catch (Exception)
{
uvPipeHandle.Dispose();
return;
}
if (_uvPipeHandleOffset > 0) // 是windows系统
{
*(int *)((void *)(uvPipeHandle.InternalGetHandle() + _uvPipeHandleOffset)) = _currentProcessId;
}
_pipeHandleList.Add(uvPipeHandle);
}
private void OnListenPipe(UvStreamHandle pipe, int status, Exception error)
{
if (status < 0)
{
return;
}
var dispatchPipe = new UvPipeHandle();
dispatchPipe.Init(Thread.Loop, Thread.QueueCloseHandle, true);
try
{
pipe.Accept(dispatchPipe);
}
catch (UvException ex)
{
dispatchPipe.Dispose();
Service.Logger.Log(ex);
return;
}
_dispatchPipes.Add(dispatchPipe);
}
private void OnListenPipe(UvStreamHandle pipe, int status, Exception error)
{
if (status < 0)
{
return;
}
var dispatchPipe = new UvPipeHandle(Log);
dispatchPipe.Init(Thread.Loop, Thread.QueueCloseHandle, true);
try
{
pipe.Accept(dispatchPipe);
}
catch (UvException ex)
{
dispatchPipe.Dispose();
Log.LogError(0, ex, "ListenerPrimary.OnListenPipe");
return;
}
_dispatchPipes.Add(dispatchPipe);
}
public void Accept(UvStreamHandle streamHandle)
{
streamHandle.Accept(UvTcpHandle);
}
