/// <summary>
/// Callback method for asynchronous receive operation of handshake data.
/// </summary>
private void ReceiveHandshakeAsyncCallback(IAsyncResult asyncResult)
{
TransportProvider<Socket> tcpClient = (TransportProvider<Socket>)asyncResult.AsyncState;
if (!asyncResult.IsCompleted)
{
// Handshake didn't complete in a timely fashion.
TerminateConnection(tcpClient, false);
OnHandshakeProcessTimeout();
}
else
{
// Received handshake data from client so we'll process it.
try
{
// Update statistics and pointers.
tcpClient.Statistics.UpdateBytesReceived(tcpClient.Provider.EndReceive(asyncResult));
tcpClient.ReceiveBufferLength = tcpClient.Statistics.LastBytesReceived;
if (tcpClient.Statistics.LastBytesReceived == 0)
// Client disconnected gracefully.
throw new SocketException((int)SocketError.Disconnecting);
// Process the received handshake message.
Payload.ProcessReceived(ref tcpClient.ReceiveBuffer, ref tcpClient.ReceiveBufferOffset, ref tcpClient.ReceiveBufferLength, Encryption, HandshakePassphrase, Compression);
HandshakeMessage handshake = new HandshakeMessage();
if (handshake.Initialize(tcpClient.ReceiveBuffer, tcpClient.ReceiveBufferOffset, tcpClient.ReceiveBufferLength) != -1)
{
// Received handshake message could be parsed successfully.
if (handshake.ID != Guid.Empty && handshake.Passphrase == HandshakePassphrase)
{
// Authentication is successful; respond to the handshake.
tcpClient.ID = handshake.ID;
handshake.ID = this.ServerID;
if (SecureSession)
{
// Create a secret key for ciphering client data.
tcpClient.Passphrase = Cipher.GenerateKey(260);
handshake.Passphrase = tcpClient.Passphrase;
}
// Prepare binary image of handshake response to be transmitted.
tcpClient.SendBuffer = handshake.BinaryImage;
tcpClient.SendBufferOffset = 0;
tcpClient.SendBufferLength = tcpClient.SendBuffer.Length;
Payload.ProcessTransmit(ref tcpClient.SendBuffer, ref tcpClient.SendBufferOffset, ref tcpClient.SendBufferLength, Encryption, HandshakePassphrase, Compression);
// Transmit the prepared and processed handshake response message.
tcpClient.Provider.Send(tcpClient.SendBuffer);
// Handshake process is complete and client is considered connected.
lock (m_tcpClients)
{
m_tcpClients.Add(tcpClient.ID, tcpClient);
}
OnClientConnected(tcpClient.ID);
ReceivePayloadAsync(tcpClient);
}
else
{
// Authentication during handshake failed, so we terminate the client connection.
TerminateConnection(tcpClient, false);
OnHandshakeProcessUnsuccessful();
}
}
else
{
// Handshake message could not be parsed, so we terminate the client connection.
TerminateConnection(tcpClient, false);
OnHandshakeProcessUnsuccessful();
}
}
catch
{
// Handshake process could not be completed most likely due to client disconnect.
TerminateConnection(tcpClient, false);
OnHandshakeProcessUnsuccessful();
}
}
}
/// <summary>
/// Callback method for asynchronous receive operation of handshake data.
/// </summary>
private void ReceiveHandshakeAsyncCallback(IAsyncResult asyncResult)
{
TransportProvider<Socket> udpServer = (TransportProvider<Socket>)asyncResult.AsyncState;
// Received handshake data from client so we'll process it.
try
{
// Update statistics and pointers.
EndPoint client = Transport.CreateEndPoint(string.Empty, 0);
udpServer.Statistics.UpdateBytesReceived(udpServer.Provider.EndReceiveFrom(asyncResult, ref client));
udpServer.ReceiveBufferLength = udpServer.Statistics.LastBytesReceived;
// Process the received handshake message.
Payload.ProcessReceived(ref udpServer.ReceiveBuffer, ref udpServer.ReceiveBufferOffset, ref udpServer.ReceiveBufferLength, Encryption, HandshakePassphrase, Compression);
HandshakeMessage handshake = new HandshakeMessage();
if (handshake.Initialize(udpServer.ReceiveBuffer, udpServer.ReceiveBufferOffset, udpServer.ReceiveBufferLength) != -1)
{
// Received handshake message could be parsed successfully.
if (handshake.ID != Guid.Empty && handshake.Passphrase == HandshakePassphrase)
{
// Create a random socket and connect it to the client.
TransportProvider<Socket> udpClient = new TransportProvider<Socket>();
udpClient.ReceiveBuffer = new byte[ReceiveBufferSize];
udpClient.Passphrase = HandshakePassphrase;
udpClient.Provider = Transport.CreateSocket(0, ProtocolType.Udp);
udpClient.Provider.Connect(client);
// Authentication is successful; respond to the handshake.
udpClient.ID = handshake.ID;
handshake.ID = this.ServerID;
if (SecureSession)
{
// Create a secret key for ciphering client data.
udpClient.Passphrase = Cipher.GenerateKey(260);
handshake.Passphrase = udpClient.Passphrase;
}
// Prepare binary image of handshake response to be transmitted.
udpClient.SendBuffer = handshake.BinaryImage;
udpClient.SendBufferOffset = 0;
udpClient.SendBufferLength = udpClient.SendBuffer.Length;
Payload.ProcessTransmit(ref udpClient.SendBuffer, ref udpClient.SendBufferOffset, ref udpClient.SendBufferLength, Encryption, HandshakePassphrase, Compression);
// Transmit the prepared and processed handshake response message.
udpClient.Provider.SendTo(udpClient.SendBuffer, udpClient.Provider.RemoteEndPoint);
// Handshake process is complete and client is considered connected.
lock (m_udpClients)
{
m_udpClients.Add(udpClient.ID, udpClient);
}
OnClientConnected(udpClient.ID);
ReceiveHandshakeAsync(udpServer);
try
{
ReceivePayloadOneAsync(udpClient);
}
catch
{
// Receive will fail if client disconnected before handshake is complete.
TerminateConnection(udpClient, true);
}
}
else
{
// Authentication during handshake failed, so we terminate the client connection.
TerminateConnection(udpServer, false);
OnHandshakeProcessUnsuccessful();
}
}
else
{
// Handshake message could not be parsed, so we terminate the client connection.
TerminateConnection(udpServer, false);
OnHandshakeProcessUnsuccessful();
}
}
catch
{
// Server socket has been terminated.
udpServer.Reset();
OnServerStopped();
}
}
/// <summary>
/// Callback method for asynchronous receive operation of handshake data.
/// </summary>
private void ReceiveHandshakeAsyncCallback(IAsyncResult asyncResult)
{
TransportProvider<Socket> udpClient = (TransportProvider<Socket>)asyncResult.AsyncState;
if (!asyncResult.IsCompleted)
{
// Handshake response is not recevied in a timely fashion.
TerminateConnection(udpClient, false);
OnHandshakeProcessTimeout();
}
else
{
// Received handshake response from server so we'll process it.
try
{
// Update statistics and pointers.
udpClient.Statistics.UpdateBytesReceived(udpClient.Provider.EndReceiveFrom(asyncResult, ref m_udpServer));
udpClient.ReceiveBufferLength = udpClient.Statistics.LastBytesReceived;
// Process the received handshake response message.
Payload.ProcessReceived(ref udpClient.ReceiveBuffer, ref udpClient.ReceiveBufferOffset, ref udpClient.ReceiveBufferLength, Encryption, HandshakePassphrase, Compression);
HandshakeMessage handshake = new HandshakeMessage();
if (handshake.Initialize(udpClient.ReceiveBuffer, udpClient.ReceiveBufferOffset, udpClient.ReceiveBufferLength) != -1)
{
// Received handshake response message could be parsed.
this.ServerID = handshake.ID;
udpClient.Passphrase = handshake.Passphrase;
// Client is now considered to be connected to the server.
OnConnectionEstablished();
ReceivePayloadAsync(udpClient);
}
else
{
// Received handshake response message could not be parsed.
TerminateConnection(udpClient, false);
OnHandshakeProcessUnsuccessful();
}
}
catch
{
// This is most likely because the server forcibly disconnected the client.
TerminateConnection(udpClient, false);
OnHandshakeProcessUnsuccessful();
}
}
}