Bad TCP Checksum?!

Hallo zusammen,
mir ist etwas sehr seltsames passiert.
Ich sende mit folgendem Code eine Antwort auf einen zuvor eingetroffenen Request. Diese Antwort soll u.a. ein Screenshot sein, die Bytes sind mittels Base64 codiert.

TcpClient client = (TcpClient)arg;
NetworkStream stream = client.GetStream();
... //Request empfangen und auswerten
byte[] response = Encoding.ASCII.GetBytes(answer);
stream.Write(response, 0, response.Length);
stream.Flush();
client.Close();

Bei kleinen Datenmengen von ein paar Byte funktioniert das wunderbar, aber wenn nun ein Screenshot, also größere Datenmengen von einigen MB übertragen werden sollen, kommt beim Client nur ein paar KB an. (Ja, der Client kann Datenmengen von mehr als einer Puffergröße empfangen; Code wie im Beispiel aus NetworkStream.Read())

Nun bin nich dem mittels Wireshark auf Serverseite auf den Grund gegangen. Und nun das verblüffende:
Es werden mehrere TCP-Pakete ordnungsmäßig verschickt, aber irgendwann gehen nur noch Pakete mit einer falschen TCP-Header-Checksum raus!! Alle diese Pakete, wo die richtigen Bilddaten drinstehen, haben die Checksumme 0x0000. Diese kommen dann beim Client höchstwahrscheinlich deswegen nicht an.

Ich hatte eigentlich erwartet, dass .NET es geregelt kriegt, Header Checksummen zu bilden. Deswegen bin ich ziemlich verblüfft.
Eine Google-Suche findet nur einen einzigen Forumsbeitrag (auf einer anderen Seite), die jedoch ohne Antwort blieb.

Habt ihr eine Erklärung/Lösung dafür?

Mit freundlichen Grüßen,
Dawamaha

Ich halte es für ziemlich unwahrscheinlich, das es wirklich am netzwerk liegt. Man beachte: tcp ist nicht paketorientiert und zwerhackstückelt dir alles willkürlich. Wenn du nutr einen befehl zum auslessen verwendest, dann berkommt zu nur das erste teil des Hackbratens.

Probiere es mal wie folgt:

Socket sock=tcpClient.Client;
Action<byte[]> send=(data)=>
{
    int sendPos=0;
    while(sendPos<data.Length)
        sendPos+=sock.Send(data,sendPos,data.Length-sendPos,SocketFlags.None);
};
byte[] response=...;
send(Bitconverter.GetBytes(response.Length));
send(response);
sock.Disconnect();

Socket sock=tcpClient.Client;
Func<int,byte[]> Receive=(num)=>
{
    int receivePos=0;
    byte[] data=new byte[num];
    while(receivePos<num)
        receivePos+=sock.Receive(data,receivePos,data.Length-receivePos,SocketFlags.None);
    return data;
};
int length=BitConverter.ToInt32(Receive(4),0);
byte[] response=Receive(length);

Entschuldige bitte, dass ich mich erst so spät melde.

Erstmal danke für deine Antwort, ich habe jetzt deinen Vorschlag, die Länge der Daten vorne weg zu schicken implementiert und es funktioniert.
Allerdings hatte ich vermutet, dass die Methode, auf die ich verwiesen hatte, auch funktionieren sollte.

Naja, herzlichen Dank nochmal,
Dawamaha

huhu,

noch als Ergänzung: schau dir mal mit Wireshark deinen sonstigen Traffic an. Windows zerhackstückelt sehr viele Cecksums in den Paketen. Diese werden von der Gegenseite im Normalfall aber trotzdem akzeptiert.

Abgesehen davon ist das eigentliche Paket (incl. Checksum) Sache des Treibers, nicht der verwendeten App - hier also Entwarnung.

😃

xynratron

Ich hatte eine ähnliche Diskussion schoneinmal.

ich habe jetzt deinen Vorschlag, die Länge der Daten vorne weg zu schicken implementiert und es funktioniert.

Ich hatte mich innerlich schon auf eine lange , zähe diskussion eingestellt. 😁

Wir können auch gerne diskutieren 😁