{
Trace.WriteLine("Data was received correctly.");
- Assert.AreEqual(data.Length, args.Bytes.Length);
+ Assert.AreEqual(data.Length, args.Message.Length);
for (int i = 0; i < data.Length; i++)
{
- Assert.AreEqual(data[i], args.Bytes[i]);
+ Assert.AreEqual(data[i], args.Message.ReadByte());
}
Assert.AreEqual(sendOption, args.SendOption);
{
Trace.WriteLine("Data was received correctly.");
- Assert.AreEqual(data.Length, innerArgs.Bytes.Length);
+ Assert.AreEqual(data.Length, innerArgs.Message.Length);
for (int i = 0; i < data.Length; i++)
{
- Assert.AreEqual(data[i], innerArgs.Bytes[i]);
+ Assert.AreEqual(data[i], innerArgs.Message.ReadByte());
}
Assert.AreEqual(sendOption, innerArgs.SendOption);
[TestMethod]
public void UdpHandshakeTest()
{
+ byte[] TestData = new byte[] { 1, 2, 3, 4, 5, 6 };
using (UdpConnectionListener listener = new UdpConnectionListener(new NetworkEndPoint(IPAddress.Any, 4296, IPMode.IPv4)))
using (UdpConnection connection = new UdpClientConnection(new NetworkEndPoint(IPAddress.Loopback, 4296, IPMode.IPv4)))
{
listener.Start();
+ MessageReader output = null;
listener.NewConnection += delegate (object sender, NewConnectionEventArgs e)
{
- Assert.IsTrue(Enumerable.SequenceEqual(e.HandshakeData, new byte[] { 1, 2, 3, 4, 5, 6 }));
+ output = e.HandshakeData;
};
- connection.Connect(new byte[] { 1, 2, 3, 4, 5, 6 });
+ connection.Connect(TestData);
+
+ Thread.Sleep(10);
+ for (int i = 0; i < TestData.Length; ++i)
+ {
+ Assert.AreEqual(TestData[i], output.ReadByte());
+ }
}
}
[TestMethod]
public void UdpUnreliableMessageSendTest()
{
+ byte[] TestData = new byte[] { 1, 2, 3, 4, 5, 6 };
using (UdpConnectionListener listener = new UdpConnectionListener(new NetworkEndPoint(IPAddress.Any, 4296, IPMode.IPv4)))
using (UdpConnection connection = new UdpClientConnection(new NetworkEndPoint(IPAddress.Loopback, 4296, IPMode.IPv4)))
{
+ MessageReader output = null;
listener.NewConnection += delegate (object sender, NewConnectionEventArgs e)
{
e.Connection.DataReceived += delegate (object s, DataReceivedEventArgs evt)
{
- Assert.IsTrue(Enumerable.SequenceEqual(evt.Bytes, new byte[] { 1, 2, 3, 4, 5, 6 }));
+ output = evt.Message;
};
};
for (int i = 0; i < 4; ++i)
{
var msg = MessageWriter.Get(SendOption.None);
- msg.Write(new byte[] { 1, 2, 3, 4, 5, 6 });
+ msg.Write(TestData);
connection.Send(msg);
msg.Recycle();
}
+
+ Thread.Sleep(10);
+ for (int i = 0; i < TestData.Length; ++i)
+ {
+ Assert.AreEqual(TestData[i], output.ReadByte());
+ }
}
}
{
e.Connection.DataReceived += delegate (object s, DataReceivedEventArgs evt)
{
- Assert.IsTrue(Enumerable.SequenceEqual(evt.Bytes, new byte[] { 3, 4 }));
+ Assert.IsTrue(Enumerable.SequenceEqual(evt.Message.Buffer, new byte[] { 3, 4 }));
};
};
Thread.Sleep(1050); //Enough time for ~10 keep alive packets
- Assert.IsTrue(
- args.Connection.Statistics.TotalBytesSent >= 30 &&
- args.Connection.Statistics.TotalBytesSent <= 50,
- "Sent: " + args.Connection.Statistics.TotalBytesSent
- );
-
- mutex.Set();
+ try
+ {
+ Assert.IsTrue(
+ args.Connection.Statistics.TotalBytesSent >= 30 &&
+ args.Connection.Statistics.TotalBytesSent <= 50,
+ "Sent: " + args.Connection.Statistics.TotalBytesSent
+ );
+ }
+ finally
+ {
+ mutex.Set();
+ }
};
listener.Start();
/// <summary>
/// Invokes the DataReceived event.
/// </summary>
- /// <param name="bytes">The bytes received.</param>
+ /// <param name="msg">The bytes received.</param>
/// <param name="sendOption">The <see cref="SendOption"/> the message was received with.</param>
/// <remarks>
/// Invokes the <see cref="DataReceived"/> event on this connection to alert subscribers a new message has been
/// received. The bytes and the send option that the message was sent with should be passed in to give to the
/// subscribers.
/// </remarks>
- protected void InvokeDataReceived(byte[] bytes, SendOption sendOption, ushort reliableId)
+ protected void InvokeDataReceived(MessageReader msg, SendOption sendOption, ushort reliableId)
{
DataReceivedEventArgs args = DataReceivedEventArgs.GetObject();
- args.Set(bytes, sendOption, reliableId);
+ args.Set(msg, sendOption, reliableId);
//Make a copy to avoid race condition between null check and invocation
EventHandler<DataReceivedEventArgs> handler = DataReceived;
/// <summary>
/// Invokes the NewConnection event with the supplied connection.
/// </summary>
- /// <param name="bytes">The user sent bytes that were received as part of the handshake.</param>
+ /// <param name="msg">The user sent bytes that were received as part of the handshake.</param>
/// <param name="connection">The connection to pass in the arguments.</param>
/// <remarks>
/// Implementers should call this to invoke the <see cref="NewConnection"/> event before data is received so that
/// subscribers do not miss any data that may have been sent immediately after connecting.
/// </remarks>
- protected void InvokeNewConnection(byte[] bytes, Connection connection)
+ protected void InvokeNewConnection(MessageReader msg, Connection connection)
{
//Get new args
NewConnectionEventArgs args = NewConnectionEventArgs.GetObject();
- args.Set(bytes, connection);
+ args.Set(msg, connection);
//Make a copy to avoid race condition between null check and invocation
EventHandler<NewConnectionEventArgs> handler = NewConnection;
/// <summary>
/// The bytes received from the client.
/// </summary>
- public byte[] Bytes { get; private set; }
+ public MessageReader Message { get; private set; }
/// <summary>
/// The <see cref="SendOption"/> the data was sent with.
/// </summary>
/// <param name="bytes">The bytes received.</param>
/// <param name="sendOption">The send option used to send the data.</param>
- internal void Set(byte[] bytes, SendOption sendOption, ushort reliableId)
+ internal void Set(MessageReader msg, SendOption sendOption, ushort reliableId)
{
- this.Bytes = bytes;
+ this.Message = msg;
this.SendOption = sendOption;
this.ReliableId = reliableId;
}
private int readHead;
- public static MessageReader Get(MessageReader srcMsg)
+ public static MessageReader GetRaw(byte[] bytes, int offset, int length)
{
var output = ReaderPool.GetObject();
- output.Buffer = srcMsg.Buffer;
- output.Offset = srcMsg.Offset;
- output.Position = srcMsg.Position;
- output.Length = srcMsg.Length;
- output.Tag = srcMsg.Tag;
+ output.Buffer = bytes;
+ output.Offset = offset;
+ output.Position = 0;
+ output.Length = length;
return output;
}
/// <summary>
/// The data received from the client in the handshake.
/// </summary>
- public byte[] HandshakeData { get; private set; }
+ public MessageReader HandshakeData { get; private set; }
/// <summary>
/// The <see cref="Connection"/> to the new client.
/// <summary>
/// Sets the members of the arguments.
/// </summary>
- /// <param name="bytes">The bytes that were received in the handshake.</param>
+ /// <param name="msg">The bytes that were received in the handshake.</param>
/// <param name="connection">The new connection</param>
- internal void Set(byte[] bytes, Connection connection)
+ internal void Set(MessageReader msg, Connection connection)
{
- this.HandshakeData = bytes;
+ this.HandshakeData = msg;
this.Connection = connection;
}
ptr += fragment.data.Length - fragment.offset;
}
- InvokeDataReceived(completeData, SendOption.FragmentedReliable, 0);
+ var reader = MessageReader.GetRaw(completeData, 0, completeData.Length);
+ try
+ {
+ InvokeDataReceived(reader, SendOption.FragmentedReliable, 0);
+ }
+ finally
+ {
+ reader.Recycle();
+ }
}
/// <summary>
/// <param name="dataOffset">The offset of data in the buffer.</param>
void InvokeDataReceived(SendOption sendOption, byte[] buffer, int dataOffset, ushort reliableId)
{
- byte[] dataBytes = new byte[buffer.Length - dataOffset];
- Buffer.BlockCopy(buffer, dataOffset, dataBytes, 0, dataBytes.Length);
-
- InvokeDataReceived(dataBytes, sendOption, reliableId);
+ var reader = MessageReader.GetRaw(buffer, dataOffset, buffer.Length - dataOffset);
+ try
+ {
+ InvokeDataReceived(reader, sendOption, reliableId);
+ }
+ finally
+ {
+ reader.Recycle();
+ }
}
/// <summary>
UdpServerConnection connection;
lock (connections)
{
- aware = connections.ContainsKey(remoteEndPoint);
-
//If we're aware of this connection use the one already
- if (aware)
- connection = connections[remoteEndPoint];
-
//If this is a new client then connect with them!
- else
+ if (!(aware = connections.TryGetValue(remoteEndPoint, out connection)))
{
//Check for malformed connection attempts
if (buffer[0] != (byte)UdpSendOption.Hello)
//If it's a new connection invoke the NewConnection event.
if (!aware)
{
- byte[] dataBuffer = new byte[buffer.Length - 3];
- Buffer.BlockCopy(buffer, 3, dataBuffer, 0, buffer.Length - 3);
- InvokeNewConnection(dataBuffer, connection);
+ var reader = MessageReader.GetRaw(buffer, 4, buffer.Length - 4);
+ try
+ {
+ InvokeNewConnection(reader, connection);
+ }
+ finally
+ {
+ reader.Recycle();
+ }
}
}
projects / rhonda / impostor.hazel.git / commitdiff