How do open child sockets get closed? - c

Question

I have spawned a child process on a while(1) loop that appears to accept ongoing TCP connections. I am looking for confirmation of 'normal' behaviour of a socket child process, assuming the parent process is not dead (I found plenty of advice on how to kill child processes when the parent is dead...).
void
dostuff (int sock, int* count)
{
while(1){
*count = *count +1;
char cnt[20];
sprintf(cnt, "count: %d\n", *count);
int n;
char buffer[bufsize];
bzero(buffer,bufsize);
n = read(sock,buffer,bufsize);
if (n < 0) error("ERROR reading from socket");
fprintf(stderr,"From the client:\n%s",buffer);
char reply[bufsize];
bzero(reply, bufsize);
strcat(reply, cnt);
n = write(sock, reply, bufsize);
if (n < 0) error("ERROR writing to socket");
}
}
I suspect the child process will automatically close when its TCP session is finished, is this correct?
It appears when reconnecting to its current TCP session, the child in effect start at the top of the while loop, incrementing count before reading and writing. Can I rely on this behaviour? Or make it reliable?

Answer 1

So first coding problems: the fprintf(stderr,"From the client:\n%s",buffer);. Even if buffer is inited with zeros you may get bufsize bytes, so the fprintf will read data after end of buffer. And you are in a loop so each read could gives a different size, so you may whatever print "garbage" from previous buffer content.
You should use functions that takes a number of chars to write (i.e. fwrite).
An other point is more a "style" problem: you get n bytes from your read, so why writing back bufsize bytes and not n? The only advantage is to have "constant size" messages.
For the inner loop none of the functions in it are able to leave this loop, or the function, or the program.
You must explicitly leave the loop (using break) or the function (using return) or even the program (with exit), depending on your needs.
In its current state the function reads from the socket. It then prints an error message but continues its job (it is up to you to decide what to do in case of read error). After it prints the message (probably the previous one as you don't clean content) and writes to the socket, which will fail (if the socket is closed, you can't read, you can't write).
So here the main point for you: trying to read/write from/to a closed socket just returns -1 from read/write functions. It's up to you to decide what to do after that.
The function should looks like:
void dostuff (int sock, int* count) {
while(1){
int n;
*count = *count + 1;
char buffer[bufsize];
n = read(sock,buffer,bufsize);
if (n <= 0) {
error("ERROR reading from socket (or EOF)");
close(sock); // close our side whatever
break; // leave the loop (or return)
}
fprintf(stderr,"From the client:\n");
fwrite(buffer, 1, n, stderr); // write the n elements
char reply[bufsize];
reply[0] = '\0'; // no need to clear all buffer
strcat(reply, cnt);
n = write(sock, reply, n); // just write N elements
if (n < 0) {
error("ERROR writing to socket");
close(sock); // close our side whatever
break; // not able to write -> problem
}
}
}