[cpp] view
plaincopyprint?

1. #include <unistd.h>  
2. int dup(int file_descriptor);  
3. int dup2(int file_descriptor_one, int file_descriptor_two);  

• dup创建一个新的文件描述符， 此描述符和原有的file_descriptor指向相同的文件、管道或者网络连接。
• dup返回的文件描述符总是取系统当前可用的最小整数值。

dup2函数通过使用参数file_descriptor_two指定新描述符数值，如果file_descriptor_two已经打开，则先关闭。若file_descriptor_one = file_descriptor_two，而不关闭。

两者调用失败均返回-1, 并设置errno。

[cpp] view
plaincopyprint?

1. //利用dup模拟实现一个基本的CGI服务器  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <unistd.h>  
5. #include <string.h>  
6. #include <errno.h>  
7. #include <sys/socket.h>  
8. #include <arpa/inet.h>  
9. #include <netinet/in.h>  
10. #include <assert.h>  
11.   
12. int main(int argc, char **argv)  
13. {  
14.     if (argc ！= 3) {  
15.          fprintf(stderr, "Usage: %s id port\n", basename(argv[0]));  
16.          return 1;  
17.     }  
18.       
19.     const char *ip = argv[1];  
20.     int port = atoi(argv[2]);  
21.       
22.     struct sockaddr_in address;  
23.     bzero(&address, sizeof(address));  
24.     address.sin_family = AF_INET;  
25.     address.sin_port = htons(port);  
26.     inet_pton(AF_INET, ip, &address.sin_addr);  
27.       
28.     int sock = socket(PF_INET, SOCK_STREAM, 0);  
29.     assert(sock >= 0);  
30.       
31.     int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));  
32.     assert(ret != -1);  
33.       
34.     ret = listen(sock, 5);  
35.     assert(ret != -1);  
36.       
37.     struct sockaddr_in client;  
38.     socklen_t client_addrlength = sizeof(client);  
39.     int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);  
40.     if (connfd < 0) {  
41.         printf("error: %s\n", strerror(errno));  
42.     }  
43.     else {  
44.         close(STDOUT_FILENO); //关闭标准输出  
45.         dup(connfd);          //重定向1到connfd，这样服务器的标准输出内容会直接发送到客户端socket，这就是CGI的基本原理  
46.           
47.         printf("abc. close stdout_fileno test... dup to client\n"); //printf会直接输出会发送到客户端  
48.           
49.         close(connfd);  
50.     }  
51.       
52.     close(sock);  
53.       
54.     return 0;  
55. }  

readv将数据从文件描述符读到分散的内存块中，即分散读。

writev将多块分散的内存一并写入文件描述符中，即集中写。

[cpp] view
plaincopyprint?

1. #include <sys/uio.h>  
2. ssize_t readv(int fd, const struct iovec *vector, int count);  
3. ssize_t writev(int fd, const struct iovec *vector, int count);  

fd参数是被操作的文件描述符。

vector参数是iovec结构体：

[cpp] view
plaincopyprint?

1. #include <sys/uio.h>  
2. struct iovec  
3. {  
4.     void *iov_base;  //指向一个缓冲区，这个缓冲区是存放readv所接收的数据或是writev将要发送的数据  
5.     size_t iov_len;  //接收的长度以及实际写入的长度  
6. };  

       count参数是vector数组的长度，即有多少块内存数据需要从fd读出或写到fd。

       两者调用成功是返回读出/写入fd的字节数，失败返回-1,并设置errno。类似于简化版的recvmsg和sendmsg。

       以下简陋的模拟WEB服务器，采用集中写的方式。省略了HTTP请求的接收及解析， 直接将目标文件作为第3个参数传递给服务端程序，客户端telnet到服务端即可获得该文件。

[cpp] view
plaincopyprint?

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4. #include <unistd.h>  
5. #include <assert.h>  
6. #include <sys/socket.h>  
7. #include <netinet/in.h>  
8. #include <arpa/inet.h>  
9. #include <errno.h>  
10. #include <sys/stat.h>  
11. #include <sys/types.h>  
12. #include <fcntl.h>  
13.   
14. #define BUFFER_SIZE 1024  
15.   
16. //定义两种HTTP状态码和状态信息  
17. static const char *status_line[2] = {"200 OK", "500 Internal server error"};  
18.   
19.   
20. int main(int argc, char **argv)  
21. {  
22.     if(argc != 4) {  
23.         fprintf(stderr, "Usage: %s ip port filename\n", basename(argv[0]));  
24.         return 1;  
25.     }  
26.       
27.     const char *ip = argv[1];  
28.     int port = atoi(argv[2]);  
29.     const char *file_name = argv[3];    //将目标文件作为程序的第三个参数传入  
30.       
31.     struct sockaddr_in address;  
32.     bzero(&address, sizeof(address));  
33.     address.sin_family = AF_INET;  
34.     address.sin_port = htons(port);  
35.     inet_pton(AF_INET, ip, &address.sin_addr);  
36.       
37.     int sock = socket(PF_INET, SOCK_STREAM, 0);  
38.     assert(sock >= 0);  
39.     printf("create socket success\n");  
40.       
41.     int reuse = 1;  
42.     setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));  
43.       
44.     int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));  
45.     assert(ret != -1);  
46.     fprintf(stderr, "bind address success\n");  
47.       
48.     ret = listen(sock, 5);  
49.     assert(ret != -1);  
50.     fprintf(stderr, "listen success\n");  
51.       
52.     struct sockaddr_in client;  
53.     socklen_t client_addrlength = sizeof(client);  
54.       
55.     fprintf(stderr, "start accept...\n");  
56.       
57.     int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);  
58.     if(connfd < 0) {  
59.         printf("error: %s\n", strerror(errno));  
60.     }  
61.     else {  
62.         char header_buf[BUFFER_SIZE];             //用于保存HTTP应答的状态行、头部字段和一个空的缓冲区  
63.         memset(header_buf, '\0', BUFFER_SIZE);  
64.           
65.         char *file_buf = NULL;                    //用于存放目标文件内容的缓存  
66.         struct stat file_stat;                    //用于获取目标文件的属性  
67.         bool valid = true;                        //目标文件是否有效  
68.         int len = 0;                              //记录header_buf当前已使用的字节空间  
69.           
70.         if(stat(file_name, &file_stat) < 0) {     //目标文件不存在  
71.             valid = false;  
72.         }  
73.         else {  
74.             if(S_ISDIR(file_stat.st_mode)) {  //目标文件是目录  
75.                 valid = false;  
76.             }  
77.             else if (file_stat.st_mode & S_IROTH) {               //当前用户是否有读权限，相对于目标文件  
78.                 int fd = open(file_name, O_RDONLY);  
79.                 file_buf = new char[file_stat.st_size + 1];  
80.                 memset(file_buf, '\0', file_stat.st_size + 1);  
81.                   
82.                 fprintf(stderr, "reading %s file...", file_name);  
83.                   
84.                 if (read(fd, file_buf, file_stat.st_size) < 0) {  
85.                         valid = false;  
86.                 }  
87.             }  
88.             else {  
89.                 valid = false;  
90.             }  
91.         }  
92.           
93.   
94.         if (valid) {   //目标文件有效  
95.                 ret = snprintf(header_buf, BUFFER_SIZE-1,  
96.                                 "%s %s\r\n",  
97.                                 "HTTP/1.1", status_line[0]);  
98.                                   
99.                 len += ret;  
100.                 ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,  
101.                                 "content-Length: %ld\r\n",  
102.                                 file_stat.st_size);  
103.                                   
104.                 len += ret;  
105.                 ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,  
106.                                 "%s", "\r\n");  
107.                   
108.                                 //将header_buf和file_buf的内容一并写出                 
109.                 struct iovec iv[2];  
110.                 iv[0].iov_base = header_buf;  
111.                 iv[0].iov_len = strlen(header_buf);  
112.                 iv[1].iov_base = file_buf;  
113.                 iv[1].iov_len = file_stat.st_size;  
114.                   
115.                 fprintf(stderr, "read %s success\nsending %s file to client...\n", file_name, file_name);  
116.                   
117.                 ret = writev(connfd, iv, 2);   //集中写  
118.                   
119.         }  
120.         else {     //目标文件无效  
121.             ret = snprintf(header_buf, BUFFER_SIZE-1,  
122.                             "%s %s\r\n",  
123.                             "HTTP/1.1", status_line[1]);  
124.               
125.             len += ret;  
126.             ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,  
127.                             "%s", "\r\n");  
128.               
129.             fprintf(stderr, "read %s failed\nsending error message to client...\n", file_name);   
130.               
131.             send(connfd, header_buf, strlen(header_buf), 0);  
132.         }  
133.           
134.         close(connfd);  
135.           
136.         if (file_buf != NULL) {  
137.             delete[] file_buf;  
138.             file_buf = NULL;  
139.         }  
140.     }  
141.       
142.     close(sock);  
143.       
144.       
145.     return 0;  
146. }  

sendfile在两个文件描术符之间直接传递数据，完全在内核中操作，从而避免了内核缓冲区到用户缓冲区的拷贝，因此效率很高，称为零拷贝。

[cpp] view
plaincopyprint?

1. #include <sys/sendfile.h>  
2. ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);  

out_fd参数是待写入内容的文件描述符。

in_fd参数是待读出内容的文件描述符。

offset参数指定从读入文件流的哪个位置开始读，如果为空，则从文件流的默认起始位置读入。

count参数指定传输的字节数。

调用成功时返回传输的字节数，失败则为-1，并设置errno

注： man手册指出，in_fd必须是一个支持类似mmap函数的文件描述符，即它必须指向真实的文件，不能是socket和管道；而out_fd必须是一个socket。可见，sendfile专为网络传输文件而生。

[cpp] view
plaincopyprint?

1. //用sendfile函数传输文件  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <unistd.h>  
5. #include <string.h>  
6. #include <assert.h>  
7. #include <errno.h>  
8. #include <sys/socket.h>  
9. #include <netinet/in.h>  
10. #include <arpa/inet.h>  
11. #include <sys/types.h>  
12. #include <sys/stat.h>  
13. #include <sys/sendfile.h>  
14. #include <fcntl.h>  
15.   
16.   
17. int main(int argc, char **argv)  
18. {  
19.     if (argc <= 3) {  
20.         fprintf(stderr, "Usage: %s ip port filename\n", basename(argv[0]));  
21.         return 1;  
22.     }  
23.       
24.     const char *ip = argv[1];  
25.     int port = atoi(argv[2]);  
26.     const char *file_name = argv[3];  
27.       
28.     int filefd = open(file_name, O_RDONLY);  
29.     assert(filefd > 0);  
30.       
31.     struct stat stat_buf;  
32.     fstat(filefd, &stat_buf);  
33.       
34.     struct sockaddr_in address;  
35.     bzero(&address, sizeof(address));  
36.     address.sin_family = AF_INET;  
37.     address.sin_port = htons(port);  
38.     inet_pton(AF_INET, ip, &address.sin_addr);  
39.       
40.     int sock = socket(PF_INET, SOCK_STREAM, 0);  
41.     assert(sock >= 0);  
42.       
43.     int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));  
44.     assert(ret != -1);  
45.       
46.     ret = listen(sock, 5);  
47.     assert(ret != -1);  
48.       
49.     struct sockaddr_in client;  
50.     socklen_t client_addrlength = sizeof(client);  
51.       
52.     int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);  
53.     if (connfd < 0) {  
54.         fprintf(stderr, "errno is: %s\n", strerror(errno));  
55.     }  
56.     else {  
57.         sendfile(connfd, filefd, NULL, stat_buf.st_size);  
58.         close(connfd);  
59.     }  
60.       
61.     close(sock);  
62.       
63.       
64.     return 0;  
65. }  

       splice用于在两个文件描述符之间移动数据， 也是零拷贝。

[cpp] view
plaincopyprint?

1. #include <fcntl.h>  
2. ssize_t splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags);  

       fd_in参数是待输入描述符。如果它是一个管道文件描述符，则off_in必须设置为NULL；否则off_in表示从输入数据流的何处开始读取，此时若为NULL，则从输入数据流的当前偏移位置读入。

       fd_out/off_out与上述相同，不过是用于输出。

       len参数指定移动数据的长度。

flags参数则控制数据如何移动：

• SPLICE_F_NONBLOCK：非阻塞的splice 操作，但实际效果还会受文件描述符本身的阻塞状态的影响。
• SPLICE_F_MORE：给内核一个提示：后续的 splice 系统调用将会有更多的数据传。
• SPLICE_F_MOVE：如果合适的话，按整页内存移动数据。这只是给内核的一个提示。不过，因为它的实现存在BUG，所以自内核2.6.21后，它实际上没有任何效果。

       注意：使用splice时， fd_in和fd_out中必须至少有一个是管道文件描述符。

调用成功时返回移动的字节数量；它可能返回0,表示没有数据需要移动，这通常发生在从管道中读数据时而该管道没有被写入的时候。

失败时返回-1，并设置errno。

                                                                                             splice函数可能产生的errno及其含义

下面代码：通过splice将客户端的内容读入到管道中， 再从管道中读出到客户端，从而实现高效简单的回显服务。整个过程未执行recv/send，因此也未涉及用户空间到内核空间的数据拷贝。

[cpp] view
plaincopyprint?

1. //使用splice实现的回显服务器  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <unistd.h>  
5. #include <sys/socket.h>  
6. #include <netinet/in.h>  
7. #include <arpa/inet.h>  
8. #include <assert.h>  
9. #include <errno.h>  
10. #include <string.h>  
11. #include <fcntl.h>  
12.   
13.   
14. int main(int argc, char **argv)  
15. {  
16.   
17.     if (argc <= 2) {  
18.         printf("usage: %s ip port\n", basename(argv[0]));  
19.         return 1;  
20.     }  
21.       
22.     const char *ip = argv[1];  
23.     int port = atoi(argv[2]);  
24.   
25.     struct sockaddr_in address;  
26.     bzero(&address, sizeof(address));  
27.     address.sin_family = AF_INET;  
28.     address.sin_port = htons(port);  
29.     inet_pton(AF_INET, ip, &address.sin_addr);  
30.   
31.     int sock = socket(PF_INET, SOCK_STREAM, 0);  
32.     assert(sock >= 0);  
33.       
34.     int reuse = 1;  
35.     setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));  
36.   
37.     int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));  
38.     assert(ret != -1);  
39.   
40.     ret = listen(sock, 5);  
41.     assert(ret != -1);  
42.       
43.     struct sockaddr_in client;  
44.     socklen_t client_addrlength = sizeof(client);  
45.       
46.     int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);  
47.     if (connfd < 0) {  
48.         printf("errno is: %s\n", strerror(errno));  
49.     }  
50.     else {  
51.         int pipefd[2];  
52.                   
53.         ret = pipe(pipefd);  //创建管道  
54.         assert(ret != -1);  
55.           
56.                 //将connfd上的客户端数据定向到管道中  
57.         ret = splice(connfd, NULL, pipefd[1], NULL,  
58.                         32768, SPLICE_F_MORE | SPLICE_F_MOVE);  
59.         assert(ret != -1);  
60.           
61.                 //将管道的输出定向到connfd上  
62.         ret = splice(pipefd[0], NULL, connfd, NULL,  
63.                         32768, SPLICE_F_MORE | SPLICE_F_MOVE);  
64.         assert(ret != -1);                
65.           
66.         close(connfd);  
67.     }  
68.   
69.       
70.     close(sock);  
71.   
72.   
73.   
74.   
75.     return 0;  
76. }  

       tee在两个管道文件描述之间复制数据，也是零拷贝操作。

[cpp] view
plaincopyprint?

1. #include <fcntl.h>  
2. ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);  

它的参数与splice相同，但fd_in和fd_out都必须是管道文件描述符，调用成功时返回复制的字节数。返回0表示没有复制任务数据。失败时返回-1，并设置errno。