[Linux] linux编程之pipe()函数详解

#include<unistd.h>
 
int pipe(int filedes[2]);

#include <sys/types.h>
 
  #include <sys/stat.h>
 
   int mkfifo(const char *pathname, mode_t mode);

/*
 * 有亲缘关系的进程间的fifo的使用
 * fifo 使用的简单例子
 */
 
#include "../all.h"
 
#define fifo_path "/tmp/hover_fifo"
 
 
void
do_sig(int signo)
{
  if (signo == sigchld)
  while (waitpid(-1, null, wnohang) > 0)
    ;
}
 
 
int
main(void)
{
  int ret;
  int fdr, fdw;
  pid_t pid;
 
  char words[10] = "123456789";
  char buf[10] = {'\0'};  
  
  // 创建它,若存在则不算是错误,
  // 若想修改其属性需要先打开得到fd,然后用fcntl来获取属性,然后设置属性.
 
  if (((ret = mkfifo(fifo_path, file_mode)) == -1) 
 
       && (errno != eexist))
  perr_exit("mkfifo()");
  fprintf(stderr, "fifo : %s created successfully!\n", fifo_path);
 
  signal(sigchld, do_sig);
 
  pid = fork();
  if (pid == 0) { // child
 
  if ((fdr = open(fifo_path, o_wronly)) < 0) // 打开fifo用来写
    perr_exit("open()");
  sleep(2);
 
  // 写入数据
  if (write(fdr, words, sizeof(words)) != sizeof(words)) 
    perr_exit("write");
  fprintf(stderr, "child write : %s\n", words);
  close(fdw);
  } else if (pid > 0) { // parent
 
  if ((fdr = open(fifo_path, o_rdonly)) < 0) // 打开fifo用来读
 
    perr_exit("open()");
 
  fprintf(stderr, "i father read, waiting for child ...\n");
  if (read(fdr, buf, 9) != 9) //读数据
    perr_exit("read");
 
  fprintf(stderr, "father get buf : %s\n", buf);
  close(fdr);
  }
  // 到这里fifo管道并没有被删除,必须手动调用函数unlink或remove删除.
 
  return 0;  
}

/*
 * fifo server
 */
 
#include "all.h"
 
int
main(void)
{
  int fdw, fdw2;
  int fdr;
  char clt_path[path_len] = {'\0'};
  char buf[max_line] = {'\0'};
  char *p;
  int n;
  
  if (mkfifo(fifo_svr, file_mode) == -1 && errno != eexist)  
  perr_exit("mkfifo()");  
  if ((fdr = open(fifo_svr, o_rdonly)) < 0)  
  perr_exit("open()");
  /* 
   * 根据fifo的创建规则, 若从一个空管道或fifo读, 
 
   * 而在读之前管道或fifo有打开来写的操作, 那么读操作将会阻塞 
   * 直到管道或fifo不打开来读, 或管道或fifo中有数据为止. 
 
   *
 
   * 这里,我们的fifo本来是打开用来读的,但是为了,read不返回0,
 
   * 让每次client端读完都阻塞在fifo上,我们又打开一次来读.
   * 见unpv2 charper 4.7
   */
  if ((fdw2 = open(fifo_svr, o_wronly)) < 0)  
  fprintf(stderr, "open()");
  
  while (1) {
  /* read client fifo path from fifo_svr */
 
   /* 这里由于fifo_svr有打开来写的操作,所以当管道没有数据时, 
 
   * read会阻塞,而不是返回0. 
 
   */
  if (read(fdr, clt_path, path_len) < 0) {
    fprintf(stderr, "read fifo client path error : %s\n", strerror(errno));  
    break;
  }
  if ((p = strstr(clt_path, "\r\n")) == null) {
    fprintf(stderr, "clt_path error: %s\n", clt_path);
    break;
  }
  *p = '\0';
  dbg("clt_path", clt_path);
  if (access(clt_path, w_ok) == -1) { // client fifo ok, but no permission
 
    perror("access()");  
    continue;
  }
  /* open client fifo for write */
  if ((fdw = open(clt_path, o_wronly)) < 0) {
    perror("open()");  
    continue;
  }
  if ((n = read(fdr, buf, words_len)) > 0) { /* read server words is ok */
    printf("server read words : %s\n", buf);
    buf[n] = '\0';
    write(fdw, buf, strlen(buf));  
  }
  }
  
  close(fdw);  
  unlink(fifo_svr);
  exit(0);
}

/*
 * fifo client
 *
 */
#include "all.h"
 
int
main(void)
{
  int fdr, fdw;
  pid_t pid;  
  char clt_path[path_len] = {'\0'};
  char buf[max_line] = {'\0'};
  char buf_path[max_line] = {'\0'};
  
  snprintf(clt_path, path_len, fifo_clt_fmt, (long)getpid());  
  dbg("clt_path1 = ", clt_path);
  snprintf(buf_path, path_len, "%s\r\n", clt_path);
 
  if (mkfifo(clt_path, file_mode) == -1 && errno != eexist)  
  perr_exit("mkfifo()");
 
  /* client open clt_path for read
   * open server for write 
  */
  if ((fdw = open(fifo_svr, o_wronly)) < 0) 
  perr_exit("open()");
  
  /* write my fifo path to server */
  if (write(fdw, buf_path, path_len) != path_len)  
  perr_exit("write()");
  if (write(fdw, words, words_len) < 0)  /* write words to fifo server */
  perr_exit("error");
 
  if ((fdr = open(clt_path, o_rdonly)) < 0)  
  perr_exit("open()");
  if (read(fdr, buf, words_len) > 0) {   /* read reply from fifo server */
  buf[words_len] = '\0';
  printf("server said : %s\n", buf);
  }
  
  close(fdr);
  unlink(clt_path);
  
  exit(0);
}