C FIFO crashes when writer goes faster than reader - c

Question

I have a parent and child process using fork who communicate using a FIFO pipe. The program will sometimes work and other times it will crash when the writer process (parent) goes faster than the reader process (child).
The following code is what I currently have.
void writeprocess(char* text);
void readprocess(void);
#define FIFO_NAME "MYTESTFIFO"
#define MAX 200
int main(int argc, const char * argv[]) {
pid_t pid;
pid = fork();
if(pid==0){
printf("Started child process.\n");
mkfifo(FIFO_NAME, 0666);
readprocess();
printf("Child process finished.\n");
exit(EXIT_SUCCESS);
}
else{
printf("Started parent process.\n");
mkfifo(FIFO_NAME, 0666);
writeprocess("Message 1");
writeprocess("Message 2");
writeprocess("Message 3");
writeprocess("Message 4");
writeprocess("terminate");
printf("Waiting for child process to finish.\n");
int returnStatus;
waitpid(pid, &returnStatus, 0);
printf("Parent process also finished.\n");
exit(EXIT_SUCCESS);
}
}
void writeprocess(char* text){
FILE *fp;
char *send_buf;
fp = fopen(FIFO_NAME, "w");
asprintf( &send_buf, "%s\n", text);
if ( fputs( send_buf, fp ) == EOF )
{
fprintf( stderr, "Error writing data to fifo\n");
exit( EXIT_FAILURE );
}
printf("Message send: %s", send_buf);
free( send_buf );
fclose(fp);
}
void readprocess(){
sleep(1);
FILE *fp;
char *str_result = NULL;
char recv_buf[MAX];
int stringdifference = 1;
while (stringdifference)
{
fp = fopen(FIFO_NAME, "r");
str_result = fgets(recv_buf, MAX, fp);
if ( str_result != NULL )
{
printf("Message received: %s", recv_buf);
}
fclose( fp );
stringdifference = strncmp(str_result, "terminate", 9);
}
}
When the writer writes faster to the FIFO pipe than the reader can read, I get an exit error with the following message: "Terminated due to signal 13". How can I avoid this from happening while keeping my program run at full performance?
I do want the parent process to be able to end the process and I have to keep working using a FIFO pipe.

Answer 1

When the writer writes faster to the FIFO pipe than the reader can read, I get an exit error with the following message: "Terminated due to signal 13".
You have mischaracterized the nature of the problem. As your other answer already observes, signal 13 is SIGPIPE, which is delivered if you try to write to a pipe that has no readers.
There is normally some (limited) protection against entering that situation with FIFOs, in that opening one end of a FIFO blocks until the other end is opened as well. Therefore if a process opens a FIFO successfully, it knows that there is initially another process with the other end open. The one with the write end open can then expect a high likelihood of writing successfully (but not necessarily without blocking). As soon as the last reader closes the FIFO, however, further attempts to write to it will cause a SIGPIPE to be delivered to the writer. Of course, if the same or a new reader opens the FIFO, that permits writing to resume -- something that's possible with a FIFO, but not with an ordinary pipe.
So the problem is not that the reader does not keep up, but rather that it keeps opening and closing the FIFO. This creates a race condition, in that there are multiple intervals in which the writer will elicit a SIGPIPE if it tries to write. Since the writer also repeatedly opens and closes the FIFO, it follows that to receive a SIGPIPE, the writer must reopen the FIFO before the reader closes it after a previous message, but that doesn't mean the writer is outpacing the reader. The reader cannot finish reading a given message before the writer finishes writing it, so their behaviors are staggered. The writer does nothing else between closing the FIFO and reopening it, so it is not surprising that it sometimes reopens before the reader closes.
The solution is simple: have each process keep the pipe open continuously until it is done communicating with the other. There is no upside to opening and closing for each message, but plenty of downside. For your particular use, however, it may be beneficial to put the writer's stream in line-buffered mode (setvbuf(); default will be fully-buffered).

Answer 2

Signal 13 is SIGPIPE. This happens because nobody is reading from the FIFO.
You cannot write to a FIFO if there is no process that currently has that FIFO open for reading. If you try to do this, your process will get SIGPIPE (which can be ignored, which turns it into EPIPE... but either way, it fails).
One way to handle this correctly:
Create the FIFO in the parent.
Fork.
In the writer process, open it for writing. This will block until the reader has opened it. Keep it open.
In the reader process, open it for writing. This will block until the writer has opened it. Keep it open.