Re-reading from a named pipe when writers come and go.

Question

I've got a problem where I have to read from a named pipe. I have to handle the situation where writers to the named pipe come and go but I need to keep the same pipe open throughout my applications.

I have summarised this in the following code.

int main( int c, char *v[] )
{
    int rfd;
    if ( (rfd = open( PIPENAME, O_RDONLY | O_NONBLOCK )) < 0 )
    {
        perror( "open" );
        return 1;
    }

    char buffer[ 1024000 ];

    // used to give select an upper bound on number of fds
    int nfd = rfd + 1;

    fd_set rfds;
    FD_ZERO( &rfds );
    FD_SET( rfd, &rfds );

    while( true )
    {
        int nr = select( nfd, &rfds, NULL, NULL, NULL );

        if ( nr < 0 )
        {
            perror( "select" );
            break;
        }

        if ( FD_ISSET( rfd, &rfds ) )
        {
            //std::cout << "RFD SET" << std::endl;
            // Ok, we have data we can read
            int nread = read( rfd, buffer, sizeof( buffer ) );
            if ( nread < 0 )
            {
                perror( "read" );
                break;
            }
            else if ( nread == 0 )
            {
                std::cout << "read 0" << std::endl;
            }
            else
            {
                std::cout << "read " << nread << " bytes" << std::endl;

            }

        }
    }

    close( rfd );

    return 0;
}

The problem I have is that after the first process writes to the named pipe and the disconnects (closes) it's end, my program doesn't block on the select. It effectively has the rfd set and the read returns zero bytes read in a tight loop.

I need the rfd to be in NON_BLOCKING mode or the open will block until a writer appears.

I've tried using fcntl to set to BLOCKING mode but that doesn't work either.

My limited understanding of the semantics of the pipe makes me think that I need to clear the EOF state on the pipe such that select will now block. However, I've no idea how to do this.

I throw myself on your collective wisdom :) Mark.

Answer 1

OK, I've come up with one solution but I'm not really happy with it. It's a bit of a "hammer to crack a nut" if you ask me.

.....
else if ( nread == 0 )   
{   
    std::cout << "read 0" << std::endl;   

    FD_ZERO( &rfds );
    close( rfd );
    if ( (rfd = open( PIPENAME, O_RDONLY | O_NONBLOCK )) < 0 )
    {
        perror( "re-open" );
        break;
    }
    FD_SET( rfd, &rfds );
    nfd = std::max( wfd, rfd ) + 1;
}   
else
.....

Basically, I close and re-open the pipe.

I'd still welcome a better solution.

Answer 2

Have you tried opening the fds in non-blocking mode, and when your read() returns EWOULDBLOCK/EAGAIN, doing a clearerr() on the fd?