Truncated Buffer - c

Question

I'm trying to troubleshoot a strange C programming problem.
I'm entering a URL on a client program and then transferring that URL to a server program. The only issue is, that when the server program receives the URL it's missing it's first two characters. So, if the url is http://www.google.com what the server reports is receiving is "tp://www.google.com."
The weird thing is that it's not some partial send problem. I'm checking on the number of bytes sent and it's claiming that the entire message is sent. The issue is that on the receiving end it's only claiming that it's getting a small chunk of the data. The receiver reports back that it's received the message length -2. Here is the code on the receiving end:
printf("%s \n", "Connected. Receive length of URL to wget.");
if ((messageSize = recv(acceptDescriptor, &urlLength, sizeof (int), 0)) == -1) {
perror("recv URL length");
exit(1);
}
urlSizeInt = atoi(urlLength);
char url[urlSizeInt];
printf("%s %d \n", "urlSizeInt: ", urlSizeInt);
printf("%s \n", "Receive URL to wget.");
if((messageSize = recv(acceptDescriptor, &url, 13, 0)) == -1) {
perror("recv URL");
exit(1);
}
Sending code:
printf("%s \n", "Connected");
//connected to first stepping stone in the chain.
//transfer the length of the URL
if (send(socketDescriptor, urlLengthStr, strlen(urlLengthStr), 0) == -1){
perror("send URL Length");
exit(0);
}
//transfer the URL
printf("%s %d \n", "strenlen(url): ",strlen(url));
printf("%s %s \n", "url: ",url);
int sent;
int totalSent=0;
if((sent=send(socketDescriptor, url, strlen(url), 0))==-1){
perror("send URL");
exit(0);
}
printf("%s %d \n", "sent: ",sent);
Send Output:
Connected
strenlen(url): 13
url: http://www.cs
sent: 13
Receive Output:
Connected. Receive length of URL to wget.
urlSizeInt: 13
Receive URL to wget.
messageSize: 11
URL Received: tp://www.cs
Code to encode the length as a char for sending:
char* url = "http://www.cs";
int urlLength = strlen(url);
char* urlLengthStr;
sprintf(urlLengthStr, "%d", urlLength);

Answer 1

Thanks for posting the full code. the problem lies in the way you send the UrlLength. Because you always recv sizeof(int) bytes, your first read is consuming the first bytes of the sent URL.
Start from the beginning - assume you don't send the URL Length.
Problem : URLs are variable length. How can the receiver know when it's read it all?
Solution : Send the length before
This is fine, unless you encode the length as a string, because that introduces another problem
Problem : The URL length may be variable length ("1", "12","1234"). How can the receiver know when it's read it all?
Solution : Haven't we been here before somewhere...
There are a couple of ways out of this recursive problem:
Solution a : Encode the URL length as a fixed size field. (you can just send the binary representation of an int, although beware of byte ordering problems - or you could encode it as a fixed-width ascii field , e.g, "00000124"
TX (ignoring byte ordering issues mentioned by JimR)
int urlLength = strlen(url);
send(socketDescriptor, &urlLength, sizeof(int), 0)
RX:
int urlLength;
recv(socketDescriptor, &urlLength, sizeof(int), 0)
Solution b: Use a termination character (often null, or linefeed) to indicate the end of the URL. Just read bytes in a loop until the terminator is reached. This also solves the 'partial recv' problem you would otherwise encounter.

Answer 2

When you're reading from a socket, you're reading a stream, not a file.
See here for good guidelines for writing network code.
Even though the sending side may have sent all the data at once, that does not guarantee that you will see all the data at once. You have to loop on recv, taking into account the number of bytes received for each call. If recv returns 0 the socket was closed or there was an error and you will receive no more data from that socket.
With those things in mind... Kinda sorta pseudo code, I didn't test this, but hope it gives you the idea:
int expectedLength = readLengthFromSocket( socket, sizeof( int ) );
int bytesRead = 0;
char buffer[expectedLength];
bytesRead = recv( socket, buffer, ... );
runningLength = 0;
if( bytesRead < 1 )
// Socket closed or there was an error, handle that here
else
{ runningLength += bytesRead;
while( runningLength < expectedLength )
{
bytesRead = recv( socket, buffer + runningLength, ... );
if( bytesRead < 1 )
// Socket closed or there was an error, handle that here
break;
else
runningLength += bytesRead;
}
}
Note that reading and writing int, long, long long, short and the unsigned variants over the network typically require byte swapping. Reading a buffer of bytes does not.
See here for an explanation.