Question

I’m sending sensor data from an android device to a TCP server in C#. The android client sends the data in fixed size chunks of 32 bytes.

In the server I read the data expecting it would come in full packs, but since TCP is a stream protocol some messages arrive at the server split in two parts. I know that because I can watch it with a software called SocketSniff.

The problem is that I don’t know how to handle it on my server.

All examples I found use the NetworkStream.Read(), in this method I have to pass a array of bytes to store the data read, an offset and the number of bytes to read. This array of bytes must have a know size, in my case 32.

I don’t know the real size of the message that arrived on my server, but it could be one of the following situations.

• If the received data size is 32 bytes, it’s all OK.

• If the received data size if greater than 32 bytes, I think I’m loosing data.

• If the received data size is less than 32 bytes, lets say 20 bytes, these bytes are stored in my array and the last 12 bytes of the array remain with the value of zero. Since I may be really receiving some zeros there’s no way to know the size I really received, so I can’t merge it with the remaining data which should come in the next reading.

My code which handles the receiving is the following:

    int buffer = 32;
    ...
    private void HandleClientComm(object client)
    {
        TcpClient tcpClient = (TcpClient)client;
        NetworkStream clientStream = tcpClient.GetStream();

        byte[] message = new byte[buffer];
        int bytesRead;

        while (true)
        {
            bytesRead = 0;

            try
            {
                bytesRead = clientStream.Read(message, 0, message.Length);
            }
            catch
            {
                break;
            }

            if (bytesRead == 0)
            {
                // Connection closed
                break;
            }

            SensorData sensorData = ProcessTcpPacket(message);
        }
        tcpClient.Close();
    }

Is there any way to know the size of the data I’m receiving in the socket?

Answer 1

Well, yes, you have the bytesRead variable – it holds the number of bytes read from the stream. You will read at most message.Length bytes, but you may read less.

Note that if there are more bytes available, you will not lose them by reading just message.Length bytes. Rather, they will be available for you next time you read from the stream.

What you need to do is add another while loop liked this:

int messageRead = 0;

while(messageRead < message.Length)
{ 
    int bytesRead = clientStream.Read(message, messageRead, message.Length - messageRead);
    messageRead += bytesRead;
    if(bytesRead==0)
        return;   // The socket was closed
}
// Here you have a full message