private void Connect_Completed(Socket socket1, ServerAsyncEventArgs e)
{
bool flag = false;
Server <C> .Connection <C> connection = null;
if (e.SocketError == SocketError.Success)
{
connection = this.CreateConnection(socket1, e.SocketError);
flag = (connection != null);
}
else
{
while (e.SocketError == SocketError.AddressAlreadyInUse && !this.connections.TryGetValue(e.RemoteEndPoint, out connection))
{
Thread.Sleep(0);
if (socket1.ConnectAsync(e))
{
return;
}
if (e.SocketError == SocketError.Success)
{
connection = this.CreateConnection(socket1, e.SocketError);
flag = (connection != null);
}
}
}
if (e.SocketError == SocketError.Success && flag)
{
this.NewTcpConnection(connection);
}
e.Completed = new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed);
e.OnCompleted(socket1);
}
public static void AcceptAsync(this Socket socket, ServerAsyncEventArgs e, ServerAsyncEventArgs.CompletedEventHandler handler)
{
e.Completed = handler;
if (!socket.AcceptAsync(e))
{
e.OnCompleted(socket);
}
}
public static void ConnectAsync(this Socket socket, ServerAsyncEventArgs e, ServerAsyncEventArgs.CompletedEventHandler handler)
{
e.Completed = handler;
if (socket.ConnectAsync(e) == false)
{
e.OnCompleted(socket);
}
}
protected void SendAsync(Connection <C> connection, ServerAsyncEventArgs e)
{
if (connection == null)
{
if (e.ConnectionId == ServerAsyncEventArgs.AnyNewConnectionId)
{
try
{
Socket socket = new Socket(realEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
socket.Bind(realEndPoint);
socket.ConnectAsync(e, Connect_Completed);
}
catch (SocketException ex)
{
e.Completed = Send_Completed;
e.SocketError = ex.SocketErrorCode;
e.OnCompleted(null);
}
}
else
{
e.Completed = Send_Completed;
e.SocketError = SocketError.NotConnected;
e.OnCompleted(null);
}
}
else
{
if (e.ConnectionId == ServerAsyncEventArgs.AnyNewConnectionId ||
e.ConnectionId == ServerAsyncEventArgs.AnyConnectionId ||
e.ConnectionId == connection.Id)
{
connection.Socket.SendAsync(e, Send_Completed);
}
else
{
e.Completed = Send_Completed;
e.SocketError = SocketError.NotConnected;
e.OnCompleted(null);
}
}
}
public override void SendAsync(ServerAsyncEventArgs e)
{
base.OnBeforeSend(null, e);
e.Completed = new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed);
if (!this.socket.SendToAsync(e))
{
e.OnCompleted(this.socket);
}
}
public override void SendAsync(ServerAsyncEventArgs e)
{
OnBeforeSend(null, e);
e.Completed = Send_Completed;
if (socket.SendToAsync(e) == false)
{
e.OnCompleted(socket);
}
}
protected void SendAsync(Server <C> .Connection <C> connection, ServerAsyncEventArgs e)
{
if (connection == null)
{
if (e.ConnectionId == -1)
{
try
{
Socket socket = new Socket(this.realEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
socket.Bind(this.realEndPoint);
socket.ConnectAsync(e, new ServerAsyncEventArgs.CompletedEventHandler(this.Connect_Completed));
return;
}
catch (SocketException ex)
{
e.Completed = new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed);
e.SocketError = ex.SocketErrorCode;
e.OnCompleted(null);
return;
}
}
e.Completed = new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed);
e.SocketError = SocketError.NotConnected;
e.OnCompleted(null);
return;
}
if (e.ConnectionId == -1 || e.ConnectionId == -2 || e.ConnectionId == connection.Id)
{
connection.Socket.SendAsync(e, new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed));
return;
}
e.Completed = new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed);
e.SocketError = SocketError.NotConnected;
e.OnCompleted(null);
}
private void Connect_Completed(Socket socket1, ServerAsyncEventArgs e)
{
bool newConnection = false;
Connection <C> connection = null;
if (e.SocketError == SocketError.Success)
{
connection = CreateConnection(socket1, e.SocketError);
newConnection = connection != null;
}
else
{
while (e.SocketError == SocketError.AddressAlreadyInUse)
{
if (connections.TryGetValue(e.RemoteEndPoint, out connection))
{
break;
}
Thread.Sleep(0);
if (socket1.ConnectAsync(e))
{
return;
}
else
{
if (e.SocketError == SocketError.Success)
{
connection = CreateConnection(socket1, e.SocketError);
newConnection = connection != null;
}
}
}
}
if (e.SocketError == SocketError.Success)
{
if (newConnection)
{
NewTcpConnection(connection);
}
}
e.Completed = Send_Completed;
e.OnCompleted(socket1);
}
private void EndTcpConnection(Server <C> .Connection <C> connection)
{
if (connection.Close())
{
this.OnEndTcpConnection(connection);
if (connection.Socket.Connected)
{
try
{
connection.Socket.Shutdown(SocketShutdown.Both);
}
catch (SocketException)
{
}
}
if (connection.IsSocketAccepted && this.socketReuseEnabled)
{
try
{
try
{
ServerAsyncEventArgs serverAsyncEventArgs = EventArgsManager.Get();
serverAsyncEventArgs.FreeBuffer();
serverAsyncEventArgs.DisconnectReuseSocket = true;
serverAsyncEventArgs.Completed = new ServerAsyncEventArgs.CompletedEventHandler(this.Disconnect_Completed);
if (!connection.Socket.DisconnectAsync(serverAsyncEventArgs))
{
serverAsyncEventArgs.OnCompleted(connection.Socket);
}
}
catch (SocketException)
{
}
}
catch (NotSupportedException)
{
this.socketReuseEnabled = false;
}
}
if (!this.socketReuseEnabled)
{
connection.Socket.Close();
}
}
}
private void EnqueueBuffers(object stateInfo)
{
int num = (int)stateInfo;
lock (this.sync)
{
if (this.socket != null)
{
int num2 = 0;
while (num2 < num && this.isRunning)
{
ServerAsyncEventArgs serverAsyncEventArgs = EventArgsManager.Get();
this.PrepareBuffer(serverAsyncEventArgs);
if (!this.socket.ReceiveFromAsync(serverAsyncEventArgs))
{
serverAsyncEventArgs.OnCompleted(this.socket);
}
num2++;
}
}
}
}
public static void SendAsync(this Socket socket, ServerAsyncEventArgs e, ServerAsyncEventArgs.CompletedEventHandler handler)
{
e.Completed = handler;
if (socket.SendAsync(e) == false)
e.OnCompleted(socket);
}
public override void SendAsync(ServerAsyncEventArgs e)
{
try
{
Server <C> .Connection <C> tcpConnection = base.GetTcpConnection(e.RemoteEndPoint);
base.OnBeforeSend(tcpConnection, e);
if (tcpConnection == null)
{
e.Completed = new ServerAsyncEventArgs.CompletedEventHandler(base.Send_Completed);
e.SocketError = SocketError.NotConnected;
e.OnCompleted(null);
}
else
{
SspiContext sspiContext = tcpConnection.SspiContext;
SecPkgContext_StreamSizes streamSizes = sspiContext.StreamSizes;
int count = e.Count;
if (e.OffsetOffset < streamSizes.cbHeader)
{
throw new NotImplementedException("Ineffective way not implemented. Need to move buffer for SECBUFFER_STREAM_HEADER.");
}
e.OffsetOffset -= streamSizes.cbHeader;
e.Count = streamSizes.cbHeader + count + streamSizes.cbTrailer;
e.ReAllocateBuffer(true);
SecBufferDescEx secBufferDescEx = new SecBufferDescEx(new SecBufferEx[]
{
new SecBufferEx
{
BufferType = BufferType.SECBUFFER_STREAM_HEADER,
Buffer = e.Buffer,
Size = streamSizes.cbHeader,
Offset = e.Offset
},
new SecBufferEx
{
BufferType = BufferType.SECBUFFER_DATA,
Buffer = e.Buffer,
Size = count,
Offset = e.Offset + streamSizes.cbHeader
},
new SecBufferEx
{
BufferType = BufferType.SECBUFFER_STREAM_TRAILER,
Buffer = e.Buffer,
Size = streamSizes.cbTrailer,
Offset = e.Offset + streamSizes.cbHeader + count
},
new SecBufferEx
{
BufferType = BufferType.SECBUFFER_VERSION
}
});
Sspi.EncryptMessage(ref sspiContext.Handle, ref secBufferDescEx, 0u, null);
e.Count = secBufferDescEx.Buffers[0].Size + secBufferDescEx.Buffers[1].Size + secBufferDescEx.Buffers[2].Size;
e.ReAllocateBuffer(true);
base.SendAsync(tcpConnection, e);
}
}
catch (SspiException error)
{
e.SocketError = SocketError.Fault;
this.OnFailed(new ServerInfoEventArgs(this.realEndPoint, error));
}
}
public override unsafe void SendAsync(ServerAsyncEventArgs e)
{
try
{
var connection = GetTcpConnection(e.RemoteEndPoint);
OnBeforeSend(connection, e);
if (connection == null)
{
e.Completed = Send_Completed;
e.SocketError = SocketError.NotConnected;
e.OnCompleted(null);
return;
}
var context = connection.SspiContext;
var sizes = context.StreamSizes;
var dataCount = e.Count;
if (e.OffsetOffset >= sizes.cbHeader)
{
e.OffsetOffset -= sizes.cbHeader;
e.Count = sizes.cbHeader + dataCount + sizes.cbTrailer;
e.ReAllocateBuffer(true);
}
else
{
throw new NotImplementedException("Ineffective way not implemented. Need to move buffer for SECBUFFER_STREAM_HEADER.");
}
var message = new SecBufferDescEx(
new SecBufferEx[]
{
new SecBufferEx()
{
BufferType = BufferType.SECBUFFER_STREAM_HEADER, Buffer = e.Buffer, Size = sizes.cbHeader, Offset = e.Offset,
},
new SecBufferEx()
{
BufferType = BufferType.SECBUFFER_DATA, Buffer = e.Buffer, Size = dataCount, Offset = e.Offset + sizes.cbHeader,
},
new SecBufferEx()
{
BufferType = BufferType.SECBUFFER_STREAM_TRAILER, Buffer = e.Buffer, Size = sizes.cbTrailer, Offset = e.Offset + sizes.cbHeader + dataCount,
},
new SecBufferEx()
{
BufferType = BufferType.SECBUFFER_EMPTY,
},
});
Sspi.EncryptMessage(
ref context.Handle,
ref message,
0,
null);
e.Count = message.Buffers[0].Size + message.Buffers[1].Size + message.Buffers[2].Size;
e.ReAllocateBuffer(true);
base.SendAsync(connection, e);
}
catch (SspiException ex)
{
e.SocketError = SocketError.Fault;
OnFailed(new ServerInfoEventArgs(realEndPoint, ex));
}
}
