private void ReceiveCallback(IAsyncResult ar)
{
EndPoint source = new IPEndPoint(0, 0);
int bytesRead = 0;
try
{
bytesRead = _socket.EndReceiveFrom(ar, ref source);
}
catch (SocketException)
{
return;
}
// Parse the message
if (source.Equals(_targetEndPoint) && bytesRead > 0)
{
try
{
byte[] b = (byte[])ar.AsyncState;
_packetProtocol.DataReceived(b, bytesRead);
}
catch (ProtocolViolationException e)
{
_packetProtocol.MessageArrived = null;
_packetProtocol = new PacketProtocol <TMessageType>(_bufferSize);
_packetProtocol.MessageArrived = (MessageType, data) => OnMessageReceived(MessageType, data);
}
}
// Start receiving more data
StartReceive();
}
public void DataReceived_LengthShorterThanBuffer_OnlyReadsTheLength()
{
MessageType expectedMessageType = MessageType.Init;
byte[] expectedBytes = new byte[] { 1, 2, 3, 4 };
byte[] message = PacketProtocol <MessageType> .WrapMessage(expectedMessageType, expectedBytes);
// Add bytes the package protocol should not read.
byte[] tooLongMessage = message.Concat(new byte[] { 9, 8, 7 }).ToArray();
MessageType receivedMessageType = MessageType.Unknown;
byte[] receivedBytes = null;
PacketProtocol <MessageType> packetProtocol = new PacketProtocol <MessageType>(100);
packetProtocol.MessageArrived += (type, bytes) =>
{
receivedMessageType = type;
receivedBytes = bytes;
};
packetProtocol.DataReceived(tooLongMessage, message.Length);
Assert.AreEqual(expectedMessageType, receivedMessageType);
Assert.AreEqual(expectedBytes, receivedBytes);
}
public static void Receive(TcpClient connection, BinaryReader reader, PacketProtocol packetProtocol)
{
var bufferSize = connection.Available;
var buffer = reader.ReadBytes(bufferSize);
packetProtocol.DataReceived(buffer);
}
public void DataReceived_FullMessage_ReturnsCorrectMessage()
{
MessageType expectedMessageType = MessageType.Init;
byte[] expectedBytes = new byte[] { 1, 2, 3, 4 };
byte[] message = PacketProtocol <MessageType> .WrapMessage(expectedMessageType, expectedBytes);
MessageType receivedMessageType = MessageType.Unknown;
byte[] receivedBytes = null;
PacketProtocol <MessageType> packetProtocol = new PacketProtocol <MessageType>(100);
packetProtocol.MessageArrived += (type, bytes) =>
{
receivedMessageType = type;
receivedBytes = bytes;
};
packetProtocol.DataReceived(message, message.Length);
Assert.AreEqual(expectedMessageType, receivedMessageType);
Assert.AreEqual(expectedBytes, receivedBytes);
}
public void DataReceived_MessageSplitInMultiplePackages_ReturnsCorrectMessage()
{
MessageType expectedMessageType = MessageType.Init;
byte[] expectedBytes = new byte[] { 1, 2, 3, 4 };
byte[] message = PacketProtocol <MessageType> .WrapMessage(expectedMessageType, expectedBytes);
Assert.AreEqual(12, message.Length, "This test assumes the message length is 12");
byte[] messagePackage1 = { message[0],
message[1],
message[2] };
byte[] messagePackage2 = { message[3],
message[4],
message[5] };
byte[] messagePackage3 = { message[6],
message[7],
message[8] };
byte[] messagePackage4 = { message[9],
message[10],
message[11], };
MessageType receivedMessageType = MessageType.Unknown;
byte[] receivedBytes = null;
PacketProtocol <MessageType> packetProtocol = new PacketProtocol <MessageType>(100);
packetProtocol.MessageArrived += (type, bytes) =>
{
receivedMessageType = type;
receivedBytes = bytes;
};
packetProtocol.DataReceived(messagePackage1, messagePackage1.Length);
Assert.AreEqual(MessageType.Unknown, receivedMessageType);
packetProtocol.DataReceived(messagePackage2, messagePackage2.Length);
Assert.AreEqual(MessageType.Unknown, receivedMessageType);
packetProtocol.DataReceived(messagePackage3, messagePackage3.Length);
Assert.AreEqual(MessageType.Unknown, receivedMessageType);
packetProtocol.DataReceived(messagePackage4, messagePackage4.Length);
Assert.AreEqual(expectedMessageType, receivedMessageType);
Assert.AreEqual(expectedBytes, receivedBytes);
}
public void DataReceived_PackageTooLong_ThrowsProtocolViolationException()
{
MessageType expectedMessageType = MessageType.Init;
byte[] expectedBytes = new byte[] { 1, 2, 3, 4 };
byte[] message = PacketProtocol <MessageType> .WrapMessage(expectedMessageType, expectedBytes);
// Add bytes the package protocol should not read.
PacketProtocol <MessageType> packetProtocol = new PacketProtocol <MessageType>(10);
Assert.Throws <ProtocolViolationException>(() => packetProtocol.DataReceived(message, message.Length));
}
// -------------------- Receive -------------------- \\
private void ReceiveCallback(IAsyncResult ar)
{
// Read incoming data from the client.
if (_isDisposed)
{
Console.WriteLine($"Ignored incoming message as this object is disposed.");
return;
}
int bytesRead = 0;
try
{
bytesRead = _socket.EndReceive(ar);
}
catch (SocketException e)
{
OnDisconnect(e);
return;
}
if (bytesRead > 0)
{
// Parse the message
lock (_parsingMessageLock)
{
try
{
byte[] b = (byte[])ar.AsyncState;
_packetProtocol.DataReceived(b, bytesRead);
}
catch (ProtocolViolationException e)
{
Console.WriteLine("Failed to receive data. Package protocol violation. \n" + e.ToString());
_packetProtocol.MessageArrived = null;
_packetProtocol.KeepAliveArrived = null;
_packetProtocol = new PacketProtocol <TMessageType>(_bufferSize);
_packetProtocol.MessageArrived = (MessageType, data) => OnMessageReceived(MessageType, data);
}
}
// Start receiving more data
byte[] buffer = new byte[_bufferSize];
_socket.BeginReceive(buffer, 0, _bufferSize, 0, new AsyncCallback(ReceiveCallback), buffer);
}
}
/// <summary>
/// Ends receiving message from remote client.
/// </summary>
/// <param name="ar"></param>
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
// Retrieve the state object and the client socket from the asynchronous state object:
StateObject state = (StateObject)ar.AsyncState;
Socket client = state.workSocket;
if (state == null)
{
Debug.Log("State is null");
}
if (packetizer == null)
{
Debug.Log("packetizer is null");
}
// Read data from the remote device:
int bytesRead = client.EndReceive(ar);
if (bytesRead > 0)
{
// pass received data and receiving process to packetizer object:
packetizer.DataReceived(state.buffer);
}
// Signal that all bytes have been received:
receiveDone.Set();
}
catch (Exception ex)
{
Debug.Log(ex.ToString());
}
}