private void ProcessReceive(SocketAsyncEventArgs e)
{
if (e.BytesTransferred <= 0 || e.SocketError != SocketError.Success)
{
CloseClientSocket(e);
}
else
{
IPCClient IPCClient = e.UserToken as IPCClient;
if (IPCClient == null)
{
CloseClientSocket(e);
}
else
{
IPCClient.ProcessReceive(e.Buffer, e.Offset, e.BytesTransferred);
if (IPCClient.Socket == null)
{
CloseClientSocket(e);
}
else
{
if (!IPCClient.Socket.ReceiveAsync(e))
{
ProcessReceive(e);
}
}
}
}
}
public IPCOperations(IPCClient ipcClient)
{
Client = ipcClient;
InitializeHandlers();
InitializeDatabase();
}
private void NotifyClientDisconnected(IPCClient client)
{
Action <IPCHost, IPCClient> clientDisconnected = ClientDisconnected;
if (clientDisconnected != null)
{
clientDisconnected(this, client);
}
}
private void NotifyClientDisconnected(IPCClient client)
{
var handler = ClientDisconnected;
if (handler != null)
{
handler(this, client);
}
}
private void CloseClientSocket(SocketAsyncEventArgs e)
{
IPCClient IPCClient = e.UserToken as IPCClient;
if (IPCClient != null)
{
try
{
IPCClient.Disconnect();
NotifyClientDisconnected(IPCClient);
}
finally
{
m_clients.Remove(IPCClient);
m_semaphore.Release();
}
}
}
private void ProcessAccept(SocketAsyncEventArgs e)
{
try
{
if (IsPaused)
{
logger.Warn("Pause state. Connection cancelled ...", m_semaphore.CurrentCount);
e.AcceptSocket.Disconnect(false);
m_semaphore.Release();
}
else
{
SocketAsyncEventArgs socketAsyncEventArgs = new SocketAsyncEventArgs();
socketAsyncEventArgs.SetBuffer(new byte[BufferSize], 0, BufferSize);
socketAsyncEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(OnReceiveCompleted);
IPCClient IPCClient = new IPCClient(e.AcceptSocket);
socketAsyncEventArgs.UserToken = IPCClient;
m_clients.Add(IPCClient);
NotifyClientConnected(IPCClient);
if (!e.AcceptSocket.ReceiveAsync(socketAsyncEventArgs))
{
StartAccept();
ProcessReceive(socketAsyncEventArgs);
}
else
{
StartAccept();
}
}
}
catch (Exception argument)
{
logger.Error("Cannot accept a connection from {0}. Exception : {1}", e.RemoteEndPoint, argument);
if (e.AcceptSocket != null)
{
e.AcceptSocket.Disconnect(false);
}
m_semaphore.Release();
StartAccept();
}
}
private void ProcessAccept(SocketAsyncEventArgs e)
{
IPCClient client = null;
try
{
// do not accept connections while pausing
if (IsPaused)
{
logger.Warn("Pause state. Connection cancelled ...", m_semaphore.CurrentCount);
e.AcceptSocket.Disconnect(false);
m_semaphore.Release();
return;
}
client = new IPCClient(e.AcceptSocket);
client.Disconnected += OnClientDisconnected;
m_clients.Add(client);
NotifyClientConnected(client);
client.BeginReceive();
StartAccept();
}
catch (Exception ex)
{
logger.Error("Cannot accept a connection from {0}. Exception : {1}", e.RemoteEndPoint, ex);
if (client != null)
{
client.Disconnect();
}
else
{
m_semaphore.Release();
}
StartAccept();
}
}
public IPCOperations(IPCClient ipcClient)
{
this.Client = ipcClient;
this.InitializeHandlers();
this.InitializeDatabase();
}
private void OnClientDisconnected(IPCClient obj)
{
m_clients.Remove(obj);
m_semaphore.Release();
}
