管道由pipe函数创建，提供一个单向数据流。pipe函数返回两个文件描述符:fd[0]与fd[1],前者打开来读，后者打开来写。
管道的典型用途是在父子进程之前提供进程间通信手段。首先，由父进程创建一个管道，然后调用fork创建子进程。如果父进程关闭管道的读出端，子进程关闭管道的写入端。在父子进程间就形成了一个单向数据流。
通常我们在shell中输入一个像下面的命令时：
cmd1 | cmd2 | cmd3
将会创建三个进程和其中的两个管道。将每个进程的读出端复制到相应进程的标准输入，把每个管道的写入端复制到相应进程的标准输出。
#include <unistd.h>
int pipe(int filedes[2]);成功的pipe调用会在数组filedes中返回两个打开的文件描述符；一个表示管道的读取端filedes[0],另一个表示管道的写入端filedes[1]。
As with any file descriptor, we can use the read() and write() system calls to perform I/O on the pipe. Once written to the write end of a pipe, data is immediately available to be read from the read end. A read() from a pipe obtains the lesser of the number of bytes requested and the number of bytes currently available in the pipe (but blocks if the pipe is empty).关闭未使用管道文件描述符
关闭未使用管道文件描述符不仅仅是为了确保进程不会耗尽文件描述符，存在如下两个方面原因：
如果读取进程没有关闭管道的写入端，那么再其他进程关闭了写入描述符之后，读者也不会看到文件结束符，即使它读完了管道中的数据，read()会阻塞以等待数据，这是因为内核知道至少还存在一个管道的写入描述符打开着，即读取进程自己打开了这个描述符。
写入进程关闭其持有的管道的读取描述符是出于不同的原因。当一个进程试图向一个管道中写入数据但没有任何进程拥有该管道的打开着的读取描述符时，内核会向写入进程发送一个SIGPIPE信号。但该进程可以捕获或忽略该信号，这样就会导致管道上的write()操作因EPIPE错误（已损坏管道）而失败。收到SIGPIPE信号或得到EPIPE错误对于表示管道的状态是有用的，这就是为何需要关闭管道的未使用读取描述符的原因。
在父进程和子进程间使用管道通信
/*************************************************************************\
* Copyright (C) Michael Kerrisk, 2018. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU General Public License as published by the *
* Free Software Foundation, either version 3 or (at your option) any *
* later version. This program is distributed without any warranty. See *
* the file COPYING.gpl-v3 for details. *
\*************************************************************************/
/* Listing 44-2 */
/* simple_pipe.c
Simple demonstration of the use of a pipe to communicate
between a parent and a child process.
Usage: simple_pipe "string"
The program creates a pipe, and then calls fork() to create a child process.
After the fork(), the parent writes the string given on the command line
to the pipe, and the child uses a loop to read data from the pipe and
print it on standard output.
*/
#include <sys/wait.h>
#include "tlpi_hdr.h"
#define BUF_SIZE 10
int
main(int argc, char *argv[])
{
int pfd[2]; /* Pipe file descriptors */
char buf[BUF_SIZE];
ssize_t numRead;
if (argc != 2 || strcmp(argv[1], "--help") == 0)
usageErr("%s string\n", argv[0]);
if (pipe(pfd) == -1) /* Create the pipe */
errExit("pipe");
switch (fork()) {
case -1:
errExit("fork");
case 0: /* Child - reads from pipe */
if (close(pfd[1]) == -1) /* Write end is unused */
errExit("close - child");
for (;;) { /* Read data from pipe, echo on stdout */
numRead = read(pfd[0], buf, BUF_SIZE);
if (numRead == -1)
errExit("read");
if (numRead == 0)
break; /* End-of-file */
if (write(STDOUT_FILENO, buf, numRead) != numRead)
fatal("child - partial/failed write");
}
write(STDOUT_FILENO, "\n", 1);
if (close(pfd[0]) == -1)
errExit("close");
_exit(EXIT_SUCCESS);
default: /* Parent - writes to pipe */
if (close(pfd[0]) == -1) /* Read end is unused */
errExit("close - parent");
if (write(pfd[1], argv[1], strlen(argv[1])) != strlen(argv[1]))
fatal("parent - partial/failed write");
if (close(pfd[1]) == -1) /* Child will see EOF */
errExit("close");
wait(NULL); /* Wait for child to finish */
exit(EXIT_SUCCESS);
}
}
/*************************************************************************\
* Copyright (C) Michael Kerrisk, 2018. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU General Public License as published by the *
* Free Software Foundation, either version 3 or (at your option) any *
* later version. This program is distributed without any warranty. See *
* the file COPYING.gpl-v3 for details. *
\*************************************************************************/
/* Listing 44-3 */
/* pipe_sync.c
Show how pipes can be used for synchronizing the actions of a parent and
multiple child processes.
Usage: pipe_sync sleep-time...
After creating a pipe, the program creates one child for each command-line
argument. Each child simulates doing some work by sleeping for the number of
seconds specified in the corresponding command-line argument. When it has
finished doing its "work", each child closes its file descriptor for the
write end of the pipe; the parent can see that all children have finished
their work when it sees end-of-file on the read end of the pipe.
*/
#include "curr_time.h" /* Declaration of currTime() */
#include "tlpi_hdr.h"
int
main(int argc, char *argv[])
{
int pfd[2]; /* Process synchronization pipe */
int j, dummy;
if (argc < 2 || strcmp(argv[1], "--help") == 0)
usageErr("%s sleep-time...\n", argv[0]);
setbuf(stdout, NULL); /* Make stdout unbuffered, since we
terminate child with _exit() */
printf("%s Parent started\n", currTime("%T"));
if (pipe(pfd) == -1)
errExit("pipe");
for (j = 1; j < argc; j++) {
switch (fork()) {
case -1:
errExit("fork %d", j);
case 0: /* Child */
if (close(pfd[0]) == -1) /* Read end is unused */
errExit("close");
/* Child does some work, and lets parent know it's done */
sleep(getInt(argv[j], GN_NONNEG, "sleep-time"));
/* Simulate processing */
printf("%s Child %d (PID=%ld) closing pipe\n",
currTime("%T"), j, (long) getpid());
if (close(pfd[1]) == -1)
errExit("close");
/* Child now carries on to do other things... */
_exit(EXIT_SUCCESS);
default: /* Parent loops to create next child */
break;
}
}
/* Parent comes here; close write end of pipe so we can see EOF */
if (close(pfd[1]) == -1) /* Write end is unused */
errExit("close");
/* Parent may do other work, then synchronizes with children */
if (read(pfd[0], &dummy, 1) != 0)
fatal("parent didn't get EOF");
printf("%s Parent ready to go\n", currTime("%T"));
/* Parent can now carry on to do other things... */
exit(EXIT_SUCCESS);
}
Using a pipe to connect ls and wc
/*************************************************************************\
* Copyright (C) Michael Kerrisk, 2018. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU General Public License as published by the *
* Free Software Foundation, either version 3 or (at your option) any *
* later version. This program is distributed without any warranty. See *
* the file COPYING.gpl-v3 for details. *
\*************************************************************************/
/* Listing 44-4 */
/* pipe_ls_wc.c
Demonstrate the use of a pipe to connect two filters. We use fork()
to create two children. The first one execs ls(1), which writes to
the pipe, the second execs wc(1) to read from the pipe.
*/
#include <sys/wait.h>
#include "tlpi_hdr.h"
int
main(int argc, char *argv[])
{
int pfd[2]; /* Pipe file descriptors */
if (pipe(pfd) == -1) /* Create pipe */
errExit("pipe");
switch (fork()) {
case -1:
errExit("fork");
case 0: /* First child: exec 'ls' to write to pipe */
if (close(pfd[0]) == -1) /* Read end is unused */
errExit("close 1");
/* Duplicate stdout on write end of pipe; close duplicated descriptor */
if (pfd[1] != STDOUT_FILENO) { /* Defensive check */
if (dup2(pfd[1], STDOUT_FILENO) == -1)
errExit("dup2 1");
if (close(pfd[1]) == -1)
errExit("close 2");
}
execlp("ls", "ls", (char *) NULL); /* Writes to pipe */
errExit("execlp ls");
default: /* Parent falls through to create next child */
break;
}
switch (fork()) {
case -1:
errExit("fork");
case 0: /* Second child: exec 'wc' to read from pipe */
if (close(pfd[1]) == -1) /* Write end is unused */
errExit("close 3");
/* Duplicate stdin on read end of pipe; close duplicated descriptor */
if (pfd[0] != STDIN_FILENO) { /* Defensive check */
if (dup2(pfd[0], STDIN_FILENO) == -1)
errExit("dup2 2");
if (close(pfd[0]) == -1)
errExit("close 4");
}
execlp("wc", "wc", "-l", (char *) NULL);
errExit("execlp wc");
default: /* Parent falls through */
break;
}
/* Parent closes unused file descriptors for pipe, and waits for children */
if (close(pfd[0]) == -1)
errExit("close 5");
if (close(pfd[1]) == -1)
errExit("close 6");
if (wait(NULL) == -1)
errExit("wait 1");
if (wait(NULL) == -1)
errExit("wait 2");
exit(EXIT_SUCCESS);
}
运行结果:
root@52coder:~/tlpi-dist/pipes# ./pipe_ls_wc
18
root@52coder:~/tlpi-dist/pipes# ls |wc -l
18
root@52coder:~/tlpi-dist/pipes# 关于dup和dup2的一个解释非常清晰的视频dup dup2 example
通过管道与shell命令通信:popen()
/*************************************************************************\
* Copyright (C) Michael Kerrisk, 2018. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU General Public License as published by the *
* Free Software Foundation, either version 3 or (at your option) any *
* later version. This program is distributed without any warranty. See *
* the file COPYING.gpl-v3 for details. *
\*************************************************************************/
/* Listing 44-5 */
/* popen_glob.c
Demonstrate the use of popen() and pclose().
This program reads filename wildcard patterns from standard input and
passes each pattern to a popen() call that returns the output from ls(1)
for the wildcard pattern. The program displays the returned output.
*/
#include <ctype.h>
#include <limits.h>
#include "print_wait_status.h" /* For printWaitStatus() */
#include "tlpi_hdr.h"
#define POPEN_FMT "/bin/ls -d %s 2> /dev/null"
#define PAT_SIZE 50
#define PCMD_BUF_SIZE (sizeof(POPEN_FMT) + PAT_SIZE)
int
main(int argc, char *argv[])
{
char pat[PAT_SIZE]; /* Pattern for globbing */
char popenCmd[PCMD_BUF_SIZE];
FILE *fp; /* File stream returned by popen() */
Boolean badPattern; /* Invalid characters in 'pat'? */
int len, status, fileCnt, j;
char pathname[PATH_MAX];
for (;;) { /* Read pattern, display results of globbing */
printf("pattern: ");
fflush(stdout);
if (fgets(pat, PAT_SIZE, stdin) == NULL)
break; /* EOF */
len = strlen(pat);
if (len <= 1) /* Empty line */
continue;
if (pat[len - 1] == '\n') /* Strip trailing newline */
pat[len - 1] = '\0';
/* Ensure that the pattern contains only valid characters,
i.e., letters, digits, underscore, dot, and the shell
globbing characters. (Our definition of valid is more
restrictive than the shell, which permits other characters
to be included in a filename if they are quoted.) */
for (j = 0, badPattern = FALSE; j < len && !badPattern; j++)
if (!isalnum((unsigned char) pat[j]) &&
strchr("_*?[^-].", pat[j]) == NULL)
badPattern = TRUE;
if (badPattern) {
printf("Bad pattern character: %c\n", pat[j - 1]);
continue;
}
/* Build and execute command to glob 'pat' */
snprintf(popenCmd, PCMD_BUF_SIZE, POPEN_FMT, pat);
fp = popen(popenCmd, "r");
if (fp == NULL) {
printf("popen() failed\n");
continue;
}
/* Read resulting list of pathnames until EOF */
fileCnt = 0;
while (fgets(pathname, PATH_MAX, fp) != NULL) {
printf("%s", pathname);
fileCnt++;
}
/* Close pipe, fetch and display termination status */
status = pclose(fp);
printf(" %d matching file%s\n", fileCnt, (fileCnt != 1) ? "s" : "");
printf(" pclose() status = %#x\n", (unsigned int) status);
if (status != -1)
printWaitStatus("\t", status);
}
exit(EXIT_SUCCESS);
}
执行结果:
root@52coder:~/tlpi-dist/pipes# ./popen_glob
pattern: popen_glob*
popen_glob
popen_glob.c
2 matching files
pclose() status = 0
child exited, status=0
pattern:
命名管道
有一篇非常清晰和基础的文章，关于命名管道。Linux mkfifo Command Tutorial for Beginners (with Examples)
文章中讲了一个非常实用的技巧，实用命令mkfifo pipe2创建了一个fifo，接着在两个终端中先后执行如下操作：
终端A ls / >pipe2
终端B cat < pipe2
终端B中可以看到在终端A中ls /的结果。
Linux/UNIX系统编程手册一书中给了一个相类似的例子：
#创建一个名为myfifo的fifo
$ mkfifo myfifo
#打开myfifo读取数据，在直到有进程打开fifo并写入数据前阻塞
$ wc -l < myfifo &
#ls显示的结果，一份给fifo，另一份给sort，给到fifo数据后wc -l会显示输出
$ ls -l | tee myfifo | sort -k5n
执行结果可以使用下面的图来总结：
tee命令将其从标准输入中读取到的数据复制两份并输出：一份写入到标准输出，另一份写入到通过参数指定的文件中。
将传给tee命令的file参数设置为一个FIFO可以让两个进程同时读取tee产生的两份数据。
执行的实际显示如下
root@52coder:~# mkfifo myfifo
root@52coder:~# wc -l < myfifo &
[1] 29172
root@52coder:~# ls -l | tee myfifo |sort -k5n
prw-r--r-- 1 root root 0 5月 3 17:48 myfifo
total 20
drwxr-xr-x 23 root root 4096 5月 2 17:28 PR
drwxr-xr-x 2 root root 4096 5月 3 12:25 workspace
drwxr-xr-x 39 root root 4096 5月 2 17:28 unp
drwxr-xr-x 50 root root 4096 5月 2 22:56 tlpi-dist
drwxr-xr-x 6 root root 4096 5月 2 17:28 redis-3.0
root@52coder:~# 7
#单机回车后输出如下信息
[1]+ Done wc -l < myfifo使用管道实现客户端/服务器应用程序
fifo_seqnum.h
/*************************************************************************\
* Copyright (C) Michael Kerrisk, 2018. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU General Public License as published by the *
* Free Software Foundation, either version 3 or (at your option) any *
* later version. This program is distributed without any warranty. See *
* the file COPYING.gpl-v3 for details. *
\*************************************************************************/
/* Listing 44-6 */
/* fifo_seqnum.h
Header file used by fifo_seqnum_server.c and fifo_seqnum_client.c
These programs create FIFOS in /tmp. This makes it easy to compile and
run the programs. However, for a security reasons, a real-world
application should never create sensitive files in /tmp. (As a simple of
example of the kind of security problems that can result, a malicious
user could create a FIFO using the name defined in SERVER_FIFO, and
thereby cause a denial of service attack against this application.
See Section 38.7 of "The Linux Programming Interface" for more details
on this subject.)
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "tlpi_hdr.h"
#define SERVER_FIFO "/tmp/seqnum_sv"
/* Well-known name for server's FIFO */
#define CLIENT_FIFO_TEMPLATE "/tmp/seqnum_cl.%ld"
/* Template for building client FIFO name */
#define CLIENT_FIFO_NAME_LEN (sizeof(CLIENT_FIFO_TEMPLATE) + 20)
/* Space required for client FIFO pathname
(+20 as a generous allowance for the PID) */
struct request { /* Request (client --> server) */
pid_t pid; /* PID of client */
int seqLen; /* Length of desired sequence */
};
struct response { /* Response (server --> client) */
int seqNum; /* Start of sequence */
};
file_seqnum_server.c
/*************************************************************************\
* Copyright (C) Michael Kerrisk, 2018. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU General Public License as published by the *
* Free Software Foundation, either version 3 or (at your option) any *
* later version. This program is distributed without any warranty. See *
* the file COPYING.gpl-v3 for details. *
\*************************************************************************/
/* Listing 44-7 */
/* fifo_seqnum_server.c
An example of a server using a FIFO to handle client requests.
The "service" provided is the allocation of unique sequential
numbers. Each client submits a request consisting of its PID, and
the length of the sequence it is to be allocated by the server.
The PID is used by both the server and the client to construct
the name of the FIFO used by the client for receiving responses.
The server reads each client request, and uses the client's FIFO
to send back the starting value of the sequence allocated to that
client. The server then increments its counter of used numbers
by the length specified in the client request.
See fifo_seqnum.h for the format of request and response messages.
The client is in fifo_seqnum_client.c.
*/
#include <signal.h>
#include "fifo_seqnum.h"
int
main(int argc, char *argv[])
{
int serverFd, dummyFd, clientFd;
char clientFifo[CLIENT_FIFO_NAME_LEN];
struct request req;
struct response resp;
int seqNum = 0; /* This is our "service" */
/* Create well-known FIFO, and open it for reading */
umask(0); /* So we get the permissions we want */
if (mkfifo(SERVER_FIFO, S_IRUSR | S_IWUSR | S_IWGRP) == -1
&& errno != EEXIST)
errExit("mkfifo %s", SERVER_FIFO);
serverFd = open(SERVER_FIFO, O_RDONLY);
if (serverFd == -1)
errExit("open %s", SERVER_FIFO);
/* Open an extra write descriptor, so that we never see EOF */
dummyFd = open(SERVER_FIFO, O_WRONLY);
if (dummyFd == -1)
errExit("open %s", SERVER_FIFO);
/* Let's find out about broken client pipe via failed write() */
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) errExit("signal");
for (;;) { /* Read requests and send responses */
if (read(serverFd, &req, sizeof(struct request))
!= sizeof(struct request)) {
fprintf(stderr, "Error reading request; discarding\n");
continue; /* Either partial read or error */
}
/* Open client FIFO (previously created by client) */
snprintf(clientFifo, CLIENT_FIFO_NAME_LEN, CLIENT_FIFO_TEMPLATE,
(long) req.pid);
clientFd = open(clientFifo, O_WRONLY);
if (clientFd == -1) { /* Open failed, give up on client */
errMsg("open %s", clientFifo);
continue;
}
/* Send response and close FIFO */
resp.seqNum = seqNum;
if (write(clientFd, &resp, sizeof(struct response))
!= sizeof(struct response))
fprintf(stderr, "Error writing to FIFO %s\n", clientFifo);
if (close(clientFd) == -1)
errMsg("close");
seqNum += req.seqLen; /* Update our sequence number */
}
}
fifo_seqnum_client.c
/*************************************************************************\
* Copyright (C) Michael Kerrisk, 2018. *
* *
* This program is free software. You may use, modify, and redistribute it *
* under the terms of the GNU General Public License as published by the *
* Free Software Foundation, either version 3 or (at your option) any *
* later version. This program is distributed without any warranty. See *
* the file COPYING.gpl-v3 for details. *
\*************************************************************************/
/* Listing 44-8 */
/* fifo_seqnum_client.c
A simple client that uses a well-known FIFO to request a (trivial)
"sequence number service". This client creates its own FIFO (using a
convention agreed upon by client and server) which is used to receive a reply
from the server. The client then sends a request to the server consisting of
its PID and the length of the sequence it wishes to be allocated. The client
then reads the server's response and displays it on stdout.
See fifo_seqnum.h for the format of request and response messages.
The server is in fifo_seqnum_server.c.
*/
#include "fifo_seqnum.h"
static char clientFifo[CLIENT_FIFO_NAME_LEN];
static void /* Invoked on exit to delete client FIFO */
removeFifo(void)
{
unlink(clientFifo);
}
int
main(int argc, char *argv[])
{
int serverFd, clientFd;
struct request req;
struct response resp;
if (argc > 1 && strcmp(argv[1], "--help") == 0)
usageErr("%s [seq-len]\n", argv[0]);
/* Create our FIFO (before sending request, to avoid a race) */
umask(0); /* So we get the permissions we want */
snprintf(clientFifo, CLIENT_FIFO_NAME_LEN, CLIENT_FIFO_TEMPLATE,
(long) getpid());
if (mkfifo(clientFifo, S_IRUSR | S_IWUSR | S_IWGRP) == -1
&& errno != EEXIST)
errExit("mkfifo %s", clientFifo);
if (atexit(removeFifo) != 0)
errExit("atexit");
/* Construct request message, open server FIFO, and send message */
req.pid = getpid();
req.seqLen = (argc > 1) ? getInt(argv[1], GN_GT_0, "seq-len") : 1;
serverFd = open(SERVER_FIFO, O_WRONLY);
if (serverFd == -1)
errExit("open %s", SERVER_FIFO);
if (write(serverFd, &req, sizeof(struct request)) !=
sizeof(struct request))
fatal("Can't write to server");
/* Open our FIFO, read and display response */
clientFd = open(clientFifo, O_RDONLY);
if (clientFd == -1)
errExit("open %s", clientFifo);
if (read(clientFd, &resp, sizeof(struct response))
!= sizeof(struct response))
fatal("Can't read response from server");
printf("%d\n", resp.seqNum);
exit(EXIT_SUCCESS);
}
有点意思呦