// Try receiving a message from the tcpSocket.
// Return the message if when succeeded to receive a whole message.
// Return null if not.
public bool TryReceiveMessage(TcpSocket tcpSocket, out byte[] message)
{
// Try receiving the size of the actual message.
if (sizeCursor < sizeBytes.Length)
{
var sizeResult = tcpSocket.Receive(sizeBytes, sizeCursor, sizeBytes.Length - sizeCursor);
var sizeError = sizeResult.Error;
if (!(sizeError == SocketError.Success || sizeError == SocketError.WouldBlock))
{
throw new Exception("Error receiving message size: " + sizeError);
}
else
{
sizeCursor += sizeResult.Size;
}
if (sizeCursor == sizeBytes.Length)
{
int packetSize = BitConverter.ToInt32(sizeBytes, 0);
messageBytes = new byte[packetSize];
}
else
{
message = null;
return(false);
}
}
// Try receiving the bytes of the actual message.
var messageResult = tcpSocket.Receive(messageBytes, messageCursor, messageBytes.Length - messageCursor);
var messageError = messageResult.Error;
if (!(messageError == SocketError.Success || messageError == SocketError.WouldBlock))
{
throw new Exception("Error receiving message: " + messageError);
}
else
{
messageCursor += messageResult.Size;
}
// If message wasn't not received completety, try it again next time.
if (messageCursor < messageBytes.Length)
{
message = null;
return(false);
}
sizeCursor = 0;
messageCursor = 0;
message = messageBytes;
return(true);
}
private void OnSent(TcpSocketSend data)
{
if (data.Status == SocketStatus.OK)
{
outgoing = new SocketBuffer(data.Buffer.Data, data.Buffer.Offset + data.Count, data.Buffer.Count - data.Count);
if (incoming.Count > 0)
{
socket.Receive(incoming, OnReceived);
}
else if (outgoing.Count > 0)
{
socket.Send(outgoing, OnSent);
}
else
{
incoming = new SocketBuffer(incoming.Data);
outgoing = new SocketBuffer(outgoing.Data);
if (session.Elapsed > TimeSpan.FromMinutes(1))
{
socket = factory.Tcp();
session = Stopwatch.StartNew();
socket.Bind();
socket.Connect(endpoint, OnConnected);
data.Socket.Dispose();
}
else
{
socket.Send(outgoing, OnSent);
}
}
}
else
{
Console.WriteLine("OnSent");
socket.Dispose();
}
counter += data.Count;
if (counter - previous > 1024 * 1024 * 1024)
{
previous = counter;
Console.WriteLine($"{counter}: {counter / watch.ElapsedMilliseconds}");
}
}
public async Task CanReceiveDataUsingTasksToHostedEchoServer()
{
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] input = Encoding.ASCII.GetBytes(request);
byte[] output = new byte[input.Length];
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
using (EchoServer server = new EchoServer(factory))
{
socket.Bind();
worker.Start();
server.Start();
await socket.Connect(server.Endpoint);
await socket.Send(input);
await socket.Receive(output);
Assert.That(input, Is.EqualTo(output));
}
}
}
public async Task CanHandleTerminatedStream()
{
IPAddress localhost = IPAddress.Loopback;
IPEndPoint endpoint = new IPEndPoint(localhost, 1234);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket server = factory.Tcp())
using (TcpSocket socket = factory.Tcp())
{
socket.Bind();
worker.Start();
server.Bind(endpoint.Port);
server.Listen(1);
Task <TcpSocketAccept> acceptable = server.Accept();
await socket.Connect(endpoint);
TcpSocketAccept accepted = await acceptable;
accepted.Connection.Dispose();
byte[] buffer = new byte[10];
TcpSocketReceive received = await socket.Receive(buffer);
Assert.That(received.Status, Is.Not.EqualTo(SocketStatus.OK));
}
}
}
public async Task <string> Send(IPEndPoint endpoint, string message)
{
int progress = 0;
byte[] output = new byte[message.Length];
byte[] bytes = Encoding.ASCII.GetBytes(message);
using (TcpSocket socket = factory.Tcp())
{
socket.Bind();
TcpSocketConnect connected = await socket.Connect(endpoint);
TcpSocketSend sent = await socket.Send(bytes);
while (progress < output.Length)
{
SocketBuffer buffer = new SocketBuffer(output, progress);
TcpSocketReceive received = await socket.Receive(buffer);
if (received.Count == 0)
{
break;
}
progress += received.Count;
}
}
return(Encoding.ASCII.GetString(output));
}
// [Test]
public void StressTest()
{
TcpListener listener = new TcpListener();
listener.Listen(PORT);
TcpSocket clientSock = new TcpSocket();
var connectionResult = clientSock.ConnectAsync("localhost", PORT).Result;
var status = listener.Accept(out TcpSocket serverSock);
for (int i = 0; i < 1000000; i++)
{
NetPacket packet = new NetPacket();
var messageTo = Guid.NewGuid().ToString();
packet.WriteString(messageTo);
while (serverSock.Send(packet) != SocketStatus.Done)
{
;
}
packet.Clear();
while (clientSock.Receive(packet) != SocketStatus.Done)
{
;
}
Assert.AreEqual(messageTo, packet.ReadString());
packet.ResetWrite();
packet.WriteString($"Message with code {messageTo} received.");
while (clientSock.Send(packet) != SocketStatus.Done)
{
;
}
packet.Clear();
while (serverSock.Receive(packet) != SocketStatus.Done)
{
;
}
packet.Dispose();
}
listener.Dispose();
clientSock.Dispose();
serverSock.Dispose();
}
public async Task CanHandleNotBoundSocket()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket socket = factory.Tcp())
{
byte[] buffer = new byte[10];
TcpSocketReceive received = await socket.Receive(buffer);
Assert.That(received.Status, Is.Not.EqualTo(SocketStatus.OK));
}
}
}
public void CanReceiveDataUsingCallbackToExampleSite()
{
TimeSpan timeout = TimeSpan.FromSeconds(2);
ManualResetEvent check = new ManualResetEvent(false);
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 80);
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] data = Encoding.ASCII.GetBytes(request);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
TcpSocketReceiveCallback onReceived = result =>
{
check.Set();
};
TcpSocketSendCallback onSent = result =>
{
socket.Receive(data, onReceived);
};
TcpSocketConnectCallback onConnected = result =>
{
socket.Send(data, onSent);
};
socket.Connect(endpoint, onConnected);
bool completed = check.WaitOne(timeout);
Assert.That(completed, Is.True);
socket.Dispose();
}
}
public void SendReceiveTest()
{
const string serverMessage = "HelloFromServer";
const string clientMessage = "ResponseFromClient";
using (TcpListener listener = new TcpListener())
{
listener.Blocking = true;
listener.Listen(PORT);
TcpSocket clientSock = new TcpSocket();
var connectionResult = clientSock.ConnectAsync("localhost", PORT).Result;
var status = listener.Accept(out TcpSocket serverSock);
NetPacket packet = new NetPacket();
NetPacket clientPacket = new NetPacket();
packet.WriteString(serverMessage);
// Send message to client.
Assert.AreEqual(SocketStatus.Done, serverSock.Send(packet));
// Read message from server.
Assert.AreEqual(SocketStatus.Done, clientSock.Receive(clientPacket));
Assert.AreEqual(serverMessage, clientPacket.ReadString());
// Send message back to server.
clientPacket.Clear(SerializationMode.Writing);
clientPacket.WriteString(clientMessage);
Assert.AreEqual(SocketStatus.Done, clientSock.Send(clientPacket));
// Read message from client.
Assert.AreEqual(SocketStatus.Done, serverSock.Receive(packet));
Assert.AreEqual(clientMessage, packet.ReadString());
clientSock.Dispose();
serverSock.Dispose();
packet.Dispose();
clientPacket.Dispose();
}
}
public void LifecycleTest()
{
TcpSocket socket = new TcpSocket();
Assert.IsFalse(socket.Connected);
socket.Connect(new DnsEndPoint("www.google.com", 80));
Assert.IsTrue(socket.Connected);
byte[] data = Encoding.ASCII.GetBytes(@"GET / HTTP/1.1
");
socket.Send(data, 0, data.Length, SocketFlags.None);
byte[] responseData = new byte[128];
socket.Receive(responseData, 0, SocketFlags.None);
string response = Encoding.ASCII.GetString(responseData);
socket.Dispose();
}
/// <summary>
/// Begins receiving data from the remote endpoint. If the buffer already
/// contains data it will wait anyway for additional remote data. The handler
/// will be notified in asynchronous way.
/// </summary>
/// <param name="handler">An instance of the incoming message handler.</param>
public void Receive(NetworkIncomingMessageHandler handler)
{
if (listener.IsAvailable(identifier))
{
int receiveOffset;
int receiveSize;
if (offset + length >= memory.Length)
{
receiveOffset = offset + length - memory.Length;
receiveSize = offset - (offset + length) % memory.Length;
}
else
{
receiveOffset = offset + length;
receiveSize = memory.Length - offset - length;
}
socket.Receive(new SocketBuffer(memory.Data, receiveOffset, receiveSize), context => OnReceived(context, handler));
}
}
private async void OnAccepted(TcpSocketAccept data)
{
if (data.Status == SocketStatus.OK)
{
socket.Accept(OnAccepted);
}
if (data.Status == SocketStatus.OK)
{
TcpSocket other = data.Connection;
byte[] bytes = new byte[1024];
while (true)
{
TcpSocketReceive received = await other.Receive(bytes);
SocketBuffer buffer = new SocketBuffer(bytes, 0, received.Count);
if (received.Count == 0)
{
break;
}
if (received.Status != SocketStatus.OK)
{
break;
}
TcpSocketSend sent = await other.Send(buffer);
if (sent.Status != SocketStatus.OK)
{
break;
}
}
other.Dispose();
}
}
public async Task CanReceiveDataUsingTasksToExampleSite()
{
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 80);
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] data = Encoding.ASCII.GetBytes(request);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
await socket.Connect(endpoint);
await socket.Send(data);
await socket.Receive(data);
}
}
public void Handle(TcpSocket socket)
{
socket.Receive(data, OnReceived);
}