My program hangs and won't break out - c

Question

I am trying to run the LIST command to display the files, but when I run it, it displays all the files like I want it to, but it just hangs there, and doesn't break back to the menu. the last 3 characters of the list is always a newline followed by a period then a newline, so I put that in an if statement to check to break out and close the socket, but it doesnt, am I missing something?
case 'l':
case 'L':
//Handle L case
sprintf(buff, "LIST\n");
send(sockfd, buff, 1000, 0);
int length = strlen(buff);
while ((rsize = recv(sockfd, buff, 1000, 0)) > 0)
{
fwrite(buff, rsize, 1, stdout);
if ( buff[length-3] == '\n' && buff[length-2] == '.' && buff[length-1] == '\n' )
{
break;
}
}
close(sockfd);
break;

Answer 1

Here's your problem:
if ( buff[length-3] ...
length comes from strlen(buff), and buff, at that point, contains the data you sent, not the data you received, so buff[length-3] is probably not even close to the end of your input data, which could be up to 1000 characters long.
You should be concentrating here on rsize, which is the number of bytes you received, rather than length.
EDIT: As was once mentioned in the comments (EDIT 2: and now in a separate answer), you're going to run into problems here any time recv() either unexpectedly stops in the middle of your end-of-line sequence, and particularly if it stops after having read less than three characters, since then you'll be illegally using a negative index to your array. It would be better to write a function to read an entire line from the socket and store it in your buffer, and then just call if ( !strcmp(buffer, ".") ) to know when you're done.
Here's an example:
#include <unistd.h>
#include <errno.h>
#include <string.h>
ssize_t socket_readline(const int socket, char * buffer, const size_t max_len) {
ssize_t num_read, total_read = 0;
bool finished = false;
memset(buffer, 0, max_len);
for ( size_t index = 0; !finished && index < (max_len - 1); ++index ) {
num_read = read(socket, &buffer[index], 1);
if ( num_read == -1 ) {
if ( errno == EINTR ) {
continue; /* Interrupted by signal, so continue */
}
else {
return -1; /* Other read() error, return error code */
}
}
else {
if ( buffer[index] == '\n' ) {
buffer[index] = '\0'; /* Remove newline */
finished = true; /* End of line, so stop */
}
else {
++total_read;
}
}
}
return total_read;
}
Using a system call for each individual character is a bit of an overhead, but if you don't do that you're going to have to store the additional characters you read somewhere, so unless you want to write your own buffering facilities, that's the best option.
As an aside, you should also be checking the return from send() (and from all system calls, for that matter), since that's not guaranteed to send all your characters in one go, and you may need additional tries.

Answer 2

You cant rely on rsize by itself. Think of what happens if one call to recv() ends on the first '\n', and then the next recv() receives the '.'. Or if recv() does not receive >=3 bytes to begin with. You would not be able to check for "\n.\n" in a single if statement like you are trying to do.
What you really should be doing instead is reading the socket data into a buffer until a '\n' is encountered (do not store it in the buffer), then process the buffer as needed and clear it, then repeat until the buffer contains only '.' by itself.
Try something like this:
case 'l':
case 'L':
{
//Handle L case
int linecapacity = 1000;
char *line = (char*) malloc(linecapacity);
if (line)
{
int linelength = 0;
if (send(sockfd, "LIST\n", 5, 0) == 5)
{
bool stop = false;
while (!stop)
{
rsize = recv(sockfd, buff, 1000, 0);
if (rsize <= 0) break;
fwrite(buff, rsize, 1, stdout);
char *start = buff;
char *end = &buff[rsize];
while ((start < end) && (!stop))
{
char *ptr = (char*) memchr(start, '\n', end-start);
if (!ptr) ptr = end;
length = (ptr - start);
int needed = (linelength + length);
if (needed > linecapacity)
{
char *newline = realloc(line, needed);
if (!newline)
{
stop = true;
break;
}
line = newline;
linecapacity = needed;
}
memcpy(buff, &line[linelength], length);
linelength += length;
if ((linelength == 1) && (line[0] == '.'))
{
stop = true;
break;
}
// process line up to linelength characters as needed...
linelength = 0;
start = ptr + 1;
}
}
}
free(line);
}
close(sockfd);
break;
}
Alternatively:
case 'l':
case 'L':
{
//Handle L case
int linecapacity = 1000;
char *line = (char*) malloc(linecapacity);
if (line)
{
int linelength = 0;
if (send(sockfd, "LIST\n", 5, 0) == 5)
{
char ch;
while (true)
{
rsize = recv(sockfd, &ch, 1, 0);
if (rsize < 1) break;
fwrite(&ch, 1, 1, stdout);
if (ch == '\n')
{
if ((linelength == 1) && (line[0] == '.'))
break;
// process line up to linelength characters as needed...
linelength = 0;
}
else
{
if (linelength == linecapacity)
{
char *newline = realloc(line, linecapacity + 1000);
if (!newline)
break;
line = newline;
linecapacity += 1000;
}
line[linelength++] = ch;
}
}
}
free(line);
}
close(sockfd);
break;
}