I/O复用 select模型使用实例

在这两篇文章基础上
http://blog.csdn.net/qq_26437925/article/details/51898120

http://blog.csdn.net/qq_26437925/article/details/51900405

参考《unix网络编程：卷1》

我们看到TCP同时两个输入：标准输入 和 TCP套接字。
当客户端阻塞于标准输入时（即fget调用，一直等待用户输入数据），我们突然杀死服务端的进程。
服务端TCP会给客户端发送一个FIN，客户端响应一个ACK, 但是客户端进程正阻塞于标准输入读入的过程，客户端看不到TCP套接字的这个EOF,直到下一次从套接字读时为止（这时才直到服务端已经关闭了，这可能过了很长时间）。

---

I/O复用概念引出(由上面的问题，《unix网络编程：卷1》原语句段如下：)

What we need is the capability to tell the kernel that we want to be notified if one or more I/O conditions are ready (i.e.,input is ready to read,or the descripter is capbale of taking more output).This capability is called I/O multiplexing(IO复用).

select , poll , pselect , epoll等函数可以实现I/O复用

---

下面是select例子

当服务端进程被kill时，客户端进程会立刻接收到这个tcp套接字信息。

---

server.c

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <arpa/inet.h>
#include <signal.h>

#define MYPORT  9877
#define QUEUE   20
#define BUFFER_SIZE 1024

void sig_child(int signo)
{
    pid_t pid;
    int stat;

    while( (pid = waitpid(-1, &stat, WNOHANG)) > 0)
        printf("child %d terminated\n", pid);
    return;
}

/* write n bytes to a descrpiter */
ssize_t Write(int fd,const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nwritten;
    const char *ptr;
    ptr = vptr;
    nleft = n;
    while (nleft > 0) 
    {
        if( (nwritten = write(fd, ptr, nleft)) <= 0)
        {
            if( nwritten < 0)
                nwritten = 0;
            else
                return -1; // error
        }
        nleft = -nwritten;
        ptr += nwritten;
    }
    return n;   
}

void str_echo(int sockfd)
{
    ssize_t n;
    char buf[BUFFER_SIZE];

    while( (n = read(sockfd, buf, BUFFER_SIZE)) > 0 )
        Write(sockfd, buf, n);
    if(n < 0)
        perror("read error");
}

int main()
{
    // 定义sockfd
    int server_sockfd = socket(AF_INET,SOCK_STREAM, 0);

    // 定义sockaddr_in
    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;//协议族
    server_sockaddr.sin_port = htons(MYPORT); //端口
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY); //地址

    // bind，成功返回0，出错返回-1
    if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,sizeof(server_sockaddr))==-1)
    {
        perror("bind");
        exit(1);
    }

    // listen，成功返回0，出错返回-1
    if(listen(server_sockfd,QUEUE) == -1)
    {
        perror("listen");
        exit(1);
    }

    signal(SIGCHLD, sig_child);// 信号处理

    while(1){
        ///客户端套接字
        struct sockaddr_in client_addr;
        socklen_t length = sizeof(client_addr);

        ///成功返回非负描述字，出错返回-1
        int conn = accept(server_sockfd, (struct sockaddr*)&client_addr, &length);
        if(conn<0)
        {
            perror("connect");
            exit(1);
        }

        char buff[BUFFER_SIZE];
        // 显示连接的客户端
        printf("connection from %s, port %d\n", 
            inet_ntop(AF_INET, &client_addr.sin_addr, buff, sizeof(buff)),
            ntohs(client_addr.sin_port));

        pid_t child_pid ;

        if( (child_pid = fork()) == 0 ) // 为客户端fork子进程
        {
            close(server_sockfd);
            str_echo(conn);     
            exit(0);
        }
        close(conn);
    }

    return 0;
}

client.c

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <sys/time.h>

#define MYPORT  9877
#define BUFFER_SIZE 1024

int max(int a, int b)
{
    return a>b?a:b;
}

/* write n bytes to a descrpiter */
ssize_t Writen(int fd,const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nwritten;
    const char *ptr;
    ptr = vptr;
    nleft = n;
    while (nleft > 0) 
    {
        if( (nwritten = write(fd, ptr, nleft)) <= 0)
        {
            if( nwritten < 0)
                nwritten = 0;
            else
                return -1; // error
        }
        nleft = -nwritten;
        ptr += nwritten;
    }
    return n;   
}

ssize_t readline(int fd, void *vptr, size_t maxlen)
{
    ssize_t n, rc;
    char c, *ptr;
    ptr = vptr;
    for(n = 1 ;n < maxlen; n++)
    {
        if( (rc = read(fd, &c, 1)) == 1)
        {
            *ptr++ = c;
            if(c == '\n')
                break;
        }else if( rc == 0) {
            *ptr = 0;
            return (n-1);
        }else{
            return -1;
        }
    }
    *ptr = 0;
    return n;
}

void str_cli(FILE *fp, int sockfd)
{
    char sendline[BUFFER_SIZE], recvline[BUFFER_SIZE];
    int maxfdpl;
    fd_set rset; // 描述符集
    FD_ZERO(&rset); //清除文件描述符集fdset中的所有位(既把所有位都设置为0)
    for(; ;){
        FD_SET(fileno(fp), &rset);//取出文件描述符，并打开相应在文件描述位
        FD_SET(sockfd, &rset);
        maxfdpl = max(fileno(fp), sockfd) + 1; //等待的描述集
        // select 如果有描述符 则返回起数目，若超时，返回0 ,出错返回-1
        select(maxfdpl, &rset, NULL, NULL, NULL);
        if(FD_ISSET(sockfd, &rset)){ //判断sockfd是否在描述集中
            if(readline(sockfd, recvline, BUFFER_SIZE) == 0)
            {
                perror("server terminated");
                exit(0);
            }
            fputs(recvline,stdout); 
        }
        if(FD_ISSET(fileno(fp), &rset)){ // 判断fp是否在描述集中
            if( fgets(sendline, BUFFER_SIZE , fp) == NULL )
                return; /* all done */
            Writen(sockfd, sendline, strlen(sendline)); 
        }
    }
}


int main()
{
    ///定义sockfd
    int sock_cli = socket(AF_INET,SOCK_STREAM, 0);

    ///定义sockaddr_in
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(MYPORT);  ///服务器端口
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  ///服务器ip

    ///连接服务器，成功返回0，错误返回-1
    if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        perror("connect");
        exit(1);
    }

    str_cli(stdin,sock_cli); //回射客户端的程序
    exit(0);
}

Makefile

.PHONY: build clean

CC=gcc
HEADERS=-I.
DEBUG=-g -ggdb  
WALL=-Wall -W  
CFLAGS=$(WALL) $(DEBUG)  
L_CC=$(CC) $(CFLAGS) $(HEADERS)     

build:server client

server:server.c
    $(L_CC) $< -o $@

client:client.c
    $(L_CC) $< -o $@

clean:
    @-if [ -f server ]; then rm server; fi
    @-if [ -f client ]; then rm client; fi

运行说明

$make
# 运行服务端
$./server
#运行客户端，服务端会fork子进行进行处理
$./client

突然杀死子进程, 客户端select检测到sockfd不可达，知道服务器错误了，然后自己关闭，服务端对应采用信号机制知道用户终止了。

$ps -aux
$kill -9  child_pid 

参考学习
http://www.cnblogs.com/Anker/p/3265058.html

文件I/O select例子

#include <stdio.h>
#include <stdlib.h>
#include <sys/select.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define MAXNUM      100
#define OPEN_DEV    "/dev/input/mice"

int max2(int a, int b)
{
    return a>b?a:b;
}


int main(void)
{
    fd_set rfds;
    struct timeval tv;
    int retval, fd;
    char buf[MAXNUM];

    fd = open(OPEN_DEV, O_RDONLY);//打开鼠标设备
    while (1) {
        FD_ZERO(&rfds);
        FD_SET(0, &rfds);//输入
        FD_SET(fd, &rfds);//鼠标设备
        tv.tv_sec = 5;
        tv.tv_usec = 0;

        retval = select(max2(0,fd)+1, &rfds, NULL, NULL, &tv);
        if (retval < 0) // 返回-1 出错
            printf ("error\n");
        if (retval == 0) // 返回0 超时
            printf ("No data within 5 seconds\n");
        if (retval > 0) { // 大于0 为描述符的数目
            if (FD_ISSET(0, &rfds)) { //判断输入描述符是否可用
                printf ("Data is available from keyboard now\n");
                read(0, buf, MAXNUM);
            }
            if (FD_ISSET(fd, &rfds)) { //判断鼠标设备描述符是否可用
                printf ("Data is available from mouse now\n");
                read(fd, buf, MAXNUM);
            }
        }
    }
    return 0;
}