《TCP IP网络编程》第十二章 I/O复用

最新推荐文章于 2023-07-14 20:18:26 发布

ScriptGirl

最新推荐文章于 2023-07-14 20:18:26 发布

阅读量266

点赞数

分类专栏： Linux网络编程文章标签：网络 linux socket I/O复用

本文链接：https://blog.csdn.net/qq_30885821/article/details/107284980

版权

Linux网络编程专栏收录该内容

17 篇文章 5 订阅

订阅专栏

第十二章 I/O复用

使用select函数：

#include<sys/select.h>
#include<time.h>

int select(int maxfd, fd_set* readset, fd_set* writeset, fd_set* exceptset, const struct timeval* timeout);
		maxfd		监视对象文件描述符数量
		readset		将所有关注“是否存在待读取数据”的文件描述符注册到fd_set型变量，并传递其地址值
		writeset	将所有关注“是否可传输无阻塞数据”的文件描述符注册到fd_set型变量，并传递其地址值
		exceptset	将所有关注“是否发生异常”的文件描述符注册到fd_set型变量，并传递其地址值
		timeout		调用select函数后，为防止陷入无线阻塞的状态，传递超时信息
		返回值		发生错误返回-1，超时返回0。因发生关注的事件返回时，返回大于0的值，该值是发生事件的文件描述符数

select函数调用示例：

#include<stdio.h>
#include<unistd.h>
#include<sys/time.h>
#include<sys/select.h>
#define BUF_SIZE 30

int main(int argc, char * argv[]){
        fd_set reads, temps;
        int result, str_len;
        char buf[BUF_SIZE];
        struct timeval timeout;
        FD_ZERO(&reads);
        FD_SET(0,&reads);//0 is standard input

        while(1){
                temps = reads;
                timeout.tv_sec = 5;
                timeout.tv_usec = 0;
                result = select(1, &temps, 0, 0, &timeout);
                if(result == -1){
                        puts("select() error!");
                        break;
                }else if(result == 0){
                        puts("Time-out!");
                }else{
                        if(FD_ISSET(0,&temps)){
                                str_len = read(0, buf, BUF_SIZE);
                                buf[str_len] = 0;
                                printf("message from console:%s",buf);
                        }
                }
        }
        return 0;
}

运行结果：

[root@VM_0_10_centos IO]# gcc select.c -o select
[root@VM_0_10_centos IO]# ./select
HITime-out!
HI
message from console:HIHI
hi
message from console:hi
ok
message from console:ok
nihaoa 
message from console:nihaoa 
Time-out!
Time-out!
hehehe
message from console:hehehe
Time-out!

基于I/O复用的回声服务器：
echo_selectserv.c :

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<sys/time.h>
#include<sys/select.h>

#define BUF_SIZE 100
void error_handling(char * buf);

int main(int argc,char* argv[]){
        int serv_sock, clnt_sock;
        struct sockaddr_in serv_adr, clnt_adr;
        struct timeval timeout;
        fd_set reads, cpy_reads;

        socklen_t adr_sz;
        int fd_max, str_len, fd_num, i;
        char buf[BUF_SIZE];
        if(argc != 2){
                printf("Usage:%s <port>\n",argv[0]);
                exit(1);
        }

        serv_sock = socket(PF_INET, SOCK_STREAM, 0);
        memset(&serv_adr, 0, sizeof(serv_adr));
        serv_adr.sin_family = AF_INET;
        serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
        serv_adr.sin_port = htons(atoi(argv[1]));

        if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1){
                error_handling("bind() error");
        }

        if(listen(serv_sock, 5) == -1){
                error_handling("listen() error");
        }

        FD_ZERO(&reads);
        FD_SET(serv_sock, &reads);
        fd_max = serv_sock;

        while(1){
                cpy_reads = reads;
                timeout.tv_sec = 5;
                timeout.tv_usec = 5000;

                if((fd_num = select(fd_max+1, &cpy_reads, 0, 0, &timeout)) == -1){
                        break;
                }
                if(fd_num == 0){
                        continue;
                }
                for(i=0;i<fd_max+1;++i){
                        if(FD_ISSET(i, &cpy_reads)){
                                if(i == serv_sock){
                                        adr_sz = sizeof(clnt_adr);
                                        clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
                                        FD_SET(clnt_sock, &reads);
                                        if(fd_max < clnt_sock){
                                                fd_max = clnt_sock;
                                        }
                                        printf("connected client: %d\n",clnt_sock);
                                }else{
                                        str_len = read(i, buf, BUF_SIZE);
                                        if(str_len == 0){
                                                FD_CLR(i, &reads);
                                                close(i);
                                                printf("closed client: %d\n",i);
                                        }else{
                                                write(i, buf, str_len); //echo!
                                        }
                                }
                        }
                }
        }
        close(serv_sock);
        return 0;
}

void error_handling(char * buf){
        fputs(buf, stderr);
        fputc('\n', stderr);
        exit(1);
}