Linux 高性能服务器编程——高级I/O函数
2014-05-12 15:36
330 查看
重定向dup和dup2函数
dup返回的文件描述符总是取系统当前可用的最小整数值。
dup2函数通过使用参数file_descriptor_two指定新描述符数值，如果file_descriptor_two已经打开，则先关闭。若file_descriptor_one = file_descriptor_two，而不关闭。 两者调用失败均返回-1, 并设置errno。//利用dup模拟实现一个基本的CGI服务器
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <assert.h>
int main(int argc, char **argv)
{
if (argc ！= 3) {
fprintf(stderr, "Usage: %s id port\n", basename(argv[0]));
return 1;
}
const char *ip = argv[1];
int port = atoi(argv[2]);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
int sock = socket(PF_INET, SOCK_STREAM, 0);
assert(sock >= 0);
int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(sock, 5);
assert(ret != -1);
struct sockaddr_in client;
socklen_t client_addrlength = sizeof(client);
int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
if (connfd < 0) {
printf("error: %s\n", strerror(errno));
}
else {
close(STDOUT_FILENO); //关闭标准输出
dup(connfd); //重定向1到connfd，这样服务器的标准输出内容会直接发送到客户端socket，这就是CGI的基本原理
printf("abc. close stdout_fileno test... dup to client\n"); //printf会直接输出会发送到客户端
close(connfd);
}
close(sock);
return 0;
}
分散读readv和集中写writev函数
readv将数据从文件描述符读到分散的内存块中，即分散读。writev将多块分散的内存一并写入文件描述符中，即集中写。#include <sys/uio.h>
ssize_t readv(int fd, const struct iovec *vector, int count);
ssize_t writev(int fd, const struct iovec *vector, int count);fd参数是被操作的文件描述符。vector参数是iovec结构体：#include <sys/uio.h>
struct iovec
{
void *iov_base; //指向一个缓冲区，这个缓冲区是存放readv所接收的数据或是writev将要发送的数据
size_t iov_len; //接收的长度以及实际写入的长度
}; count参数是vector数组的长度，即有多少块内存数据需要从fd读出或写到fd。 两者调用成功是返回读出/写入fd的字节数，失败返回-1,并设置errno。类似于简化版的recvmsg和sendmsg。 以下简陋的模拟WEB服务器，采用集中写的方式。省略了HTTP请求的接收及解析， 直接将目标文件作为第3个参数传递给服务端程序，客户端telnet到服务端即可获得该文件。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#define BUFFER_SIZE 1024
//定义两种HTTP状态码和状态信息
static const char *status_line[2] = {"200 OK", "500 Internal server error"};
int main(int argc, char **argv)
{
if(argc != 4) {
fprintf(stderr, "Usage: %s ip port filename\n", basename(argv[0]));
return 1;
}
const char *ip = argv[1];
int port = atoi(argv[2]);
const char *file_name = argv[3]; //将目标文件作为程序的第三个参数传入
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
int sock = socket(PF_INET, SOCK_STREAM, 0);
assert(sock >= 0);
printf("create socket success\n");
int reuse = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
fprintf(stderr, "bind address success\n");
ret = listen(sock, 5);
assert(ret != -1);
fprintf(stderr, "listen success\n");
struct sockaddr_in client;
socklen_t client_addrlength = sizeof(client);
fprintf(stderr, "start accept...\n");
int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
if(connfd < 0) {
printf("error: %s\n", strerror(errno));
}
else {
char header_buf[BUFFER_SIZE]; //用于保存HTTP应答的状态行、头部字段和一个空的缓冲区
memset(header_buf, '\0', BUFFER_SIZE);
char *file_buf = NULL; //用于存放目标文件内容的缓存
struct stat file_stat; //用于获取目标文件的属性
bool valid = true; //目标文件是否有效
int len = 0; //记录header_buf当前已使用的字节空间
if(stat(file_name, &file_stat) < 0) { //目标文件不存在
valid = false;
}
else {
if(S_ISDIR(file_stat.st_mode)) { //目标文件是目录
valid = false;
}
else if (file_stat.st_mode & S_IROTH) { //当前用户是否有读权限，相对于目标文件
int fd = open(file_name, O_RDONLY);
file_buf = new char[file_stat.st_size + 1];
memset(file_buf, '\0', file_stat.st_size + 1);
fprintf(stderr, "reading %s file...", file_name);
if (read(fd, file_buf, file_stat.st_size) < 0) {
valid = false;
}
}
else {
valid = false;
}
}
if (valid) { //目标文件有效
ret = snprintf(header_buf, BUFFER_SIZE-1,
"%s %s\r\n",
"HTTP/1.1", status_line[0]);
len += ret;
ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
"content-Length: %ld\r\n",
file_stat.st_size);
len += ret;
ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
"%s", "\r\n");
//将header_buf和file_buf的内容一并写出
struct iovec iv[2];
iv[0].iov_base = header_buf;
iv[0].iov_len = strlen(header_buf);
iv[1].iov_base = file_buf;
iv[1].iov_len = file_stat.st_size;
fprintf(stderr, "read %s success\nsending %s file to client...\n", file_name, file_name);
ret = writev(connfd, iv, 2); //集中写
}
else { //目标文件无效
ret = snprintf(header_buf, BUFFER_SIZE-1,
"%s %s\r\n",
"HTTP/1.1", status_line[1]);
len += ret;
ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
"%s", "\r\n");
fprintf(stderr, "read %s failed\nsending error message to client...\n", file_name);
send(connfd, header_buf, strlen(header_buf), 0);
}
close(connfd);
if (file_buf != NULL) {
delete[] file_buf;
file_buf = NULL;
}
}
close(sock);
return 0;
}
sendfile函数
sendfile在两个文件描术符之间直接传递数据，完全在内核中操作，从而避免了内核缓冲区到用户缓冲区的拷贝，因此效率很高，称为零拷贝。
#include <sys/sendfile.h>
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专为网络传输文件而生。
//用sendfile函数传输文件
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/sendfile.h>
#include <fcntl.h>
int main(int argc, char **argv)
{
if (argc <= 3) {
fprintf(stderr, "Usage: %s ip port filename\n", basename(argv[0]));
return 1;
}
const char *ip = argv[1];
int port = atoi(argv[2]);
const char *file_name = argv[3];
int filefd = open(file_name, O_RDONLY);
assert(filefd > 0);
struct stat stat_buf;
fstat(filefd, &stat_buf);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
int sock = socket(PF_INET, SOCK_STREAM, 0);
assert(sock >= 0);
int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(sock, 5);
assert(ret != -1);
struct sockaddr_in client;
socklen_t client_addrlength = sizeof(client);
int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
if (connfd < 0) {
fprintf(stderr, "errno is: %s\n", strerror(errno));
}
else {
sendfile(connfd, filefd, NULL, stat_buf.st_size);
close(connfd);
}
close(sock);
return 0;
}
splice函数
splice用于在两个文件描述符之间移动数据， 也是零拷贝。
#include <fcntl.h>
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，因此也未涉及用户空间到内核空间的数据拷贝。
tee函数
tee在两个管道文件描述之间复制数据，也是零拷贝操作。
用tee和splice实现从标准输入到终端和文件的程序：
#include <unistd.h> int dup(int file_descriptor); 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。//利用dup模拟实现一个基本的CGI服务器
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <assert.h>
int main(int argc, char **argv)
{
if (argc ！= 3) {
fprintf(stderr, "Usage: %s id port\n", basename(argv[0]));
return 1;
}
const char *ip = argv[1];
int port = atoi(argv[2]);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
int sock = socket(PF_INET, SOCK_STREAM, 0);
assert(sock >= 0);
int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(sock, 5);
assert(ret != -1);
struct sockaddr_in client;
socklen_t client_addrlength = sizeof(client);
int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
if (connfd < 0) {
printf("error: %s\n", strerror(errno));
}
else {
close(STDOUT_FILENO); //关闭标准输出
dup(connfd); //重定向1到connfd，这样服务器的标准输出内容会直接发送到客户端socket，这就是CGI的基本原理
printf("abc. close stdout_fileno test... dup to client\n"); //printf会直接输出会发送到客户端
close(connfd);
}
close(sock);
return 0;
}
分散读readv和集中写writev函数
readv将数据从文件描述符读到分散的内存块中，即分散读。writev将多块分散的内存一并写入文件描述符中，即集中写。#include <sys/uio.h>
ssize_t readv(int fd, const struct iovec *vector, int count);
ssize_t writev(int fd, const struct iovec *vector, int count);fd参数是被操作的文件描述符。vector参数是iovec结构体：#include <sys/uio.h>
struct iovec
{
void *iov_base; //指向一个缓冲区，这个缓冲区是存放readv所接收的数据或是writev将要发送的数据
size_t iov_len; //接收的长度以及实际写入的长度
}; count参数是vector数组的长度，即有多少块内存数据需要从fd读出或写到fd。 两者调用成功是返回读出/写入fd的字节数，失败返回-1,并设置errno。类似于简化版的recvmsg和sendmsg。 以下简陋的模拟WEB服务器，采用集中写的方式。省略了HTTP请求的接收及解析， 直接将目标文件作为第3个参数传递给服务端程序，客户端telnet到服务端即可获得该文件。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <assert.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#define BUFFER_SIZE 1024
//定义两种HTTP状态码和状态信息
static const char *status_line[2] = {"200 OK", "500 Internal server error"};
int main(int argc, char **argv)
{
if(argc != 4) {
fprintf(stderr, "Usage: %s ip port filename\n", basename(argv[0]));
return 1;
}
const char *ip = argv[1];
int port = atoi(argv[2]);
const char *file_name = argv[3]; //将目标文件作为程序的第三个参数传入
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
int sock = socket(PF_INET, SOCK_STREAM, 0);
assert(sock >= 0);
printf("create socket success\n");
int reuse = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
fprintf(stderr, "bind address success\n");
ret = listen(sock, 5);
assert(ret != -1);
fprintf(stderr, "listen success\n");
struct sockaddr_in client;
socklen_t client_addrlength = sizeof(client);
fprintf(stderr, "start accept...\n");
int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
if(connfd < 0) {
printf("error: %s\n", strerror(errno));
}
else {
char header_buf[BUFFER_SIZE]; //用于保存HTTP应答的状态行、头部字段和一个空的缓冲区
memset(header_buf, '\0', BUFFER_SIZE);
char *file_buf = NULL; //用于存放目标文件内容的缓存
struct stat file_stat; //用于获取目标文件的属性
bool valid = true; //目标文件是否有效
int len = 0; //记录header_buf当前已使用的字节空间
if(stat(file_name, &file_stat) < 0) { //目标文件不存在
valid = false;
}
else {
if(S_ISDIR(file_stat.st_mode)) { //目标文件是目录
valid = false;
}
else if (file_stat.st_mode & S_IROTH) { //当前用户是否有读权限，相对于目标文件
int fd = open(file_name, O_RDONLY);
file_buf = new char[file_stat.st_size + 1];
memset(file_buf, '\0', file_stat.st_size + 1);
fprintf(stderr, "reading %s file...", file_name);
if (read(fd, file_buf, file_stat.st_size) < 0) {
valid = false;
}
}
else {
valid = false;
}
}
if (valid) { //目标文件有效
ret = snprintf(header_buf, BUFFER_SIZE-1,
"%s %s\r\n",
"HTTP/1.1", status_line[0]);
len += ret;
ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
"content-Length: %ld\r\n",
file_stat.st_size);
len += ret;
ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
"%s", "\r\n");
//将header_buf和file_buf的内容一并写出
struct iovec iv[2];
iv[0].iov_base = header_buf;
iv[0].iov_len = strlen(header_buf);
iv[1].iov_base = file_buf;
iv[1].iov_len = file_stat.st_size;
fprintf(stderr, "read %s success\nsending %s file to client...\n", file_name, file_name);
ret = writev(connfd, iv, 2); //集中写
}
else { //目标文件无效
ret = snprintf(header_buf, BUFFER_SIZE-1,
"%s %s\r\n",
"HTTP/1.1", status_line[1]);
len += ret;
ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
"%s", "\r\n");
fprintf(stderr, "read %s failed\nsending error message to client...\n", file_name);
send(connfd, header_buf, strlen(header_buf), 0);
}
close(connfd);
if (file_buf != NULL) {
delete[] file_buf;
file_buf = NULL;
}
}
close(sock);
return 0;
}
sendfile函数
sendfile在两个文件描术符之间直接传递数据，完全在内核中操作，从而避免了内核缓冲区到用户缓冲区的拷贝，因此效率很高，称为零拷贝。
#include <sys/sendfile.h>
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专为网络传输文件而生。
//用sendfile函数传输文件
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/sendfile.h>
#include <fcntl.h>
int main(int argc, char **argv)
{
if (argc <= 3) {
fprintf(stderr, "Usage: %s ip port filename\n", basename(argv[0]));
return 1;
}
const char *ip = argv[1];
int port = atoi(argv[2]);
const char *file_name = argv[3];
int filefd = open(file_name, O_RDONLY);
assert(filefd > 0);
struct stat stat_buf;
fstat(filefd, &stat_buf);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
int sock = socket(PF_INET, SOCK_STREAM, 0);
assert(sock >= 0);
int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(sock, 5);
assert(ret != -1);
struct sockaddr_in client;
socklen_t client_addrlength = sizeof(client);
int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
if (connfd < 0) {
fprintf(stderr, "errno is: %s\n", strerror(errno));
}
else {
sendfile(connfd, filefd, NULL, stat_buf.st_size);
close(connfd);
}
close(sock);
return 0;
}
splice函数
splice用于在两个文件描述符之间移动数据， 也是零拷贝。
#include <fcntl.h>
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及其含义
| 错误 | 含义 |
| EBADF | 参数所指文件描述符有错 |
| EINVAL | 目标文件系统不支持splice，或者目标文件以追加方式打开，或者两个文件描述符都不是管道文件描述符，或者某个offset参数被用于不支持随机访问的设备（比如字符设备） |
| ENOMEM | 内存不够 |
| ESPIPE | 参数fd_in（或fd_out）是管道文件描述符，而off_in（或off_out）不为NULL |
//使用splice实现的回显服务器
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
int main(int argc, char **argv)
{
if (argc <= 2) {
printf("usage: %s ip port\n", basename(argv[0]));
return 1;
}
const char *ip = argv[1];
int port = atoi(argv[2]);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
int sock = socket(PF_INET, SOCK_STREAM, 0);
assert(sock >= 0);
int reuse = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
int ret = bind(sock, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(sock, 5);
assert(ret != -1);
struct sockaddr_in client;
socklen_t client_addrlength = sizeof(client);
int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
if (connfd < 0) {
printf("errno is: %s\n", strerror(errno));
}
else {
int pipefd[2];
ret = pipe(pipefd); //创建管道
assert(ret != -1);
//将connfd上的客户端数据定向到管道中
ret = splice(connfd, NULL, pipefd[1], NULL,
32768, SPLICE_F_MORE | SPLICE_F_MOVE);
assert(ret != -1);
//将管道的输出定向到connfd上
ret = splice(pipefd[0], NULL, connfd, NULL,
32768, SPLICE_F_MORE | SPLICE_F_MOVE);
assert(ret != -1);
close(connfd);
}
close(sock);
return 0;
}tee函数
tee在两个管道文件描述之间复制数据，也是零拷贝操作。
#include <fcntl.h> ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);它的参数与splice相同，但fd_in和fd_out都必须是管道文件描述符，调用成功时返回复制的字节数。返回0表示没有复制任务数据。失败时返回-1，并设置errno。
用tee和splice实现从标准输入到终端和文件的程序：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <assert.h>
int main(int argc, char **argv)
{
if (argc != 2) {
fprintf(stderr, "Usage: %s <file>\n", argv[0]);
return 1;
}
uid_t uid = getuid();
uid_t euid = geteuid();
printf("userid: %d, effective userid: %d\n", uid, euid);
int filefd = open(argv[1], O_CREAT | O_WRONLY | O_TRUNC, 0666);
assert(filefd > 0);
int pipefd_stdout[2];
int ret = pipe(pipefd_stdout);
assert(ret != -1);
int pipefd_file[2];
ret = pipe(pipefd_file);
assert(ret != -1);
//将标准输入的内容输出到管道
ret = splice(STDOUT_FILENO, NULL, pipefd_stdout[1], NULL,
32768, SPLICE_F_MORE | SPLICE_F_MOVE);
assert(ret != -1);
//将管道pipefd_stdout的输出复制到管理pipefd_file的输入端
ret = tee(pipefd_stdout[0], pipefd_file[1],
32768, SPLICE_F_NONBLOCK);
assert(ret != -1);
//将管道pipefd_file的输出定向到文件描述符filefd上，写入文件
ret = splice(pipefd_file[0], NULL, filefd, NULL,
32768, SPLICE_F_MORE | SPLICE_F_MOVE);
assert(ret != -1);
//将管道pipefd_stdout的输出定向到标准出， 其内容和写入文件的内容一致
ret = splice(pipefd_stdout[0], NULL, STDOUT_FILENO, NULL,
32768, SPLICE_F_MORE | SPLICE_F_MOVE);
assert(ret != -1);
close(filefd);
close(pipefd_file[0]);
close(pipefd_file[1]);
close(pipefd_stdout[0]);
close(pipefd_stdout[1]);
return 0;
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Linux 高性能服务器编程——高级I/O函数
- Linux 高性能服务器编程——高级I/O函数
- Linux x86_64与i386区别之 —— 内存寻址
- Qt共享库及其调用（Window&Linux&Mac）
- linux上安装mysql
- 如何禁用Easy Install以及linux下安装VMware Tools
- linux配置java环境变量(详细)
- Centos Linux 下FTP配置
- linux中修改dns
- Linux忘记root密码的解决办法(图文)
- rhel、centos好用的yum源
- 如何在windows下和linux下获取文件(如exe文件)的详细信息和属性
- linux coredump调试,ulimit设置
- linux 远程桌面---xmanager
- linux 安装 和 配置java
- 在CENTOS上安装MYSQL服务器
- 详解linux下的串口通讯开发
- centos6.5 gnome 桌面 回收站所在文件夹
- Mysql学习-(1- Ubuntu Linux下安装MySQL)
- crash工具分析linux dump文件