TCP socket select用法分析

网上一篇博主写的select，十分透彻，参考linux下多路复用模型之Select模型
本文主要记录了select一些用法和自己写的一个用select的服务器端例子。

首先，我们来看看select函数的定义和参数的含义：

int select( int nfds, fd_set FAR* readfds,　fd_set * writefds, fd_set * exceptfds,　const struct timeval * timeout)

参数含义：
1. nfds：是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！在Windows中这个参数的值无所谓，可以设置不正确。
2. readfds：（可选）指针，指向一组等待可读性检查的套接口。
3. writefds：（可选）指针，指向一组等待可写性检查的套接口。
4. exceptfds：（可选）指针，指向一组等待错误检查的套接口。
5. timeout：select()最多等待时间，对阻塞操作则为NULL。

返回值：
select()调用返回处于就绪状态并且已经包含在fd_set结构中的描述字总数；如果超时则返回0；否则的话，返回SOCKET_ERROR错误，应用程序可通过WSAGetLastError获取相应错误代码。
1. 当返回为-1时，所有描述符集清0。
2. 当返回为0时，表示超时。
3. 当返回为正数时，表示已经准备好的描述符数。
select（）返回后，在3个描述符集里，依旧是1的位就是准备好的描述符。这也就是为什么，每次用select后都要用FD_ISSET的原因。
select函数实现I/O多路复用，可以用来监视多个描述符，之后我们调用FD_ISSET函数确定具体是哪一个描述符准备好了。
那怎样才算准备好了呢？《unix环境高级编程》中，提到：

1. 若对读集中的一个描述符进行的read操作不会阻塞，则认为此描述符是准备好的。
2. 若对写集中的一个描述符进行的write操作不会阻塞，则认为此描述符是准备好的。
3. 若对异常条件集中的一个描述符有一个未决异常条件，则认为此描述符是准备好的。
4. 对于读、写和异常条件，普通文件的文件描述符总是认为准备好的。

操作select函数，还需要以下几个函数配合。

1. void FD_CLR(int fd, fd_set *set) // 清除set集合中描述符fd
2. int FD_ISSET(int fd, fd_set *set) //判断set集合中描述符fd是否准备好
3. void FD_SET(int fd, fd_set *set) //将描述符fd添加进集合set(其实是将某一位置1)。
4. void FD_ZERO(fd_set *set) //将set集全部清除

接下来看一个服务器端运用select函数的例子。从下面的程序可以看出，服务器端调用函数FD_SET( sockfd, &readfds)把套接字描述符sockfd加入读集合，调用select函数监听了socket套接字是否准备好。当客户端有连接请求时，select会返回一个正数，然后调用FD_ISSET(sockfd,&readfds)判断是哪一个描述符准备好。当然这里只能是socket，因为我们只向读集合添加了一个。接着调用accept接收请求，创建线程去处理客户端的请求。

/*server.c*/

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096
#define MAX_QUE_CONN_NM 5
#define PORT 6000
//#define MAXSOCKFD     10
#define FILE_NAME_MAX 512

void recv_mul_file(int sockfd);
void* pthread_func(void * arg);

int main(int argc,char* argv[])
{
    int sockfd;
    int sin_size = sizeof(struct sockaddr);
    struct sockaddr_in server_sockaddr, client_sockaddr;
    int i = 1;/* 使得重复使用本地地址与套接字进行绑定 */

    /*建立socket连接*/
    if ((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1)
    {
        perror("socket");
        exit(1);
    }
    printf("Socket id = %d\n",sockfd);

    /*设置sockaddr_in 结构体中相关参数*/
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(PORT);
    server_sockaddr.sin_addr.s_addr = INADDR_ANY;
    bzero(&(server_sockaddr.sin_zero), 8);

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));

    /*绑定函数bind*/
    if (bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr))== -1)
    {
        perror("bind");
        exit(1);
    }
    printf("Bind success!\n");

    /*调用listen函数*/
    if (listen(sockfd, MAX_QUE_CONN_NM) == -1)
    {
        perror("listen");
        exit(1);
    }
    printf("Listening....\n");
    recv_mul_file(sockfd);
    close(sockfd);
    return 0;
}

void recv_mul_file(int sockfd)
{
    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET( sockfd, &readfds);

    pthread_t tid;
    struct sockaddr_in client_sockaddr;
    int client_fd, sin_size = sizeof(struct sockaddr);
    int MAXSOCKFD = sockfd;

    while(1)
    {
        if(select(MAXSOCKFD + 1,&readfds,NULL,NULL,NULL) > 0)
        {
            if(FD_ISSET(sockfd,&readfds)>0)
            {
                if ((client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, (socklen_t *)&sin_size)) == -1)
                {
                    perror("accept");
                    exit(1);
                }
                pthread_create(&tid, NULL, pthread_func, &client_fd);
            }
            FD_SET( client_fd, &readfds);
            MAXSOCKFD = (MAXSOCKFD > client_fd? MAXSOCKFD:client_fd);
        }
    }
}

void* pthread_func(void * arg)
{
    //recv file imformation
    int client_fd;

    char buff[BUFFER_SIZE];
    char filename[FILE_NAME_MAX];
    int count;
    bzero(buff,BUFFER_SIZE);
    client_fd = *(int *)arg;
    printf("recv from client,client_fd = %d\n",client_fd);
    count=recv(client_fd,buff,BUFFER_SIZE,0);   //把接受到到字符放在长度为BUFFER_SIZE的buff地址上，接收成功返回接收到到字节数目
    if(count<0)
    {
        perror("recv");
        exit(1);
    }
    strncpy(filename,buff,strlen(buff)>FILE_NAME_MAX?FILE_NAME_MAX:strlen(buff));//把filename地址上的内容复制到地址buff上，第三个参数表明复制多少个字节

    printf("Preparing recv file : %s\n",filename );

    //recv file
    FILE *fd=fopen(filename,"wb+"); //告诉函数库，打开的是一个二进制到可写文件，地址在指针filename
    if(NULL==fd)
    {
        perror("open");
        exit(1);
    }
    bzero(buff,BUFFER_SIZE); //缓冲区清0

    int length=0;
    while(length=recv(client_fd,buff,BUFFER_SIZE,0)) //这里是分包接收，每次接收4096个字节
    {
        if(length<0)
        {
            perror("recv");
            exit(1);
        }
        int writelen=fwrite(buff,sizeof(char),length,fd);//把从buff接收到的字符写入（二进制）文件中
        if(writelen<length)
        {
            perror("write");
            exit(1);
        }
        bzero(buff,BUFFER_SIZE); //每次写完缓冲清0，准备下一次的数据的接收
    }
    printf("Receieved file:%s finished!\n",filename );
    fclose(fd);
    close(client_fd);
    return 0;
}