### 15.1 Creating a Pipe

The primitive for creating a pipe is the `pipe` function. This creates both the reading and writing ends of the pipe. It is not very useful for a single process to use a pipe to talk to itself. In typical use, a process creates a pipe just before it forks one or more child processes (see Creating a Process). The pipe is then used for communication either between the parent or child processes, or between two sibling processes.

The `pipe` function is declared in the header file `unistd.h`.

— Function: int pipe (int filedes`[2]`)

> Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | See POSIX Safety Concepts.

> The `pipe` function creates a pipe and puts the file descriptors for the reading and writing ends of the pipe (respectively) into filedes`[0]` and filedes`[1]`.

> An easy way to remember that the input end comes first is that file descriptor `0` is standard input, and file descriptor `1` is standard output.

> If successful, `pipe` returns a value of `0`. On failure, `-1` is returned. The following `errno` error conditions are defined for this function:

> `EMFILE`
>   The process has too many files open.
> `ENFILE`
>   There are too many open files in the entire system. See Error Codes, for more information about `ENFILE`. This error never occurs on GNU/Hurd systems.

Here is an example of a simple program that creates a pipe. This program uses the `fork` function (see Creating a Process) to create a child process. The parent process writes data to the pipe, which is read by the child process.

         #include <sys/types.h>
         #include <unistd.h>
         #include <stdio.h>
         #include <stdlib.h>

         /* Read characters from the pipe and echo them to stdout. */

         void
         read_from_pipe (int file)
         {
           FILE *stream;
           int c;
           stream = fdopen (file, "r");
           while ((c = fgetc (stream)) != EOF)
             putchar (c);
           fclose (stream);
         }

         /* Write some random text to the pipe. */

         void
         write_to_pipe (int file)
         {
           FILE *stream;
           stream = fdopen (file, "w");
           fprintf (stream, "hello, world!\n");
           fprintf (stream, "goodbye, world!\n");
           fclose (stream);
         }

         int
         main (void)
         {
           pid_t pid;
           int mypipe[2];

           /* Create the pipe. */
           if (pipe (mypipe))
             {
               fprintf (stderr, "Pipe failed.\n");
               return EXIT_FAILURE;
             }

           /* Create the child process. */
           pid = fork ();
           if (pid == (pid_t) 0)
             {
               /* This is the child process.
                  Close other end first. */
               close (mypipe[1]);
               read_from_pipe (mypipe[0]);
               return EXIT_SUCCESS;
             }
           else if (pid < (pid_t) 0)
             {
               /* The fork failed. */
               fprintf (stderr, "Fork failed.\n");
               return EXIT_FAILURE;
             }
           else
             {
               /* This is the parent process.
                  Close other end first. */
               close (mypipe[0]);
               write_to_pipe (mypipe[1]);
               return EXIT_SUCCESS;
             }
         }