PIPE(2) 		   Linux Programmers Manual		      PIPE(2)



NAME
       pipe - create pipe

SYNOPSIS
       #include 

       int pipe(int pipefd[2]);

DESCRIPTION
       pipe()  creates	a pipe, a unidirectional data channel that can be used
       for interprocess communication.	The array pipefd is used to return two
       file  descriptors  referring to the ends of the pipe.  pipefd[0] refers
       to the read end of the pipe.  pipefd[1] refers to the write end of  the
       pipe.   Data  written  to  the write end of the pipe is buffered by the
       kernel until it is read from the read end of  the  pipe.   For  further
       details, see pipe(7).

RETURN VALUE
       On  success,  zero is returned.	On error, -1 is returned, and errno is
       set appropriately.

ERRORS
       EFAULT pipefd is not valid.

       EMFILE Too many file descriptors are in use by the process.

       ENFILE The system limit on the total number  of	open  files  has  been
	      reached.

CONFORMING TO
       POSIX.1-2001.

EXAMPLE
       The  following  program	creates  a pipe, and then fork(2)s to create a
       child process; the child inherits a duplicate set of  file  descriptors
       that  refer  to	the same pipe.	After the fork(2), each process closes
       the descriptors that it doesnt need for the pipe (see  pipe(7)).   The
       parent  then  writes the string contained in the programs command-line
       argument to the pipe, and the child reads this string a byte at a  time
       from the pipe and echoes it on standard output.

       #include 
       #include 
       #include 
       #include 
       #include 
       #include 

       int
       main(int argc, char *argv[])
       {
	   int pipefd[2];
	   pid_t cpid;
	   char buf;

	   assert(argc == 2);

	   if (pipe(pipefd) == -1) {
	       perror("pipe");
	       exit(EXIT_FAILURE);
	   }

	   cpid = fork();
	   if (cpid == -1) {
	       perror("fork");
	       exit(EXIT_FAILURE);
	   }

	   if (cpid == 0) {    /* Child reads from pipe */
	       close(pipefd[1]);	  /* Close unused write end */

	       while (read(pipefd[0], &buf, 1) > 0)
		   write(STDOUT_FILENO, &buf, 1);

	       write(STDOUT_FILENO, "\n", 1);
	       close(pipefd[0]);
	       _exit(EXIT_SUCCESS);

	   } else {	       /* Parent writes argv[1] to pipe */
	       close(pipefd[0]);	  /* Close unused read end */
	       write(pipefd[1], argv[1], strlen(argv[1]));
	       close(pipefd[1]);	  /* Reader will see EOF */
	       wait(NULL);		  /* Wait for child */
	       exit(EXIT_SUCCESS);
	   }
       }

SEE ALSO
       fork(2), read(2), socketpair(2), write(2), popen(3), pipe(7)

COLOPHON
       This  page  is  part of release 3.05 of the Linux man-pages project.  A
       description of the project, and information about reporting  bugs,  can
       be found at http://www.kernel.org/doc/man-pages/.



Linux				  2008-01-09			       PIPE(2)