【APUE】Chapter15 Interprocess Communication
15.1 Introduction
这部分太多概念我不了解。只看懂了最后一段，进程间通信（IPC）内容被组织成了三个部分：
（1）classical IPC : pipes, FIFOs, message queues, semaphores, and shared memory
（2）network IPC : sockets mechanism
（3）advanced features of IPC
15.2 Pipes
Pipes是“the oldest form of UNIX System IPC”，因此有两个方面的limitations：
（1）一般来说pipes都是半双工（half-duplex）的工作模式
（2）pipes能通信的process是有要求的：必须是同一个ancestor的（比如一个process不断fork这种的）
1. pipe函数
int pipe(int fd[2])
fd[0]：执行pipe后，fd[0]代表reading file descriptor
fd[1]: 执行pipe后，fd[1]代表writing file descriptor
返回0代表成功，-1表示失败
这个函数的原理可以用一张图来理解：
上左图：two ends connected in a single process
上右图：emphasizes that the data in the pipe flows through the kernel
这还是在single process里面玩儿，跟我们说的interprocess communication不一样。这时候要借助Chapter8中学到的内容，fork函数，化腐朽为神奇的一步：
“the process that calls pipe then calls fork, creating an IPC channel from the parent to the child, or vice versa”
翻译过来就是：pipe + fork 完成了一个最原始的interprocess communication。上面的IPC思路，可以用下图解释：
理解上面的原理图，需要有fork的背景知识：parent process经过fork出child process后，parent process的file descriptor是直接copy到child process的。
这样，经过fork之后，就在parent和child中各有一对fd[0] fd[1]：
（1）parent中的fd[1]由pipe输出到parent和child的两个fd[0]
（2）child中的fd[1]同理也可以由pipe输出到parent和child中的两个fd[0]
2. Pipe函数实现基础IPC功能
下面，搞一个程序验证下是不是pipe是不是实现了这样的功能：
1 #include "apue.h" 2 3 int main(int argc, char *argv[]) 4 { 5 int n; 6 int fd[2]; 7 pid_t pid; 8 char line[MAXLINE]; 9 10 if (pipe(fd)<0) { 11 err_sys("pipe error"); 12 } 13 if ((pid=fork())<0) { 14 err_sys("fork error"); 15 } 16 else if (pid>0) { /*parent process*/ 17 //close(fd[0]); 18 write(fd[1], "12345678", 8); 19 sleep(2); 20 n = read(fd[0], line, 4); 21 write(STDOUT_FILENO, line, n); 22 printf("parent\n"); 23 } 24 else { 25 //close(fd[1]); 26 n = read(fd[0], line, 4); 27 write(STDOUT_FILENO, line, n); 28 printf("child\n"); 29 } 30 exit(0); 31 }
（ 在pipe+fork之后，常规的套路应该是关闭parent和child端不用的file descriptor（parent关闭fd[0], child关闭fd[1]），但是为了解决上面的疑惑故意没有关上）
这样，效果就是parent和child都保持了read和write的入口。
程序做的事情就是在parent process中往pipe中写“12345678”总共8个字符，先让child process从pipe的出口读4个字符，然后再让parent process从pipe的出口读4个字符。代码运行结果如下：
从结果中看到，parent和child都从管道中fetch了4个字符。解决了之前的疑惑。
更进步一步，查阅了如下的blog（http://blog.csdn.net/tennysonsky/article/details/46315517），下面的几点总结的挺好：
还有一点要注意，read方法是阻塞的：如果parent和child都用read方法从pipe中读内容，如果pipe中的内容被读光了，read方法就阻塞住了。
把上面代码中line18改为“write(fd[1], "1234", 4)”，运行结果如下：
结果就是parent process在read那里阻塞住了。原因是：
（1）pipe中的数据一旦被read走就消失了
（2）read方法是阻塞方法，读不到数据就挂住了
上面解释了“read读不到数据被阻塞的情况”，如果是write写数据的时候，read端已经关闭了呢？这个时候会产生一个SIGPIPE信号。
有如下代码：
1 #include "apue.h" 2 #include <signal.h> 3 #include <unistd.h> 4 5 void sig_pipe(int signo) 6 { 7 printf("pid:%d\n",getpid()); 8 if ( signo == SIGPIPE) 9 { 10 printf("fetch SIGPIPE\n"); 11 fflush(stdout); 12 } 13 } 14 15 int main(int argc, char *argv[]) 16 { 17 int n; 18 int fd[2]; 19 pid_t pid; 20 char line[MAXLINE]; 21 signal(SIGPIPE, sig_pipe); 22 23 if (pipe(fd)<0) { 24 err_sys("pipe error"); 25 } 26 if ((pid=fork())<0) { 27 err_sys("fork error"); 28 } 29 else if (pid>0) { /*parent process*/ 30 close(fd[0]); 31 sleep(10); 32 write(fd[1], "1234", 4); 33 printf("parent\n"); 34 } 35 else { 36 //close(fd[1]); 37 printf("child\n"); 38 close(fd[0]); 39 } 40 exit(0); 41 }
程序运行结果如下：
可以看到，是调用write的parent process捕获了这个SIGPIPE信号（parent pid是6867）。（child pid为6868，由于parent没有回收child process，所以在child process执行完之后，就变成了野进程了<defunct>）
3. 利用pipe函数实现一个 cat XXX | more的例子
如题，直接上例子代码：
1 #include "apue.h" 2 #include <sys/wait.h> 3 4 #define DEF_PAGER "/bin/more" /*default pager program*/ 5 6 int main(int argc, char *argv[]) 7 { 8 int n; 9 int fd[2]; 10 pid_t pid; 11 char *pager, *argv0; 12 char line[MAXLINE]; 13 FILE *fp; 14 15 fp = fopen(argv[1], "r"); /*把fp关联到disk file*/ 16 pipe(fd); /*创建pipe*/ 17 18 if ((pid = fork())<0) { 19 err_sys("fork error"); 20 } 21 else if (pid>0) { /*parent process*/ 22 close(fd[0]); 23 while (fgets(line, MAXLINE, fp)!=NULL) { /*从disk file中读一行*/ 24 n = strlen(line); 25 if (write(fd[1], line, n)!=n) { /*往child process的fd[0]中写*/ 26 err_sys("write error to pipe"); 27 } 28 } 29 ferror(fp); /*检查写的过程中是否出问题了*/ 30 close(fd[1]); /*关闭写的fd*/ 31 if (waitpid(pid, NULL, 0)<0) { /*等child process执行完毕*/ 32 err_sys("waitpid error"); 33 } 34 exit(0); 35 } 36 else { 37 close(fd[1]); 38 if (fd[0] != STDIN_FILENO) { /*将fd[0]关联到stdin中*/ 39 if (dup2(fd[0], STDIN_FILENO)!=STDIN_FILENO) { 40 err_sys("dup2 error to stdin"); 41 } 42 close(fd[0]); /*fd[0]的使命到此结束了 因为read end已经被关联到stdout了*/ 43 } 44 if ((pager = getenv("PAGER"))==NULL) { /*从环境变量中读取PAGER*/ 45 pager = DEF_PAGER; 46 } 47 if ((argv0 = strrchr(pager, '/'))!=NULL) { /*找到'/'在字符串pager中最后一次出现的位置*/ 48 argv0++; 49 } 50 else { 51 argv0 = pager; 52 } 53 if (execl(pager, argv0, (char *)0)<0) { /*pager是命令path argv0是具体路径下的命令*/ 54 err_sys("execl error for %s", pager); 55 } 56 } 57 exit(0); 58 }
编译后，执行如下命令：
获得结果如下：
从结果来看 就跟 cat XXX | more实现的功能是一样的。
从代码上看，为了实现上面的功能，主要在line39~line41中用到了dup2这个函数。回顾一下dup2这个函数：
int dup2(A, B)
（1）A是已经打开的file descriptor
（2）让B与A关联到同一个file
（3）如果A是not valid则fail
（4）如果A与B相等，则什么都不做返回
有了上面的背景知识，理解以上的代码主要有以下几点：
（1）dup2是把parent process通过fd[1]往pipe里面写数据，本来正常的出口是fd[0]，但是通过dup2把出口改到了child process的STDIN_FILENO上面。这样就彻底实现了cat XXX | more一样的功能。“cat XXX”就是parent process做的事情，“|”就是起到了dup2的作用，“more”是child process实际做的事情。
（2）execl之后child process执行的内容就是/bin/more命令；而执行more命令的process中file descriptor是从之前child process中继承下来的，而STDIN_FILENO就是编号为0的file descriptor；所以对于“more”命令来说，它的STDIN_FILENO就是pipe的出口端fd[0]。具体excel的细节，还得去看APUE的chapter 8。
4. popen & pclose函数 及其实现细节
"pipe + fork"编程模型是一个最基础的IPC模型，<stdio.h>中提供了两个函数来集成化实现"pipe+fork"的编程模型。
FILE *popen(const char *cmdstring, const char *type)
int pclose(FILE *fp)
参数cmdstring就是要执行的命令， type可以取值{“r”, “w”}两个值。这里的r和w跟fopen中的r和w一个意思。
当type对应的参数为"r"的时候，即fp = popen(cmdstring, "r")的情况下，是如下的编程模型：
当type对应的参数为"w"的时候，即fp = popen(cmdstring, "w")的情况下，是如下的编程模型：
这两个函数本身stdio是都提供具体实现的，但是为了串起来一些细节，用一个综合的例子来说明。
这个例子还是实现cat XXX | more的功能，与之前的区别是把"pipe+fork"的编程模型继承到了popen和pclose中。具体代码如下：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <unistd.h> 4 #include <errno.h> 5 #include <fcntl.h> 6 #include <sys/wait.h> 7 #include <limits.h> 8 9 #ifdef OPEN_MAX 10 static long openmax = OPEN_MAX; 11 #else 12 static long openmax = 0; 13 #endif 14 15 #define OPEN_MAX_GUESS 256 16 #define PAGER "${PAGER:-more}" /*environment variable, or default*/ 17 #define MAXLINE 4096 18 19 static pid_t *childpid = NULL; /*pointer to array allocated at run-time*/ 20 static int maxfd; 21 22 /*系统允许获得的最大的file descriptor数量*/ 23 long open_max(void) 24 { 25 if (openmax==0) { 26 errno = 0; 27 if ((openmax = sysconf(_SC_OPEN_MAX))<0) { 28 if (errno == 0) { 29 openmax = OPEN_MAX_GUESS; 30 } 31 else { 32 err_sys("sysconf error for _SC_OPEN_MAX"); 33 } 34 } 35 } 36 return openmax; 37 } 38 39 40 FILE * popen(const char *cmdstring, const char *type) 41 { 42 int i; 43 int pfd[2]; 44 pid_t pid; 45 FILE *fp; 46 /*这段代码保证输入参数*/ 47 if ((type[0] != 'r' && type[0] != 'w')||(type[1] !=0)) { 48 errno = EINVAL; 49 return NULL; 50 } 51 if (childpid==NULL) { /*如果是首次处理childpid 动态给childpid分配内存*/ 52 maxfd = open_max(); 53 if ((childpid = calloc(maxfd, sizeof(pid_t)))==NULL) { 54 return NULL; 55 } 56 } 57 if (pipe(pfd)<0) { /*pipe搞一下pfd, pfd[0]代表input pfd[1]代表output*/ 58 return NULL; 59 } 60 if ( pfd[0]>=maxfd || pfd[1]>=maxfd ) { /*如果超出fd最大量程 就把fd都关了返回*/ 61 close(pfd[0]); 62 close(pfd[1]); 63 errno = EMFILE; /*这个ERROR的意思就是file descriptor超出最大量程了*/ 64 return NULL; 65 } 66 /*在这之前都是做各种准备工作*/ 67 if ((pid=fork())<0) { 68 return NULL; 69 } 70 else if (pid==0) { /*child process*/ 71 if (*type=='r') { /*parent要从child中读 所以关闭child中pfd[0] input的fd*/ 72 close(pfd[0]); 73 if (pfd[1]!=STDOUT_FILENO) { /*常规套路 把pdf[1]引到child的标准输出中*/ 74 dup2(pfd[1], STDOUT_FILENO); 75 close(pfd[1]); 76 } 77 } 78 else { /*parent要向child中写 所以关闭child中pfd[1] output的fd*/ 79 close(pfd[1]); 80 if (pfd[0]!=STDIN_FILENO) { 81 dup2(pfd[0], STDIN_FILENO); 82 close(pfd[0]); 83 } 84 } 85 /*close all descriptors in childpid[]*/ 86 for( i=0; i<maxfd; i++ ) /*为什么要这种操作 因为child process可以继承parent process的file descriptor 但是这些file descriptor其实并不需要 所以都需要关了*/ 87 { 88 if (childpid[i]>0) { /*每次fork之后 child process中都会copy过来一套childpid 而这些pid在child porocess中其实都不需要 所以 需要一一给删除*/ 89 close(i); 90 } 91 } 92 /*至此 child process的准备工作都做好了: 1.管道铺好了 2.该关的fd也都关了*/ 93 execl("/bin/sh", "sh", "-c", cmdstring, (char *)0); 94 _exit(127); 95 } 96 /*parent process继续往下进行*/ 97 if (*type=='r') { 98 close(pfd[1]); 99 if ((fp=fdopen(pfd[0], type))==NULL) { /*因为pfd已经被pipe打开了 所以对于打开的fd就要用fdopen来处理 下面'w'的情况同理*/ 100 return NULL; 101 } 102 } 103 else { 104 close(pfd[0]); 105 if ((fp=fdopen(pfd[1], type))==NULL) { 106 return NULL; 107 } 108 } 109 childpid[fileno(fp)] = pid; /*这里的方式是用fd作为index child pid号作为value 构建这个childpid数组*/ 110 return fp; 111 } 112 113 int pclose(FILE *fp) 114 { 115 int fd, stat; 116 pid_t pid; 117 118 if (childpid==NULL) { /*没有调用过popen函数 报错*/ 119 errno = EINVAL; 120 return -1; 121 } 122 fd = fileno(fp); /*file descriptor超过最大量程 报错*/ 123 if (fd>=maxfd) { 124 errno = EINVAL; 125 return -1; 126 } 127 if ((pid=childpid[fd])==0) { /*正用着的进程的pid是不可能为0的 因为没用用的childpid[]都是0 报错*/ 128 errno = EINVAL; 129 return -1; 130 } 131 childpid[fd] = 0; /*把进程pid设为0了 告诉父进程 这个曾经起作用的child process已经无效了*/ 132 if (fclose(fp)==EOF) { /*fclose执行不成功返回的是-1 且errno中标示了是什么错误*/ 133 return -1; 134 } 135 /*这里为什么要用while循环?*/ 136 while (waitpid(pid, &stat, 0)<0) { /*这个pid是子进程的pid 由于调用pclose的一定是parent process 所以必须等着child process进程执行完毕了再往下进行*/ 137 if (errno!=EINTR) { 138 return -1; 139 } 140 } 141 return stat; /*通过stat返回 与fp挂钩的child process的执行状态*/ 142 } 143 144 145 int main(int argc, char *argv[]) 146 { 147 char line[MAXLINE]; 148 FILE *fpin, *fpout; 149 150 fpin = fopen(argv[1], "r"); 151 if ((fpout = popen(PAGER, "w"))==NULL) { 152 err_sys("popen error"); 153 } 154 while (fgets(line, MAXLINE, fpin)!=NULL) { 155 if (fputs(line, fpout)==EOF) { 156 err_sys("fputs error to pipe"); 157 } 158 } 159 if (ferror(fpin)) { 160 err_sys("fgets error"); 161 } 162 if (pclose(fpout)==-1) { 163 err_sys("pclose error"); 164 } 165 exit(0); 166 }
代码执行结果与之前相同，不再赘述。主要通过这个例子来学习一些细节。
popen函数：
由于这种通用的函数要defensive programming的思路来设计，所以在实现functionality之前要处理各种corner case
（1）如果type的值不是r和w 则出错返回。
（2）如果childpid（childpid中存放着已经开着的各种child process的pid）为空，证明是parent process首次调用popen函数，需要给childpid分配memory。
（3）具体要给childpid分配多大的memory，这个由maxfd参数决定。maxfd这个由于具体系统实现决定（通过open_max函数获得，apue耍书上P52 figure2.17实现），含义是同一个process最多能开多少个fd（在我的用centos系统上是1024）。给childpid分配memory的方式一开始没理解好，问题主要纠结在为什么pid的array要根据file descriptor max来决定。其实，就应该是这样的，因为"pipe+fork"编程模型的核心在于一个fd通向一个child process；所以，最多能有多少个chidpid就是取决于最多能弄出来多少个file descriptor。
接下来就是之前提到过的“pipe+fork”编程模型，看似只返回了一个FILE *fp，实际上做了如下几件事情：
（4）私下搞出来一个child process，执行传入的cmdstring命令
（5）返回给parent process一个fp，这个fp就相当于child process的STDIN
（6）为了让parent process能定位到popen函数创建的child process。需要在childpid中存着这个pid，这里有个技巧，就是用parent process与child process关联的fp的fd，最终是fd作为这个child process pid在childpid数组中的index。我猜这样设计的原因是，pid和fd都同时知道了，想做什么操作也方便了。
（7）在child process中，用for循环把childpid中所有的fd都关闭了。因为fork之后，parent process中的childpid也继承到了chid process中，这对child process是无用的，而且不关掉还容易留隐患。通过检验childpid[i]是否为0，可以判断这个child process是否被fork出来过；如果被fork出来过，则证明其fd（就是i）是有效的，统统关闭之。注意，这里关闭的是后面fork出来的child process指向之前fork出来的child process的fd，有点儿拗口，主要是下面的图：
大概就是这个意思了。因此才有了for循环，删除child与child之间fd的关联。没有关联就不能乱删，判断有关联的标准就是pid!=0。这样就保证了只有parent与child之间的pipe连接，不会产生child与child之间的pipe通道。
pclose函数：
这个函的功能就是断开parent与某个child之间的pipe通道。这个功能分为三个实现环节：
（1）关闭之前获得的fp（传入的参数fp发挥了作用）
（2）防止child成为孤儿进程，必须回收child process的执行状态：用waitpid来完成这个事情，又由于waitpid允许被signal打断，而signal产生的EINTR信号是可以容忍出现的，因此用了while循环来做。（之前保存在childpid中的pid发挥了作用）
（3）还必须保证后续fork的child知道，这个child已经被回收了（childpid[fd]=0发挥了作用）
15.3 Coprocesses
自己写出去，经过一个filter处理后，再读回来。
先构造一个2整数加法器如下：
1 #include "apue.h" 2 3 int main(int argc, char *argv[]) 4 { 5 int n, int1, int2; 6 char line[MAXLINE]; 7 8 while ((n=read(STDIN_FILENO, line, MAXLINE))>0) { 9 line[n] = 0; /*null terminate*/ 10 if (sscanf(line, "%d%d", &int1, &int2)==2) { 11 sprintf(line, "%d\n", int1+int2); 12 n = strlen(line); 13 if (write(STDOUT_FILENO, line, n) != n) { 14 err_sys("write error"); 15 } 16 } 17 else { 18 if (write(STDOUT_FILENO, "invalid args\n", 13)!=13) { 19 err_sys("write error"); 20 } 21 } 22 } 23 exit(0); 24 }
这个加法器的作用就是从stdin中读两个整数，做容错处理，加法运算，再写出到stdout中。编译成可执行文件add2。
构造一个进程，利用coprocess的方式，来调用add2处理加法运算。代码如下（除去了书上一些defensive programming的段落，目的是便于把思路捋清楚）：
1 #include "apue.h" 2 3 static void sig_pipe(int signo) 4 { 5 if ( signo == SIGPIPE ) 6 { 7 printf("fetch SIGPIPE\n"); 8 } 9 exit(1); 10 } 11 12 int main(int argc, char *argv[]) 13 { 14 int n, fd1[2], fd2[2]; 15 char line[MAXLINE]; 16 pid_t pid; 17 18 signal(SIGPIPE, sig_pipe); 19 pipe(fd1); 20 pipe(fd2); 21 22 if ((pid = fork())<0) { 23 err_sys("fork error"); 24 } 25 else if (pid>0) { /*parent process*/ 26 close(fd1[0]); 27 close(fd2[1]); 28 while (fgets(line,MAXLINE,stdin)!=NULL) { 29 n = strlen(line); 30 if (write(fd1[1],line,n)!=n) { 31 err_sys("write error to pipe"); 32 } 33 if ((n=read(fd2[0], line, MAXLINE))<0) { 34 err_sys("read error from pipe"); 35 } 36 if (n==0) { 37 err_msg("child closed pipe"); 38 break; 39 } 40 line[n] = 0; /*null terminate*/ 41 if (fputs(line ,stdout)==EOF) { 42 err_sys("fputs error"); 43 } 44 } 45 ferror(stdin); 46 exit(0); 47 } 48 else { 49 close(fd1[1]); 50 close(fd2[0]); 51 if (fd1[0]!=STDIN_FILENO) { 52 dup2(fd1[0], STDIN_FILENO); 53 close(fd1[0]); 54 } 55 if (fd2[1]!=STDOUT_FILENO) { 56 dup2(fd2[1], STDOUT_FILENO); 57 close(fd2[1]); 58 } 59 execl("./add2", "add2", (char *)0); 60 } 61 exit(0); 62 }
执行结果如下：
（1）一开始按照coprocess的模型执行两个整数的加法，输入“1 2”返回“3”
（2）然后手工结束add2进程如下：
手动结束进程后，pipe的一端已经没有了；因此，a.out的write就触发了SIGPIPE的信号。
这里还有个内容需要注意，add2在实现上用的都是low-level的read和write两个读写函数。
如果把level往上拔一下，换到standard I/O，代码如下：
1 #include "apue.h" 2 3 int main(int argc, char *argv[]) 4 { 5 int int1, int2; 6 char line[MAXLINE]; 7 8 setvbuf(stdin, NULL, _IOLBF, 0); 9 setvbuf(stdout, NULL, _IOLBF, 0); 10 11 while (fgets(line, MAXLINE, stdin)!=NULL) { 12 if (sscanf(line, "%d%d", &int1, &int2)==2) { 13 printf("%d\n", int1+int2); 14 } 15 else { 16 printf("invalid args\n"); 17 } 18 } 19 exit(0); 20 }
则再执行上述的完整流程，完全进行不下去了。
原因可以用一句话来概括：由于standard I/O的buffer机制，使得这种coprocess编程模型出现了deadlock。
由于这种编程模型下，add2自动识别standard input来自于pipe（同理，standard output也被识别为输出到pipe），因此standard I/O默认设置为fully buffered。在这样的背景下，整个program执行的流程如下：
（1）a.out调用write向pipe中写数据
（2）add2调用fgets从pipe中读数据，但是由于是fully buffered，所以不刷新一直读不进来；由于没有读到数据，因此也不会往出写数据
（3）同时，a.out调用完write之后，又马上调用了read；由于read是阻塞函数，所以一直等着pipe的输出
（4）但是（2）中已经说了，add2等着a.out给buffer写满再刷新，同时a.out也等着add2往pipe中写数据。a.out和add2都互相等着对方，最终就造成了deadlock。
如何解决coprocess这种编程模型遇到的问题？
一种方式就是修改源代码，强制为line buffered；但是并不是所有程序都拿的到源代码的，于是就有了另外一种方法，叫pesudo terminal，后面Chapter 19中提到。
15.5 FIFOs
传统的pipes是在ancestor relation processes之间完成IPC，FIFOs则可以在unrelated processes之间完成IPC。
1. FIFOs是一种file，它的创建可以用如下函数：
int mkfifo(const char *path, mode_t mode)
int mkfifoat(int fd, const char *path, mode_t mode)
其用法可以类比open和openat（书上P62）
2. 与pipe类似，如果向FIFOs执行write操作，但是read端已经关闭了，也会发出SIGPIPE信号
3. 同一个FIFOs可以有多个writer向其中写，因此有多个写的atomic问题：与pipe类似，如果每个writer写的数据不大于PIPE_BUF，则FIFOs的实现机制可以保证其同步，不会数据在FIFOs中data interleaved
4. FIFOs的实际用处主要包括两个方面：
（1）shell command用FiFOs技术完成一个pipeline向另一个pipeline传输数据（好处是不用创建临时文件）
（2）CS架构中，client与server数据的交换汇合点
三个例子。
第一例子说明，FIFOs可以在unrelated process之间exchange data，代码：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <unistd.h> 4 #include <fcntl.h> 5 6 #include <sys/types.h> 7 #include <sys/stat.h> 8 #include <signal.h> 9 #include <errno.h> 10 11 #define PATHNAME "/tmp/myfifo" 12 13 int main(int argc, char *argv[]) 14 { 15 pid_t pid; 16 int fd = -1; 17 char buf[BUFSIZ] = ""; 18 19 mkfifo(PATHNAME, 0644); /*创建一个管道文件*/ 20 fflush(NULL); 21 if ((pid = fork())<0) { 22 exit(1); 23 } 24 else if (pid>0) { /*parent 1*/ 25 pid_t child1 = pid; 26 pid = fork(); 27 if (pid>0) { /*parent 2*/ 28 waitpid(pid, NULL, 0); /*先等着child2执行完*/ 29 } 30 else { /*child 这样就保证两个child没有共同的parent process*/ 31 fd = open(PATHNAME, O_RDWR); /*打开fifo文件, 既能读又能写*/ 32 read(fd, buf, BUFSIZ); /*阻塞读*/ 33 printf("%s",buf); /*读到什么展示一下*/ 34 write(fd, " World!", 8); /*读完了再写点儿东西进去*/ 35 close(fd); 36 exit(0); 37 } 38 waitpid(child1, NULL, 0); /*再等着child1执行完*/ 39 } 40 else { /*child 1*/ 41 fd = open(PATHNAME, O_RDWR); /*打开fifo文件*/ 42 write(fd, "Hello", 6); /*写点儿东西*/ 43 sleep(1); /*停一会儿*/ 44 read(fd, buf, BUFSIZ); /*阻塞读*/ 45 close(fd); 46 puts(buf); /*展示读到了什么*/ 47 remove(PATHNAME); /*把创建的fifo文件删了*/ 48 exit(0); 49 } 50 return 0; 51 }
代码执行结果如下：
上述的代码构造了两个unrelated process，并且通过FIFOs来回写了一次。
第二个例子，pipeline向pipeline之间传数据，shell调用tee命令
mkfifo fifo1
prog3 < fifo1 &
prog1 < infile | tee fifo1 | prog2
上述shell command的实际流程就是下面的图：
如果没有FIFO这个环节，就只能用临时文件：因为prog3是一个进程，而tee的stdout只能输出prog2，因此tee输出到FIFO就相当于输出到了prog3中。
第三个例子，CS架构的数据汇合节点，如下图所示：
（1）从C向S，通过well-known FIFO
（2）从S向C，server给每个client都分配一个unique FIFO
（3）如果client crash了，server向client执行write的时候，会出发SIGPIPE信号。
15.6 XSI IPC
书上这部分内容比较抽象，讲述的就是XSI IPC三种类型（message queues, semaphores, and shared memory）的共性：
1. Identifiers and Keys：
Keys用于全局唯一标识某种IPC，常用的生成Keys的方式是利用pathname+project ID的方式来生成，具体的函数是ftok函数。
Identifiers依赖于Keys，向msgget函数传入参数Keys来生成Identifier；这个Identifier在进程内部唯一标识某个IPC，具体的函数是msgget函数。
为什么要搞这种内外分开的设计模式？
我猜这是因为方便管理进程对于某个IPC structure的权限管理：Keys的意思是，IPC structure客观上就在那里摆着（由pathname+project ID决定）；但是，每个进程中再由Keys生成Identifiers的时候，必须设定相应的权限。通过这样的方式，管理了不同进程对相同IPC structure的不同权限。
/* 2015.12.24日补充*/
看到chapter17的时候，以17.3 17.4的messsage queue为例：同一台机器上，一个process中规定了key，创建了message queue以及其poll接收方；另一个process利用这个key，并且创建了message queue的消息发送方。
（1）在两个process之间，这个key就是两个不同process之间通信的信物
（2）在每个process内部，分别由相同的key产生各自process内部的identifier（类似file descriptor），这个id就相当于这个key在进程内部的别名。
这才是稍微正确的打开方式，理解为什么要有key以及identifier。从这个角度理解，message queue的key也就是一个文件名了，不同的process里面通过各自的identifier关联到这个message queue上。
/****************/
2. Permission Structure
通过一个struct ipc_perm中的各项属性来决定。
3. Configuration Limits
这是由kernel管的。
4. Advantages and Disadvantages
没太看懂。
15.7 Message Queues
书上缺少具体的例子，参考下面的blog（http://www.cnblogs.com/chuyuhuashi/p/4475904.html）中的代码例子，模拟一个单机版的Message Queues。
代码分为三个部分：
第一个部分是记录消息队列接口参数以及消息主体结构体的头文件proto.h，如下：
1 #ifndef PROTO_H_ 2 #define PROTO_H_ 3 4 #define NAMESIZE 32 5 6 #define KEYPATH "/tmp/out" 7 8 #define KEYPROJ 'a' 9 10 #define MSGTYPE1 11 11 #define MSGTYPE2 12 12 13 struct msg_st{ 14 long mtype; 15 char name[NAMESIZE]; 16 int chinese; 17 int math; 18 }; 19 20 #endif
第二个部分是消息队列接收部分，reciver.c如下：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <sys/types.h> 4 #include <sys/ipc.h> 5 #include <sys/msg.h> 6 7 #include "proto.h" 8 9 int main(int argc, char *argv[]) 10 { 11 key_t key; 12 int msgid; 13 struct msg_st rbuf; 14 15 /*创建key 标识从哪个消息队列接收*/ 16 key = ftok(KEYPATH, KEYPROJ); 17 if (key<0) { 18 perror("ftok()"); 19 exit(1); 20 } 21 22 /*reciver创建消息队列*/ 23 msgid = msgget(key, IPC_CREAT|0600); /*0400和0200的合体 具有user-read和user-write的权限*/ 24 if (msgid<0) { 25 perror("msgget()"); 26 exit(1); 27 } 28 29 /*不断从消息队列中接收消息*/ 30 while (1) { 31 /*接收消息*/ 32 if (msgrcv(msgid, &rbuf, sizeof(rbuf)-sizeof(long),0,0)<0) { 33 perror("msgrcv"); 34 exit(1); 35 } 36 /*校验消息类型*/ 37 if (rbuf.mtype == MSGTYPE1) { 38 printf("MSGTYPE1:\n"); 39 printf("name = %s\n", rbuf.name); 40 printf("math = %d\n", rbuf.math); 41 printf("chinese = %d\n", rbuf.chinese); 42 } 43 else if (rbuf.mtype == MSGTYPE2) { 44 printf("MSGTYPE2:\n"); 45 printf("name = %s\n", rbuf.name); 46 printf("math = %d\n", rbuf.math); 47 printf("chinese = %d\n", rbuf.chinese); 48 } 49 else { 50 exit(1); 51 } 52 } 53 54 /*移除消息队列信息*/ 55 msgctl(msgid, IPC_RMID, NULL); 56 exit(0); 57 }
第三部分是向消息队列发送消息的部分，sender.c如下：
#include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include <string.h> #include <unistd.h> #include <time.h> #include "proto.h" int main(int argc, char *argv[]) { key_t key; int msgid; struct msg_st sbuf; srand(time(NULL)); /*创建key 用于标识发送到哪个消息队列*/ key = ftok(KEYPATH, KEYPROJ); if (key<0) { perror("ftok()"); exit(1); } /*由于reciver已经创建了以key为标识的消息队列 所以只需要得到msgid即可*/ msgid = msgget(key, 0); if (msgid<0) { perror("msgget()"); exit(1); } /*构建消息主体*/ sbuf.mtype = MSGTYPE1; strcpy(sbuf.name, "type1 sender"); sbuf.math = rand()%100; sbuf.chinese = rand()%100; /*发送消息*/ if (msgsnd(msgid, &sbuf, sizeof(sbuf)-sizeof(long),0)<0) { perror("msgsnd()"); exit(1); } sbuf.mtype = MSGTYPE2; strcpy(sbuf.name, "type2 sender"); sbuf.math = rand()%100; sbuf.chinese = rand()%100; if (msgsnd(msgid, &sbuf, sizeof(sbuf)-sizeof(long),0)<0) { perror("msgsnd()"); exit(1); } /*发送完毕*/ puts("ok!"); exit(0); }
执行结果如下：
操作流程如下：
（1）先启动./reciver（ps -a查看，确实有reciver再运行），建立消息队列并不断做好准备从消息队列中循环接收消息。
（2）启动./sender ，向reciver建立的消息队列中发送消息。
（3）reciver通过消息队列接收到了sender发来的消息，做出响应并输出结果
上面的流程，就是典型的消息队列通信流程，其中涉及到如下几个关键函数：
1. ftok函数
key_t ftok(const char *path, int id)
函数的作用是根据输入参数获得唯一的标示某个消息队列的key_t型变量。
一个消息队列必须对应唯一的key_t；如果reciver和sender想要对应同一个消息队列，reciver和sender就必须用同样的path和id作为参数，生成key_t。path和id就是定义在proto.h中的两个宏：
注意。这里的KEYPATH所指的文件必须是存在的，如果不存在，则会报错。
2. msgget函数
int msgget(key_t key, int flag)
打开或者创建一个消息队列。如果消息队列不存在，就创建之；如果存在了，就打开之。
其中key就是就ftok生成的唯一标识消息队列的key_t类型变量；flag其中一个作用是控制权限，以及消息队列的打开模式。
函数的返回值是int型，就是前面提到的消息队列identifier。在process内部的所有对消息队列的进一步操作，都用msgid来唯一标识这个消息队列。
3. msgrcv函数
ssize_t msgrcv(int msqid, void *ptr, size_t nbytes, long type, int flag)
用于消息队列接收端，接受消息。
msqid：进程中由msgget产生的消息队列进程内唯一id，即告诉从哪个进程接受消息。
ptr：指向一个long类型的地址，即告诉消息从消息队列中读完之后存到哪里。上述代码中是一个结构体，即消息队列中每个消息的定义结构，reciver和sender都要知道这个结构才能使IPC通信完成。
nbytes：ptr所指的long类型再往后读多少bytes的消息数据内容；默认每个消息的开头都是long类型，这个long类型只表征消息的类型，不涉及到消息的内容；跳过这个long的大小之后，紧接着的都是消息内容，这个nbytes表征了读多少消息内容。
type：等于0标示读消息队列中最近一个消息；大于0表示，只读最近一个type=ptr所指向的long变量类型的值（在这里就是mtype的值）；小于0也有其对应的意义。
flag：有一个重要属性是IPC_NOWAIT；正常msgrcv这个函数是阻塞的，即干等着收到消息才返回；如果在flag中设置了IPC_NOWAIT这个标志位，则不会干等着，一旦没有马上获取消息队列中的消息，就马上返回了，并且将errno设置为EIDRM。即，默认不改动flag情况下，msgrcv是一个阻塞函数：每次就从消息队列中读那么多，读到了才算完事儿，否则就干等着。
函数的返回值是从消息的数据部分（不包括long类型的mtype）。
这里有关ptr结构体成员的定义是有严格要求的：第一个成员必须是long类型的mtype，并且必须是大于0的值。为什么这样？这几个函数就是这么协定的。即完整的消息结构必须是：“long表示的消息类型+紧跟着的消息数据内容”
4. msgsnd函数
int msgsnd(int msqid, const void *ptr, size_t nbytes, int flag)
与3相同的几个参数不再赘述。
flag的设置也可以设为IPC_NOWAIT；不同的在于如果没有立刻向队列中发出去消息，则将errno设为EAGAIN，表示资源繁忙。
5. msgctl函数
int msgctl(int msqid, int cmd, struct msqid_ds *buf)
这是个消息队列的管家函数。
cmd可以取值为 {IPC_STAT，IPC_SET，IPC_RMID}
根据cmd不同取值，执行不同的功能。上述代码中执行的是删除功能。
15.8 Semaphores
信号量是一个“counter used to provide access to a shared data object for multiple processes”。即保证多进程对于shared data object进行同步操作。APUE的作者对XSI IPC的semaphore的评价并不是很高，使用上比较复杂，并且有时候容易遇到各种坑。
通过一个例子，来说明semaphore的一般用法，代码如下；
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 #include <unistd.h> 5 #include <sys/wait.h> 6 #include <sys/types.h> 7 #include <sys/ipc.h> 8 #include <sys/sem.h> 9 #include <errno.h> 10 11 #define PROCNUM 10 12 #define FNAME "/tmp/out" 13 #define BUFSIZE 1024 14 15 static int semid; /*所有的进程都要访问的资源 且不会被修改*/ 16 17 static void P(int sem_index){ 18 struct sembuf op; 19 op.sem_num = sem_index; /*semid标定的semaphore set中具体第sem_index下标的那个semaphore*/ 20 op.sem_op = -1; /*申请占用1个资源*/ 21 op.sem_flg = 0; /*没有特殊要求*/ 22 while (semop(semid,&op,1)<0) { /*这里的'1'指的是从&op这个地址往后取几个struct sembuf*/ 23 if (errno!=EINTR && errno!=EAGAIN) { 24 perror("semop()"); 25 exit(1); 26 } 27 } 28 } 29 30 static void V(int sem_index){ 31 struct sembuf op; 32 op.sem_num = sem_index; 33 op.sem_op = 1; /*释放1个资源*/ 34 op.sem_flg = 0; 35 while (semop(semid,&op,1)<0) { 36 if (errno!=EINTR && errno!=EAGAIN) { 37 perror("semop()"); 38 exit(1); 39 } 40 } 41 } 42 43 static void func_add(){ 44 FILE *fp; 45 char buf[BUFSIZE]; 46 fp = fopen(FNAME, "r+"); /*所有child process都可以打开FNAME*/ 47 /*并且所有的child process都必须按照套路出牌 先敲门再访问*/ 48 P(0); /*占用资源*/ 49 P(1); 50 fgets(buf, BUFSIZE, fp); 51 rewind(fp); 52 sleep(1); 53 fprintf(fp,"%d\n",atoi(buf)+1); 54 fflush(fp); 55 V(1); 56 V(0); /*释放资源*/ 57 fclose(fp); 58 } 59 60 int main(int argc, char *argv[]){ 61 int i; 62 pid_t pid; 63 /*由于都是在亲缘关系的process之间 因此可以用IPC_PRIVATE宏生成semid*/ 64 semid = semget(IPC_PRIVATE, 2, 0600); /*创建两个semaphore*/ 65 if (semid<0) { 66 perror("segment()"); 67 exit(1); 68 } 69 if (semctl(semid,0,SETVAL,1)<0) { /*设置semaphore[0]资源数量是1*/ 70 perror("semctl()"); 71 exit(1); 72 } 73 if (semctl(semid,1,SETVAL,1)<0) { /*设置semaphore[1]资源的数量是1*/ 74 perror("semctl()"); 75 exit(1); 76 } 77 /*fork出20个子进程*/ 78 for (i=0; i<PROCNUM; i++){ 79 pid = fork(); 80 if (pid==0) { /*每次在child process中执行对semaphore的操作*/ 81 func_add(); 82 exit(0); 83 } 84 } 85 for(i=0; i<PROCNUM; i++) /*等着fork出来的所有child都返回完成了*/ 86 wait(NULL); 87 semctl(semid, 0, IPC_RMID); /*移除这个semaphore*/ 88 exit(0); 89 }
代码执行到功能，是10个进程向同一个文件（/tmp/out）中累加数据，用信号量的方式对多进程操作同步。
有了前面消息队列的基础，对semaphore的几个函数梳理如下：
1. semget函数
int segmet(key_t key, int nsems, int flag)
创建信号量
key : 喂给这个函数key（这个key是不同进程中唯一标示semaphore的，上面的例子中，由于各个process都是由一个parent fork出来的，属于亲属关系，因此用IPC_PRIVATE作为key即可）
nsems : 创建信号量的数量（上述代码是2个）
flag：一些特殊要求设置flag位
函数的返回值在是semaphore在进程内部的唯一标示
2. semctl函数
信号量的管理函数
int semctl(int semid, int semnum, int cmd, ... /* union semun arg */)
semid : 进程内部唯一标示semaphore的identifier
semnum : 这个变量有点别扭，即semid标示的是一个semaphore数组，semnum指的是这个数组中的semaphore下标（在上面的代码中由于semid标示的数组总共有两个semaphore资源，所以这里semnum可以取值为{0，1}）。
cmd : 要对某个semaphore执行的具体操作（上述代码中是SETVAL，即只对一个semaphore资源操作）
3. semop函数
int semop(int semid, struct sembuf semop_array[], size_t nops)
对信号量操作
semid：同上
semop_array：struct sembuf类型的结构体数组指针，每个结构体中存放着要对semid所指向的某个semaphore的操作信息。
struct sembuf{ unsigned short sem_num; /*semid标定的semaphore数组中的元素下标*/ short sem_op; /*正几就是占用几个资源 负几就是释放几个资源 0代表等着资源是0*/ short sem_flg; /*特殊要求 设置flag位*/ }
nops：代表semop_array的数量，到底有多少个op需要加在semaphore上面
15.9 Shared Memory
优点就是速度快，缺点是同步起来麻烦，得借助信号量之类的。
这种shared memory不像之前的消息队列或信号量，没有显式的文件名。
通过shared memory这种方式可以方便的在parent process和child process之间通信。
直接看一个列子：
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <sys/mman.h> 4 #include <sys/types.h> 5 #include <sys/stat.h> 6 #include <unistd.h> 7 #include <fcntl.h> 8 #include <string.h> 9 #include <sys/ipc.h> 10 #include <sys/shm.h> 11 #include <sys/wait.h> 12 13 #define MEMSIZE 1024 14 15 int main(int argc, char *argv[]) 16 { 17 char *ptr; 18 pid_t pid; 19 int shmid; 20 21 shmid = shmget(IPC_PRIVATE, MEMSIZE, 0600); 22 23 if ((pid=fork())<0) { 24 perror("fork()"); 25 } 26 else if (pid==0) { /*child process*/ 27 ptr = shmat(shmid, NULL, 0); 28 printf("CHILD : shared memory from %p to %p\n", (void*)ptr, (void*)ptr+MEMSIZE); 29 fflush(stdout); 30 strcpy(ptr, "hello"); 31 shmdt(ptr); 32 exit(0); 33 } 34 else { /*parent process*/ 35 wait(NULL); 36 ptr = shmat(shmid, NULL, 0); 37 printf("PARENT : shared memory from %p to %p\n", (void*)ptr, (void*)ptr+MEMSIZE); 38 puts(ptr); 39 shmdt(ptr); 40 shmctl(shmid, IPC_RMID, NULL); 41 exit(0); 42 } 43 }
上述代码开辟了一段shared memory（line21）；child process向这段shared memory写入“hello"字符串；parent process从这段shared memory读入内容再输出到terminal上。运行结果如下：
shared memory的关键在于：
（1）shmget函数：负责理出来一块memroy专门用于shared memory，仅仅是理出来这么一块memory，并且生成了shmid这个identifier，唯一标识这块shared memory。
（2）shmat函数：shmget函数整理出来的shared memory还不能够被其他process访问，而shmat做的事情就是启动当前process对这段shared memory的访问，把这段shared memory对接到当前process的memory space上，并返回这段共享内存在当前process中的起始地址，即上述代码中的ptr。child process和parent process中的ptr相当于这段shared memory的代言人。
乍看上述代码的输出，为什么child和parent中的ptr的值都相同呢？分析一下不难得出结论：
这个地址绝对不是shared memory的实际地址，而是这段shared memory在child和process内部各自的地址代言人。既然各自process中的代言人，为什么还相同呢？原因有两个：
（1）ptr的产生方式都是 ptr = shmat(shmid ,0 ,0) 即让系统的算法自动给这段shared memory在当前process的memory layout中找到first avalialbe的地址。
（2）parent process通过fork的方式产生child process，则child与process在memory layout上完全copy过去的。因此，按照（1）中提到的方法，在child和parent的内部获得的地址一定是相同的。
