• Linux 高性能server编程——高级I/O函数



    重定向dup和dup2函数

    #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模拟实现一个主要的CGIserver
    #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
    ", 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
    ", strerror(errno));
    	}
    	else {
    		close(STDOUT_FILENO); //关闭标准输出
    		dup(connfd);          //重定向1到connfd,这样server的标准输出内容会直接发送到客户端socket。这就是CGI的基本原理
    		
    		printf("abc. close stdout_fileno test... dup to client
    "); //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。

           以下简陋的模拟WEBserver,採用集中写的方式。

    省略了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
    ", 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
    ");
    	
    	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
    ");
    	
    	ret = listen(sock, 5);
    	assert(ret != -1);
    	fprintf(stderr, "listen success
    ");
    	
    	struct sockaddr_in client;
    	socklen_t client_addrlength = sizeof(client);
    	
    	fprintf(stderr, "start accept...
    ");
    	
    	int connfd = accept(sock, (struct sockaddr*)&client, &client_addrlength);
    	if(connfd < 0) {
    		printf("error: %s
    ", strerror(errno));
    	}
    	else {
    		char header_buf[BUFFER_SIZE];             //用于保存HTTP应答的状态行、头部字段和一个空的缓冲区
    		memset(header_buf, '', 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, '', 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
    ",
    								"HTTP/1.1", status_line[0]);
    								
    				len += ret;
    				ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
    								"content-Length: %ld
    ",
    								file_stat.st_size);
    								
    				len += ret;
    				ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
    								"%s", "
    ");
    				
                                    //将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
    sending %s file to client...
    ", file_name, file_name);
    				
    				ret = writev(connfd, iv, 2);   //集中写
    				
    		}
    		else {     //目标文件无效
    			ret = snprintf(header_buf, BUFFER_SIZE-1,
    							"%s %s
    ",
    							"HTTP/1.1", status_line[1]);
    			
    			len += ret;
    			ret = snprintf(header_buf+len, BUFFER_SIZE-1-len,
    							"%s", "
    ");
    			
    			fprintf(stderr, "read %s failed
    sending error message to client...
    ", 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
    ", 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
    ", 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将客户端的内容读入到管道中, 再从管道中读出到客户端,从而实现高效简单的回显服务。整个过程未运行recv/send。因此也未涉及用户空间到内核空间的数据拷贝。


    //使用splice实现的回显server
    #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
    ", 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
    ", 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>
    ", argv[0]);
    		return 1;
    	}
    	
    	uid_t uid = getuid();
    	uid_t euid = geteuid();
    	printf("userid: %d, effective userid: %d
    ", 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;
    }

  • 相关阅读:
    android一些小的问题
    Android知识细节
    在Windows登录Linux的一些工具
    Android studio字体调整
    在Android Studio中自动添加import以及快捷键
    设计模式(十三) 职责链(chain of responsibility)
    设计模式(十二):bridge模式
    linux 进程通信 管道
    信号量sem
    一道求递增数的题目
  • 原文地址:https://www.cnblogs.com/lcchuguo/p/5137605.html
Copyright © 2020-2023  润新知