winsock recv() duplicates/missing data - c++

Question

I'm writing a simple server/client program to send a file from client to server.
i'm using winsock2. I'm limiting the capacity to send the data each time to 5000.
client side (send):
int iResult = 0;
int totalBytesSent = 0;
while (length > 0){
iResult = send( _connectSocket, data, MAX_TRANSIT_SIZE, 0 ); // MAX_TRANSIT_SIZE is 5000
if (iResult == SOCKET_ERROR) {
printf("send failed with error: %d\n", WSAGetLastError());
return closeSocket();
}
totalBytesSent += iResult;
length -= iResult;
//cout << "Data sent (" << iResult << " Bytes)" << endl;
}
cout << "Total Bytes Sent: (" << totalBytesSent << ")" << endl;
return 0;
on the server side (recv):
// Receive and send data
char recvbuf[MAX_DATA_SIZE];
int iResult = 0;
int totalBytesRead = 0;
// Receive until the peer shuts down the connection
do {
totalBytesRead += iResult;
iResult = recv(_clientSocket, recvbuf, MAX_DATA_SIZE, 0);
if (iResult > 0) {
//printf("RECEIVED DATA\n");
//printf("Bytes received: %d\n", iResult);
} else if (iResult == 0)
printf("Connection closing...\n");
else {
printf("recv failed: %d\n", WSAGetLastError());
closesocket(_clientSocket);
WSACleanup();
return 1;
}
} while (iResult > 0);
cout << "Total Bytes Received: (" << totalBytesRead << ")" << endl;
The problem:
After running client and server and sending a file, it does say the correct data size sent/received (which is of course the file size in bytes), BUT the output file is different, and when I open it with some text editor (notepad++) I can clearly see that the output file holds less data (but File->Properties shows same file sizes) and some data is duplicates.
My Question:
How do revc() works? If it's receiving data in many calls, does it accumulates it in the buffer? (In my case: recvbuf) or does it rewrite the buffer?
As far as I figured out, it does accumulate, so my code is correct??
Thanks.

Answer 1

There are several issues in your code.
Client side:
send( _connectSocket, data, MAX_TRANSIT_SIZE, 0 );
Here you never update data to account for the bytes already sent, so every time you call send it sends the same data again and again (the first MAX_TRANSIT_SIZE bytes of your data buffer). A quick fix, assuming data is a pointer to any byte type (uint8_t, char, ...) would be:
send( _connectSocket, data + totalBytesSent, MAX_TRANSIT_SIZE, 0 );
You should also cap the data size you send, because unless length is originally a multiple of MAX_TRANSIT_SIZE you'll have a buffer overrun when you reach the end of the data:
send( _connectSocket, data + totalBytesSent, std::min(length, MAX_TRANSIT_SIZE), 0 );
Server side:
recv(_clientSocket, recvbuf, MAX_DATA_SIZE, 0);
Just like with send, recv has no notion of "what did I already receive in that buffer". So every time you call recv it just put the new data it receives at the beginning of your buffer, overwriting the older data. This may or may not be what you want, this is hard to tell since you don't show us how you use that buffer. You may want to use the same approach to manage your receive buffer than the one I just explained for your send buffer.

Answer 2

I don't see where you're writing out of the recvbuf. Each time you call recv it is going to overwrite what is already in the recvbuf. Therefore, where you have the commented out "RECEIVED DATA" prints, you should be copying the data you want to keep out of the buffer.