private void AcceptCallback(IAsyncResult AR)
{
if (!IsRunning)
{
return;
}
Socket cSock = _globalSocket.EndAccept(AR);
if (OnClientConnecting != null)
{
if (!OnClientConnecting(this, cSock))
{
return;
}
}
eSockClient _client = new eSockClient(cSock, BufferSize, Encryption.DefaultClientEncryption);
_client.Encryption.Key = Encryption.DefaultEncryptionKey;
_client.Encryption.Enabled = Encryption.EnableEncryptionOnConnect;
if (OnClientConnect != null)
{
OnClientConnect(this, _client);
}
_client.NetworkSocket.BeginReceive(_client.Buffer, 0, _client.Buffer.Length, SocketFlags.None,
RetrieveCallback, _client);
_globalSocket.BeginAccept(AcceptCallback, null);
}
private void RetrieveCallback(IAsyncResult AR)
{
if (!IsRunning)
{
return;
}
eSockClient _client = (eSockClient)AR.AsyncState;
SocketError SE;
int packetLength = _client.NetworkSocket.EndReceive(AR, out SE);
if (SE != SocketError.Success)
{
if (OnClientDisconnect != null)
{
OnClientDisconnect(this, _client, SE);
}
return;
}
byte[] Packet = new byte[packetLength];
Buffer.BlockCopy(_client.Buffer, 0, Packet, 0, packetLength);
_client.NetworkSocket.BeginReceive(_client.Buffer, 0, _client.Buffer.Length, SocketFlags.None,
RetrieveCallback, _client);
object[] RetrievedData = Formatter.Deserialize <object[]>(Packet);
if (OnDataRetrieved != null)
{
OnDataRetrieved(this, _client, RetrievedData);
}
}
private void RetrieveCallback(IAsyncResult AR)
{
SocketError SE = SocketError.NotConnected;
eSockClient client = (eSockClient)AR.AsyncState;
try
{
client.NetworkSocket.EndReceive(AR, out SE);
if (SE != SocketError.Success)
{
throw new Exception("Socket Error");
}
if (_structured)
{
try
{
ushort packSize = PacketStructure.PacketLength(client.PacketBuffer);
byte[] _packet = new byte[packSize];
Buffer.BlockCopy(client.PacketBuffer, 0, _packet, 0, _packet.Length);
PacketStructure ps = new PacketStructure(_packet);
if (DataRetrievedCallback != null)
{
DataRetrievedCallback(client, ps, PacketError.Success);
}
}
catch
{
if (DataRetrievedCallback != null)
{
DataRetrievedCallback(client, new PacketStructure(4, 0), PacketError.SizeIncorrect);
}
}
}
else
{
if (DataRetrievedNotStructured != null)
{
DataRetrievedNotStructured(client, client.PacketBuffer);
}
}
client.NetworkSocket.BeginReceive(client.PacketBuffer, 0, client.PacketBuffer.Length, SocketFlags.None, out SE, RetrieveCallback, client);
if (SE != SocketError.Success)
{
throw new Exception("Socket Error");
}
}
catch
{
if (ClientDisconnectCallback != null)
{
ClientDisconnectCallback(client, SE);
}
}
}
private void AcceptCallback(IAsyncResult AR)
{
Socket cSock = _Sock.EndAccept(AR);
if (ClientConnectCallback != null)
{
ClientConnectCallback(new eSockClient(cSock));
}
SocketError SE;
eSockClient client = new eSockClient(cSock);
client.ResizeBuffer(clientBufferSize);
cSock.BeginReceive(client.PacketBuffer, 0, client.PacketBuffer.Length, SocketFlags.None, out SE, RetrieveCallback, client);
if (SE != SocketError.Success)
{
if (ClientDisconnectCallback != null)
{
ClientDisconnectCallback(new eSockClient(cSock), SE);
}
}
_Sock.BeginAccept(AcceptCallback, null);
}
private void RetrieveCallback(IAsyncResult AR)
{
if (!IsRunning)
{
return;
}
eSockClient _client = (eSockClient)AR.AsyncState;
if (_client.NetworkSocket == null || !_client.NetworkSocket.Connected)
{
if (OnClientDisconnect != null)
{
OnClientDisconnect(this, _client, SocketError.Disconnecting);
}
_client.Dispose();
return;
}
SocketError SE;
int packetLength = _client.NetworkSocket.EndReceive(AR, out SE);
if (SE != SocketError.Success)
{
if (OnClientDisconnect != null)
{
OnClientDisconnect(this, _client, SE);
}
_client.Dispose();
return;
}
byte[] PacketCluster = new byte[packetLength];
Buffer.BlockCopy(_client.Buffer, 0, PacketCluster, 0, packetLength);
byte[] Packet = null;
using (MemoryStream bufferStream = new MemoryStream(PacketCluster))
using (BinaryReader packetReader = new BinaryReader(bufferStream))
{
try
{
while (bufferStream.Position < bufferStream.Length)
{
int length = packetReader.ReadInt32();
if (length > bufferStream.Length - bufferStream.Position)
{
using (MemoryStream recievePacketChunks = new MemoryStream(length))
{
byte[] buffer = new byte[bufferStream.Length - bufferStream.Position];
buffer = packetReader.ReadBytes(buffer.Length);
recievePacketChunks.Write(buffer, 0, buffer.Length);
while (recievePacketChunks.Position != length)
{
packetLength = _client.NetworkSocket.Receive(_client.Buffer);
buffer = new byte[packetLength];
Buffer.BlockCopy(_client.Buffer, 0, buffer, 0, packetLength);
recievePacketChunks.Write(buffer, 0, buffer.Length);
}
Packet = recievePacketChunks.ToArray();
}
}
else
{
Packet = packetReader.ReadBytes(length);
}
if (_client.Encryption != null)
{
Packet = _client.Encryption.Decrypt(Packet);
}
object[] RetrievedData = Formatter.Deserialize <object[]>(Packet);
if (OnDataRetrieved != null && RetrievedData != null)
{
OnDataRetrieved(this, _client, RetrievedData);
}
_client.NetworkSocket.BeginReceive(_client.Buffer, 0, _client.Buffer.Length, SocketFlags.None, RetrieveCallback, _client);
}
}
catch
{
}
}
}
