C＃NetworkStream数据丢失

Question

I am currently working on a networking project where I worked out a binary protocol. My packets look like this: [1 byte TYPE][2 bytes INDEX][2 bytes LENGTH][LENGTH bytes DATA]

And here's the code where I am receiving the packets:

NetworkStream clientStream= Client.GetStream();
while (Client.Connected)
{
    Thread.Sleep(10);
    try
    {
        if (clientStream.DataAvailable)
        {
            byte[] infobuffer = new byte[5];
            int inforead = clientStream.Read(infobuffer, 0, 5);
            if (inforead < 5) { continue; }
            byte[] rawclient = new byte[2];
            Array.Copy(infobuffer, 1, rawclient, 0, 2);
            PacketType type = (PacketType)Convert.ToSByte(infobuffer[0]);
            int clientIndex = BitConverter.ToInt16(rawclient, 0);
            int readLength = BitConverter.ToInt16(infobuffer, 3);
            byte[] readbuffer = new byte[readLength];
            int count_read = clientStream.Read(readbuffer, 0, readLength);
            byte[] read_data = new byte[count_read];
            Array.Copy(readbuffer, read_data, count_read);

            HandleData(read_data, type, clientIndex);
        }
    }
    catch (Exception ex)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine("[E] " + ex.GetType().ToString());
        Console.ResetColor();
        break;
    }
}

Well, and everything works fine... as long as I run it on 127.0.0.1. As soon as I try testing it over long distance, packets somehow get lost, and I am getting an overflow-exception on the line where I convert the first byte to PacketType. Also, if I try to convert the other values to int16, I get very strange values.

I assume the stream somehow looses some bytes on its way to the server, but can this be? Or is it just a little mistake of mine somewhere in the code?

edit: I now edited the code, now it reads till it gets its 5 bytes. But I still get the same exception over long distance...

NetworkStream clientStream = Client.GetStream();
while (Client.Connected)
{
    Thread.Sleep(10);
    try
    {
        if (clientStream.DataAvailable)
        {
            int totalread = 0;
            byte[] infobuffer = new byte[5];
            while (totalread < 5)
            {
                int inforead = clientStream.Read(infobuffer, totalread, 5 - totalread);
                if (inforead == 0)
                { break; }
                totalread += inforead;
            }
            byte[] rawclient = new byte[2];
            Array.Copy(infobuffer, 1, rawclient, 0, 2);
            PacketType type = (PacketType)Convert.ToSByte(infobuffer[0]);
            int clientIndex = BitConverter.ToInt16(rawclient, 0);
            int readLength = BitConverter.ToInt16(infobuffer, 3);
            byte[] readbuffer = new byte[readLength];
            int count_read = clientStream.Read(readbuffer, 0, readLength);
            byte[] read_data = new byte[count_read];
            Array.Copy(readbuffer, read_data, count_read);

            HandleData(read_data, type, clientIndex);
        }
    }
    catch (Exception ex)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine("[E] " + ex.GetType().ToString());
        Console.ResetColor();
        break;
    }
}

PacketType is an enum:

public enum PacketType
{
    AddressSocks5 = 0,
    Status = 1,
    Data = 2,
    Disconnect = 3,
    AddressSocks4 = 4
}

Answer 1

So many things you're doing wrong here... so many bugs... where to even start...

First Network polling? Really? That's just a naïve way of doing network activity in this day and age.. but I won't harp on that.

Second, with this type of protocol, it's pretty easy to get "out of sync" and once you do, you have no way to get back in sync. This is typically accomplished with some kind of "framing protocol" which provides a unique sequence of bytes that you can use to indicate the start and end of a frame, so that if you ever find yourself out of sync you can read data until you get back in sync. Yes, you will lose data, but you've already lost it if you're out of sync.

Third, you're not really doing anything huge here, so I shamelessly stole the "ReadWholeArray" code from here, it's not the most efficient, but it works and there is other code there that might help:

http://www.yoda.arachsys.com/csharp/readbinary.html

Note: you don't mention how you are serializing the length, type and index values on the other side. So using the BitConverter may be the wrong thing depending on how that was done.

if (clientStream.DataAvailable)
{
    byte[] data = new byte[5];
    // if it can't read all 5 bytes, it throws an exception
    ReadWholeArray(clientStream, data);
    PacketType type = (PacketType)Convert.ToSByte(data[0]);
    int clientIndex = BitConverter.ToInt16(data, 1);
    int readLength = BitConverter.ToInt16(data, 3);

    byte[] rawdata = new byte[readLength];
    ReadWholeArray(clientStream, rawdata); 
    HandleData(rawdata, type, clientIndex);
}

/// <summary>
/// Reads data into a complete array, throwing an EndOfStreamException
/// if the stream runs out of data first, or if an IOException
/// naturally occurs.
/// </summary>
/// <param name="stream">The stream to read data from</param>
/// <param name="data">The array to read bytes into. The array
/// will be completely filled from the stream, so an appropriate
/// size must be given.</param>
public static void ReadWholeArray (Stream stream, byte[] data)
{
    int offset=0;
    int remaining = data.Length;
    while (remaining > 0)
    {
        int read = stream.Read(data, offset, remaining);
        if (read <= 0)
            throw new EndOfStreamException 
                (String.Format("End of stream reached with {0} bytes left to read", remaining));
        remaining -= read;
        offset += read;
    }
}

Answer 2

I think the problem is in these lines

int inforead = clientStream.Read(infobuffer, 0, 5);
if (inforead < 5) { continue; }

what happen to your previously read data if the length is under 5 byte? you should save the bytes you have read so far and append next bytes so you can have the header completely

Answer 3

You Read 5 - totalRead.

let totalRead equal 5 or more. When that happens you read nothing, and in cases of 1 - 4 you read that many arbitrary bytes. Not 5. You also then discard any result of less then 5.

You also copy at a offset 1 or another offset without really knowing the offset.

BitConverter.ToInt16(infobuffer, 3);

Is an example of this, what is at off 2?

So if it's not that (decoding error) and and not the structure of your data then unless you change the structure of your loop its you who's losing the bytes not the NetworkStream.

Calculate totalRead by increments of justRead when you recieve so you can handle any size of data as well as receiving it at the correct offset.