// 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); }