Pipes and FIFOS

• Think water flowing
  • there is an input end
  • And an output end
  • And data flows through
• int pipe(int pipefd[2]);
  • The single parameter is an array of integers of size 2.
  • This represents both the read end (0) and the write end(1) of the pipe.
  • Return -1 on error.
• PIPE_BUF
  • At least 512 bytes
  • But defined in limits.h
  • Messages of this size or smaller are atomic, ie will not be mixed.
  • Messages larger than this may block
    • Be chopped into smaller pieces
    • May be intermingled in a multiple writer situation.
    • May cause writing to bock.
• int pipe2(int pipefd[2], int flags);
  • flags can be
    • 0 - behave like pipe
    • O_CLOEXEC
    • O_DIRECT : Treat the pipe as a packet oriented object.
      • read reads the next packet, if the size is smaller than the packet, the rest of the packet is discarded.
      • So specify a size of PIPE_BUF for reads.
    • O_NONBLOCK : don't block, return immediately if there is no data.
• A normal use scenario
  • create a pipe.
  • fork
  • ON the reader end
    • Close file descriptor 0
    • dup the read end of the pipe.
    • Close the write end of the pipe.
    • Write to the stdout.
  • On the writer end
    • close file descriptor 1
    • dup the write end of the pipe.
    • close the read end of the pipe.
    • Read from stdin.

•   
  int dup(int oldfd);
  int dup2(int oldfd, int newfd);
      

  • dup makes a copy of the old file descriptor at the next available file descriptor location.
  • dup2 allows you to specify what the new file descriptor should be
    • If newfd is open, it is closed
  • After this, both the old and the new file descriptors are available and the same.
• Note: Processes using the fork process must be related.
• See pipe1.cpp for a simple demo.
• See pi.cpp for a more complex demo.