Socket programming sending and receiving messages with a loop in C - c

Question

I just started learning socket programming and I'm trying to send and receive between the client and the server using TCP. First I am sending the client the size of the current directory from the server, and the client is receiving it perfectly fine. Then I want to send from the server each file name in the current directly so I created a loop to do so. In the client, I also have a loop for receiving all of the file names that executes as many times as there are files (the directory size). The problem is that when I print out what was received in the loop, the buffer is blank. I realized that the bytes received for the first loop is 55 and the rest are 0 but the buffer is always blank. Here are my code snippets:
Server:
if(strcmp(buffer, "ls-remote") == 0){ //display files from server directory
// get the size of the directory
unsigned long size = htonl(directorySize());
n = send(newsockfd, &size, sizeof(size), 0);
if(n < 0) syserr("can't send to server");
DIR *d = opendir(".");
struct dirent *dir;
if (d)
{
while((dir = readdir(d))!= NULL)
{ memset(&buffer[0], 0, sizeof(buffer)); // clear buffer
strcat(buffer, dir->d_name);
n = send(newsockfd, buffer, strlen(buffer), 0);
if(n < 0) syserr("can't send to server");
}
closedir(d);
}
else{
syserr("Error...could not get files from directory.");
}
}
Client:
if(strcmp(buffer, "ls-remote") == 0){ //display files from server directory
unsigned long size;
n = recv(sockfd, &size, sizeof(uint32_t), 0);// recieve the size of the directory
if(n < 0) syserr("can't receive from server");
size = ntohl(size);
while(size > 0){
memset(&buffer[0], 0, sizeof(buffer)); // clear buffer
n = recv(sockfd, buffer, 255, 0); // recieve directory from server
if(n < 0) syserr("can't send to server");
buffer[strlen(buffer) - 1] = '\0';
printf("recieving: %s\n", buffer); // print directory
size--;
}
}

Answer 1

One problem here is that there is no synchronization between the server sending the size of the directory and the directory entries and the client receiving them. In other words, if the directory contains entry.1, entry.2, and entry.3, the client may receive, for example, entry.1 and entry.2entry.3, or entry.1entry.2 and entry.3. This is true even if unicode is not involved here as a culprit, as suggested by JVene.
A couple other things:
buffer[strlen(buffer) - 1] = '\0'; in the client code will chop off
the last character. It should be buffer[strlen(buffer)] = '\0';
instead.
consistency in type usage with the sizeof() operator is important.
E.g., on my Mac sizeof(long) is 8, while sizeof(uint32_t) is 4.
This leads to even more interesting side-effects of the lack of
synchronization between the client and the server.
The "synchronization" issue here is due to the possibility that by the time the client gets around to reading from the socket, the server has already written several directory entries, so the client will read them all as one string. Things will get even messier if the directory size is written to and read from the socket assuming different buffer size; see above.
After some additional experimentation I have come up with code that seems to work. I'm sure there are improvements that could be made, there are other approaches, and there are scenarios the code doesn't account for, e.g. what if the directory is changing as the programs are running. This is just a proof of concept piece of code that will hopefully help you move in the right direction.
The idea here is for the server to write directory entries to the socket separated by NULL characters. These are then used as delimiters on the client side to tell dir entries apart. See comments in the code.
The server code writing dir entries to the socket:
// Assume maximum entry length is 255
// The buffer is 256 bytes long to accommodate the NULL-terminator.
// The terminator is important for the client as direntry delimiter.
char buffer[256];
// get the size of the directory
unsigned long size = htonl(dirSize());
int n = send(client_sock, &size, sizeof(size), 0);
if(n < 0) puts("can't send size to server");
DIR *d = opendir(".");
struct dirent *dir;
if (d)
{
while((dir = readdir(d))!= NULL)
{
memset(&buffer[0], 0, sizeof(buffer)); // clear buffer
strcat(buffer, dir->d_name);
// Write up to 255 chars of direntry + the NULL-terminator.
n = send(client_sock, buffer, strlen(buffer) + 1, 0);
if(n < 0) puts("can't send entry to server");
}
closedir(d);
}
else{
puts("Error...could not get files from directory.");
}
The client code that reads from the socket:
char buffer[256];
/*
* We need this in case the beginning of a directory entry is in one buffer, but
* the end is in the next.
*/
char buf_1[256];
unsigned long size;
buf_1[0] = 0; // make sure strlen(buf_1) is 0.
int n = recv(sockfd, &size, sizeof(long), 0);// recieve the size of the directory
if(n < 0) puts("can't receive size from server");
size = ntohl(size);
while(size > 0){
memset(&buffer[0], 0, sizeof(buffer)); // clear buffer
n = recv(sockfd, buffer, 255, 0); // keep last element of buffer as 0
if(n < 0) puts("can't receive entry from server");
int _start = 0;
if (strlen(buf_1)) // something left over from previously read buffer
{
// buf_1 contains beginning of an entry, buffer - the end
strcat(buf_1, buffer); // Assume there is a 0-terminator somewhere in buffer
printf("receiving: %s\n", buf_1); // buf_1 now has the entry, print it buf_1[0] = 0; // flag buf_1 as empty
size--; // we are one direntry down
_start += strlen(buffer) + 1; // move _start to char following 0-terminator
}
// Loop while _start is 0 - 254, the char at offset _start is not NULL,
// and there are still entries to retrieve.
while (_start < 255 && *(buffer + _start) && size > 0)
{
if (strlen( buffer + _start ) + _start >= 255) // no null terminator, need buf_1
{
strcpy(buf_1, buffer + _start); // copy unfinished entry to buf_1
// don't decrement size, we haven't extracted a full direntry.
break; // out of the inner while to read more from the socket.
}
else // we have a full direntry
{
printf("receiving: %s\n", buffer + _start); // print it
_start += strlen(buffer + _start) + 1; // move offset to next possible entry
size--; // one entry down
}
}
}
Hope this helps, good luck! Let me know if you have additional questions.