private void receiveMessage(int length)
{
rcvdMode = receivingMode.receivingMessage;
receivingOrder++;
// Reallocating if needed
if (length < 1000000)
{
if (length > rcvdByteBuffer.Length) rcvdByteBuffer = new byte[length];
AsyncState asyncState = new AsyncState(receivingOrder, length);
try
{
clientSocket.BeginReceive(rcvdByteBuffer, 0, length, 0, new AsyncCallback(ReadCallback), asyncState);
}
catch (SocketException se)
{
DebuggerIX.WriteLine(DebuggerTag.Net, role, "SocketException: " + se.Message);
throw;
}
}
else
{
throw new SocketException();
}
}
private void receiveDescriptor()
{
rcvdMode = receivingMode.receivingDescriptor;
receivingOrder++;
AsyncState asyncState = new AsyncState(receivingOrder, MESSAGE_DESCRIPTOR_LENGTH);
try
{
clientSocket.BeginReceive(rcvdByteBuffer, 0, MESSAGE_DESCRIPTOR_LENGTH, 0,
new AsyncCallback(ReadCallback), asyncState);
}
catch (SocketException e)
{
DebuggerIX.WriteLine(DebuggerTag.Net, role, "SocketException: " + e.Message);
throw;
}
}
protected void receivingInit()
{
lock (readCallbackLock)
{
rcvdBuffer.Clear();
}
rcvdMode = receivingMode.none;
isReceiving = false;
receivingOrder = 0;
rcvdBufferLength = 0;
rcvdBufferOffset = 0;
}
private void receiveAsyncProcessing()
{
isReceiving = true;
if (rcvdMode == receivingMode.descriptorReceived)
{
int messageLength = BitConverter.ToInt32(rcvdByteBuffer, 0);
rcvdNetworkMessageType = (NetworkMessageType)BitConverter.ToInt32(rcvdByteBuffer, 4);
resetRcvdVariables();
receiveMessage(messageLength);
}
else if (rcvdMode == receivingMode.messageReceived)
{
byte[] data = new byte[rcvdBufferLength];
Buffer.BlockCopy(rcvdByteBuffer, 0, data, 0, rcvdBufferLength);
rcvdBuffer.Enqueue(new Pair<NetworkMessageType, byte[]>(rcvdNetworkMessageType, data));
receivedMessageHandle.Set();
resetRcvdVariables();
rcvdMode = receivingMode.none;
}
if (rcvdMode == receivingMode.none)
{
resetRcvdVariables();
receiveDescriptor();
}
}
public void ReadCallback(IAsyncResult ar)
{
lock (readCallbackLock)
{
// Retrieve the state object and the handler socket
// from the asynchronous state object.
AsyncState asyncState = (AsyncState)ar.AsyncState;
// Read data from the client socket.
int received = 0;
try
{
received = clientSocket.EndReceive(ar);
}
catch (ObjectDisposedException)
{
DebuggerIX.WriteLine(DebuggerTag.Net, role, "ReadCallback: Socket has been closed\n");
return;
}
catch (ArgumentException e)
{
DebuggerIX.WriteLine(DebuggerTag.Net, role, "ReadCallback: Called from wrong AsyncResult; Exception: " + e.Message);
return;
}
catch (SocketException se)
{
if (se.ErrorCode == 10054) // Error code for Connection reset by peer
{
DebuggerIX.WriteLine(DebuggerTag.Net, role, "Client Disconnected");
return;
}
else
{
DebuggerIX.WriteLine(DebuggerTag.Net, role, se.Message);
return;
}
}
rcvdBufferLength += received;
rcvdBufferOffset += rcvdBufferLength;
if (received == asyncState.Length)
{
// All the data has been read from the
// client. Display it on the console.
//Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content);
if (rcvdMode == receivingMode.receivingDescriptor)
{
DebuggerIX.WriteLine(DebuggerTag.Net, role,
"Message #" + asyncState.Order + " descriptor received. Total bytes: " + rcvdBufferLength +
"; Next message (length, type): (" + BitConverter.ToInt32(rcvdByteBuffer, 0) +
", " + (NetworkMessageType)BitConverter.ToInt32(rcvdByteBuffer, 4) + ")");
rcvdMode = receivingMode.descriptorReceived;
}
else if (rcvdMode == receivingMode.receivingMessage)
{
DebuggerIX.WriteLine(DebuggerTag.Net, role,
"Message #" + asyncState.Order + " received. Total bytes: " + rcvdBufferLength);
rcvdMode = receivingMode.messageReceived;
}
receiveAsyncProcessing();
}
else
{
asyncState.Length = asyncState.Length - received;
// Not all data received. Get more.
try
{
clientSocket.BeginReceive(rcvdByteBuffer, rcvdBufferOffset, asyncState.Length, SocketFlags.None,
new AsyncCallback(ReadCallback), asyncState);
}
catch (SocketException e)
{
DebuggerIX.WriteLine(DebuggerTag.Net, role, "ReadCallback: Exception. Message: " + e.Message);
}
//}
//catch (SocketException e)
//{
//if (isClosed == false) throw new Exception("SocketException: " + e.Message);
//}
}
}
}
