PROLOG

       This  manual  page  is part of the POSIX Programmer's Manual.  The Linux implementation of
       this interface may differ (consult the corresponding Linux  manual  page  for  details  of
       Linux behavior), or the interface may not be implemented on Linux.

NAME

       pipe — create an interprocess channel

SYNOPSIS

       #include <unistd.h>

       int pipe(int fildes[2]);

DESCRIPTION

       The  pipe() function shall create a pipe and place two file descriptors, one each into the
       arguments fildes[0] and fildes[1], that refer to the open file descriptions for  the  read
       and  write ends of the pipe. Their integer values shall be the two lowest available at the
       time of the pipe() call. The O_NONBLOCK and FD_CLOEXEC flags shall be clear on  both  file
       descriptors. (The fcntl() function can be used to set both these flags.)

       Data  can  be  written  to the file descriptor fildes[1] and read from the file descriptor
       fildes[0].  A read on the file descriptor fildes[0] shall access data written to the  file
       descriptor fildes[1] on a first-in-first-out basis. It is unspecified whether fildes[0] is
       also open for writing and whether fildes[1] is also open for reading.

       A process has the pipe open for  reading  (correspondingly  writing)  if  it  has  a  file
       descriptor open that refers to the read end, fildes[0] (write end, fildes[1]).

       The pipe's user ID shall be set to the effective user ID of the calling process.

       The pipe's group ID shall be set to the effective group ID of the calling process.

       Upon  successful  completion, pipe() shall mark for update the last data access, last data
       modification, and last file status change timestamps of the pipe.

RETURN VALUE

       Upon successful completion, 0 shall be returned; otherwise, −1 shall be returned and errno
       set to indicate the error.

ERRORS

       The pipe() function shall fail if:

       EMFILE All, or all but one, of the file descriptors available to the process are currently
              open.

       ENFILE The number of simultaneously open files in the system would exceed a system-imposed
              limit.

       The following sections are informative.

EXAMPLES

   Using a Pipe to Pass Data Between a Parent Process and a Child Process
       The  following  example  demonstrates  the use of a pipe to transfer data between a parent
       process and a  child  process.  Error  handling  is  excluded,  but  otherwise  this  code
       demonstrates  good practice when using pipes: after the fork() the two processes close the
       unused ends of the pipe before they commence transferring data.

           #include <stdlib.h>
           #include <unistd.h>
           ...

           int fildes[2];
           const int BSIZE = 100;
           char buf[BSIZE];
           ssize_t nbytes;
           int status;

           status = pipe(fildes);
           if (status == −1 ) {
               /* an error occurred */
               ...
           }

           switch (fork()) {
           case −1: /* Handle error */
               break;

           case 0:  /* Child - reads from pipe */
               close(fildes[1]);                       /* Write end is unused */
               nbytes = read(fildes[0], buf, BSIZE);   /* Get data from pipe */
               /* At this point, a further read would see end of file ... */
               close(fildes[0]);                       /* Finished with pipe */
               exit(EXIT_SUCCESS);

           default:  /* Parent - writes to pipe */
               close(fildes[0]);                       /* Read end is unused */
               write(fildes[1], "Hello world\n", 12);  /* Write data on pipe */
               close(fildes[1]);                       /* Child will see EOF */
               exit(EXIT_SUCCESS);
           }

APPLICATION USAGE

       None.

RATIONALE

       The wording carefully avoids using the verb ``to open'' in order to avoid any  implication
       of use of open(); see also write().

FUTURE DIRECTIONS

       None.

SEE ALSO

       fcntl(), read(), write()

       The Base Definitions volume of POSIX.1‐2008, <fcntl.h>, <unistd.h>

COPYRIGHT

       Portions  of  this  text  are  reprinted  and  reproduced in electronic form from IEEE Std
       1003.1, 2013 Edition, Standard for Information Technology  --  Portable  Operating  System
       Interface  (POSIX),  The Open Group Base Specifications Issue 7, Copyright (C) 2013 by the
       Institute of Electrical and Electronics Engineers, Inc  and  The  Open  Group.   (This  is
       POSIX.1-2008  with  the  2013  Technical  Corrigendum  1  applied.)  In  the  event of any
       discrepancy between this version and the original IEEE and The Open  Group  Standard,  the
       original  IEEE  and The Open Group Standard is the referee document. The original Standard
       can be obtained online at http://www.unix.org/online.html .

       Any typographical or formatting errors that appear in this page are most  likely  to  have
       been  introduced  during  the conversion of the source files to man page format. To report
       such errors, see https://www.kernel.org/doc/man-pages/reporting_bugs.html .