Named Pipes with streams [C]

Question

I've just started to learn Fifos in C and I've written the following program to test their funcionalities:

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>


void error(){
    printf("Error occured: %s\n", strerror(errno));
    exit(EXIT_FAILURE);
}

int main (int argc, char* argv[]){
    const char fifoName[] = "test";
    unlink(fifoName);
    if(mkfifo(fifoName, 0700) < 0)
        error();
    pid_t pid ;
    if((pid=fork()) < 0)
        error();

    if (pid == 0){
        FILE *f = fopen(fifoName, "r");
        puts("\nchild started writing\n");
        for(size_t i = 0; i < 10 ; i++){
            fputc(i + 48, f);
            fputc(i+48, stdout);
        }
        puts("\nchild finished writing\n");
        fclose(f);
    }
    else{
        FILE *f = fopen(fifoName, "w");
        puts("parent started reading");
        while(!feof(f)){
            char c = fgetc(f);
            if(c != EOF)
                putc(c, stdout);
        }
        puts("parent finised reading");
        fclose(f);

    }


    unlink(fifoName);
    return 0;
}

The problem is that the parent process (the reader) doesn't terminate, on the contrary, it keeps reading EOF chars even after the child has finished writing correctly. As you can see I decided to use FILE* streams, opening them in read and write mode depending on the process. By doing so I have the standard functions fprintf, fscanf etc and overall I have the buffered-derived performance of the streams. Could this implementation be the reason behind the problematic behaviour?

Answer 1

As I noted in a comment, you have the read/write modes on the fopen() calls backwards — you try to write to the file stream you open for reading and try to read from the stream you open for writing.

You should also note while (!feof(file)) is always wrong. Actually, the loop should be:

int c;
while ((c = fgetc(f)) != EOF)
    putchar(c);  // or putc(c, stdout);

Note that the return value from fgetc() is an int, not char; that's because the function can return any char value and also one distinctive value, EOF.

This code works:

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>   /* mkfifo() */
#include <unistd.h>

static void error(void)
{
    printf("Error occurred: %s\n", strerror(errno));
    exit(EXIT_FAILURE);
}

int main(void)
{
    const char fifoName[] = "test";
    unlink(fifoName);
    if (mkfifo(fifoName, 0700) < 0)
        error();
    pid_t pid;
    if ((pid = fork()) < 0)
        error();

    if (pid == 0)
    {
        FILE *f = fopen(fifoName, "w");
        puts("\nchild started writing");
        for (size_t i = 0; i < 10; i++)
        {
            fputc(i + '0', f);
            fputc(i + '0', stdout);
        }
        puts("\nchild finished writing\n");
        fclose(f);
    }
    else
    {
        FILE *f = fopen(fifoName, "r");
        puts("parent started reading");
        int c;
        while ((c = fgetc(f)) != EOF)
            putc(c, stdout);
        puts("\nparent finished reading");
        fclose(f);
    }

    unlink(fifoName);
    return 0;
}

Output:

child started writing
0123456789
child finished writing

parent started reading
0123456789
parent finished reading

The output sequence above was the most common one I saw, but is not guaranteed — sometimes the parent's output is partially interleaved with the child's output.

It would be worth upgrading the error() function so it takes a string which you can use to identify where the error occurred and so that it writes to stderr (standard error stream) rather than stdout:

static void error(const char *tag)
{
    fprintf(stderr, "%s: error %d (%s)\n", tag, errno, strerror(errno));
    exit(EXIT_FAILURE);
}

A more general version of the function would prefix the error message with the program name, which would be derived from argv[0]. (I removed the arguments to main() since they were unused and my default compiling options reject code defining unused variables.). You can find my (moderately complex) version of similar error reporting routines in my SOQ (Stack Overflow Questions) repository on GitHub as files stderr.c and stderr.h in the src/libsoq sub-directory. You can find analogous code as err(3), available on at least BSD (macOS) and Linux.