Using Named Pipes (FIFOs) with Bash

 in

It's hard to write a bash script of much import without using a pipe or two. Named pipes, on the other hand, are much rarer.

Like un-named/anonymous pipes, named pipes provide a form of IPC (Inter-Process Communication). With anonymous pipes, there's one reader and one writer, but that's not required with named pipes—any number of readers and writers may use the pipe.

Named pipes are visible in the filesystem and can be read and written just as other files are:

$ ls -la /tmp/testpipe
prw-r--r-- 1 mitch users 0 2009-03-25 12:06 /tmp/testpipe|

Why might you want to use a named pipe in a shell script? One situation might be when you've got a backup script that runs via cron, and after it's finished, you want to shut down your system. If you do the shutdown from the backup script, cron never sees the backup script finish, so it never sends out the e-mail containing the output from the backup job. You could do the shutdown via another cron job after the backup is "supposed" to finish, but then you run the risk of shutting down too early every now and then, or you have to make the delay much larger than it needs to be most of the time.

Using a named pipe, you can start the backup and the shutdown cron jobs at the same time and have the shutdown just wait till the backup writes to the named pipe. When the shutdown job reads something from the pipe, it then pauses for a few minutes so the cron e-mail can go out, and then it shuts down the system.

Of course, the previous example probably could be done fairly reliably by simply creating a regular file to signal when the backup has completed. A more complex example might be if you have a backup that wakes up every hour or so and reads a named pipe to see if it should run. You then could write something to the pipe each time you've made a lot of changes to the files you want to back up. You might even write the names of the files that you want backed up to the pipe so the backup doesn't have to check everything.

Named pipes are created via mkfifo or mknod:

$ mkfifo /tmp/testpipe
$ mknod /tmp/testpipe p

The following shell script reads from a pipe. It first creates the pipe if it doesn't exist, then it reads in a loop till it sees "quit":

#!/bin/bash

pipe=/tmp/testpipe

trap "rm -f $pipe" EXIT

if [[ ! -p $pipe ]]; then
    mkfifo $pipe
fi

while true
do
    if read line <$pipe; then
        if [[ "$line" == 'quit' ]]; then
            break
        fi
        echo $line
    fi
done

echo "Reader exiting"

The following shell script writes to the pipe created by the read script. First, it checks to make sure the pipe exists, then it writes to the pipe. If an argument is given to the script, it writes it to the pipe; otherwise, it writes "Hello from PID".

#!/bin/bash

pipe=/tmp/testpipe

if [[ ! -p $pipe ]]; then
    echo "Reader not running"
    exit 1
fi


if [[ "$1" ]]; then
    echo "$1" >$pipe
else
    echo "Hello from $$" >$pipe
fi

Running the scripts produces:

$ sh rpipe.sh &
[3] 23842
$ sh wpipe.sh
Hello from 23846
$ sh wpipe.sh
Hello from 23847
$ sh wpipe.sh
Hello from 23848
$ sh wpipe.sh quit
Reader exiting

Note: initially I had the read command in the read script directly in the while loop of the read script, but the read command would usually return a non-zero status after two or three reads causing the loop to terminate.

while read line <$pipe
do
    if [[ "$line" == 'quit' ]]; then
        break
    fi
    echo $line
done
______________________

Mitch Frazier is an Associate Editor for Linux Journal.

Comments

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Problems with trap

nick.dap's picture

You should explicitly exit from the trap command, otherwise the script will continue running past it. You should also catch a few other signals.

So: trap "rm -f $pipe" EXIT
Becomes: trap "rm -f $pipe; exit" INT TERM EXIT

Excellent article. Thank you!

Not really necessary in this case

Mitch Frazier's picture

The EXIT trap gets executed when the shell exits regardless of why it exits so trapping INT and TERM aren't really necessary in this case.

However, your point about "exit" is good: trapping a signal removes the default action that occurs when a signal occurs, so if the default action is to exit the program and you want that to happen in addition to executing your code, you need to include an exit statement in your code.

Mitch Frazier is an Associate Editor for Linux Journal.

multiple readers

Fahd Shariff's picture

Thanks, good post.

One point to note, is that if you have multiple readers reading from the same pipe, only one of the readers will receive the output.

named pipe

neil's picture

I find named pipes of most use in feeding programs with data from network connections. Just make sure the program does not try to rewind the file.

mkfifo input
programxyz -f input
nc -lvvp 20000 > input

and on same macine or another send data to port 20000.

wow

dm's picture

Excellent article!

It's a nice complement to the famous Linux Journal Hall of Famer
http://www.linuxjournal.com/article/2156
by Andy Vaught.

With respect to your initial reader's implementation
while read line <$pipe
it seems to be a valid piece (meaning the redirection is pertinent to the "read", now the while loop; where the pipe would have been opened once.)

Another observation concerns a slightly modified final reader code:

while true; do
    if read line <$pipe; then
        if [[ "$line" == 'quit' ]]; then
            break
        else
            echo oops   #  Should not be executed
        fi
        echo $line
    fi
done

"echo oops" should not be - I think - ever executed, since "read" opens the pipe, reads one line and breaks, then opens it again and blocks waiting for input; however a simple test shows that it does:

for ((i = 0; i < 1000; i++)); do
   ./wpipe.sh
done

oops
line: Hello from 27952
line: Hello from 27953
oops
line: Hello from 27954
oops
line: Hello from 27955

I guess that's a "Steven's UNIX Network Programming" moment - need to finally open and read it :-)

correction

dm's picture

misplaced the "ops" :-)
correction to the above

while true
do
    if read line <$pipe; then
        if [[ "$line" == 'quit' ]]; then
            break
        fi
        echo "line: $line"
    else
        echo oops  # Should not be executed.
    fi
done

now it seems to be correct.

Very useful

Anonymous's picture

Thank you for this - I didn't even know these existed - I have always used files for IPC between shell scripts. I guess I'm still a shell noob at heart ;)

White Paper
Linux Management with Red Hat Satellite: Measuring Business Impact and ROI

Linux has become a key foundation for supporting today's rapidly growing IT environments. Linux is being used to deploy business applications and databases, trading on its reputation as a low-cost operating environment. For many IT organizations, Linux is a mainstay for deploying Web servers and has evolved from handling basic file, print, and utility workloads to running mission-critical applications and databases, physically, virtually, and in the cloud. As Linux grows in importance in terms of value to the business, managing Linux environments to high standards of service quality — availability, security, and performance — becomes an essential requirement for business success.

Learn More

Sponsored by Red Hat

White Paper
Private PaaS for the Agile Enterprise

If you already use virtualized infrastructure, you are well on your way to leveraging the power of the cloud. Virtualization offers the promise of limitless resources, but how do you manage that scalability when your DevOps team doesn’t scale? In today’s hypercompetitive markets, fast results can make a difference between leading the pack vs. obsolescence. Organizations need more benefits from cloud computing than just raw resources. They need agility, flexibility, convenience, ROI, and control.

Stackato private Platform-as-a-Service technology from ActiveState extends your private cloud infrastructure by creating a private PaaS to provide on-demand availability, flexibility, control, and ultimately, faster time-to-market for your enterprise.

Learn More

Sponsored by ActiveState