LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    pipe2

    
    
    

    SYNOPSIS

           #include <unistd.h>
    
           int pipe(int pipefd[2]);
    
           #define _GNU_SOURCE             /* See feature_test_macros(7) */
           #include <fcntl.h>              /* Obtain O_* constant definitions */
           #include <unistd.h>
    
           int pipe2(int pipefd[2], int flags);
    
    
    

    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).
    
           If  flags is 0, then pipe2() is the same as pipe().  The following val-
           ues can be bitwise ORed in flags to obtain different behavior:
    
           O_CLOEXEC
                  Set the close-on-exec (FD_CLOEXEC) flag  on  the  two  new  file
                  descriptors.   See  the  description of the same flag in open(2)
                  for reasons why this may be useful.
    
           O_DIRECT (since Linux 3.4)
                  Create a pipe that performs I/O in "packet" mode.  Each write(2)
                  to  the  pipe  is  dealt with as a separate packet, and read(2)s
                  from the pipe will read one packet at a time.  Note the  follow-
                  ing points:
    
                  *  Writes  of  greater than PIPE_BUF bytes (see pipe(7)) will be
                     split into multiple packets.
    
                  *  If a read(2) specifies a buffer size that is smaller than the
                     next packet, then the requested number of bytes are read, and
                     the excess bytes in the packet are discarded.   Specifying  a
                     buffer  size  of  PIPE_BUF  will  be  sufficient  to read the
                     largest possible packets (see the previous point).
    
                  *  Zero-length packets are not supported.  (A read(2) that spec-
                     ifies a buffer size of zero is a no-op, and returns 0.)
    
                  Older  kernels  that do not support this flag will indicate this
                  via an EINVAL error.
    
           O_NONBLOCK
                  Set the O_NONBLOCK file status flag on the  two  new  open  file
                  descriptions.   Using this flag saves extra calls to fcntl(2) to
                  reached.
    
    
    

    VERSIONS

           pipe2() was added to Linux in version 2.6.27; glibc support  is  avail-
           able starting with version 2.9.
    
    
    

    CONFORMING TO

           pipe(): POSIX.1-2001.
    
           pipe2() is Linux-specific.
    
    
    

    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 doesn't need for the pipe (see  pipe(7)).   The
           parent  then  writes the string contained in the program's 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.
    
       Program source
           #include <sys/types.h>
           #include <sys/wait.h>
           #include <stdio.h>
           #include <stdlib.h>
           #include <unistd.h>
           #include <string.h>
    
           int
           main(int argc, char *argv[])
           {
               int pipefd[2];
               pid_t cpid;
               char buf;
    
               if (argc != 2) {
                   fprintf(stderr, "Usage: %s <string>\n", argv[0]);
                   exit(EXIT_FAILURE);
               }
    
               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 */
                   exit(EXIT_SUCCESS);
               }
           }
    
    
    

    SEE ALSO

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

    Linux 2014-02-11 PIPE(2)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz