TCP socket.receive() seems to drop packets

I am working on client-server appliction in C#. The comunication between them is with TCP sockets. The server listen on specific port for income clients connection. After a new client arrived, his socket being saved in a socket list. I define every new client socket with receive timeout of 1 ms. To receive from the client sockets without blocking my server I use the threadpool like this:

  private void CheckForData(object clientSocket)
        {
            Socket client = (Socket)clientSocket;
            byte[] data = new byte[client.ReceiveBufferSize];
            try
            {
                int dataLength = client.Receive(data);
                if (dataLength == 0)// means client disconnected
                {
                    throw (new SocketException(10054));
                }
                else if (DataReceivedEvent != null)
                {
                    string RemoteIP = ((IPEndPoint)client.RemoteEndPoint).Address.ToString();
                    int RemotePort = ((IPEndPoint)client.RemoteEndPoint).Port;
                    Console.WriteLine("SERVER GOT NEW MSG!");
                    DataReceivedEvent(data, new IPEndPoint(IPAddress.Parse(RemoteIP), RemotePort));
                }
                ThreadPool.QueueUserWorkItem(new WaitCallback(CheckForData), client);
            }
            catch (SocketException e)
            {
                if (e.ErrorCode == 10060)//recieve timeout
                {
                    ThreadPool.QueueUserWorkItem(new WaitCallback(CheckForData), client);
                }
                else if(e.ErrorCode==10054)//client disconnected
                {
                    if (ConnectionLostEvent != null)
                    {
                        ConnectionLostEvent(((IPEndPoint)client.RemoteEndPoint).Address.ToString());
                        DisconnectClient(((IPEndPoint)client.RemoteEndPoint).Address.ToString());
                        Console.WriteLine("client forcibly disconected");
                    }
                }
            }

        }

My problem is when sometimes the client send 2 messages one after another, the server doesn't receive the second message. I checked with wireshark and it shows that both of the messages were received and also got ACK.

I can force this problem to occur when I am putting break point here:

            if (e.ErrorCode == 10060)//recieve timeout
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(CheckForData), client);
            }

Then send the two messages from the client, then releasing the breakpoint.

Does anyone met this problem before?

Jon Skeet
people
quotationmark

my problem is when sometimes the client send 2 messages one after another, the server doesn't receive the second message

I think it's much more likely that it does receive the second message, but in a single Receive call.

Don't forget that TCP is a stream protocol - just because the data is broken into packets at a lower level doesn't mean that one "send" corresponds to one "receive". (Multiple packets may be sent due to a single Send call, or multiple Send calls may be coalesced into a single packet, etc.)

It's generally easier to use something like TcpClient and treat its NetworkStream as a stream. If you want to layer "messages" on top of TCP, you need to do so yourself - for example, prefixing each message with its size in bytes, so that you know when you've finished receiving one message and can start on the next. If you want to handle this asynchronously, I'd suggest sing C# 5 and async/await if you possibly can. It'll be simpler than dealing with the thread pool explicitly.

people

See more on this question at Stackoverflow