linux网络socket编程select

       #include <stdio.h>
       #include <stdlib.h>
       #include <sys/time.h>
       #include <sys/types.h>
       #include <unistd.h>

       int main(void)
       {
           fd_set rfds;
           struct timeval tv;
           int retval;

           /* Watch stdin (fd 0) to see when it has input. */
           FD_ZERO(&rfds);
           FD_SET(0, &rfds);

           /* Wait up to five seconds. */
           tv.tv_sec = 5;
           tv.tv_usec = 0;

           retval = select(1, &rfds, NULL, NULL, &tv);
           /* Don't rely on the value of tv now! */
           if (retval == -1)
               perror("select()");
           else if (retval)
               printf("Data is available now.\n");
               /* FD_ISSET(0, &rfds) will be true. */
           else
               printf("No data within five seconds.\n");

           exit(EXIT_SUCCESS);
       }

客户端

#define PORT    4321
#define BUFFER_SIZE 1024

int main(int argc, char *argv[])
{
    int sockfd, sendbytes， res;
    char buf[BUFFER_SIZE];
    struct hostent *host;
    struct sockaddr_in serv_addr;
    
    /*地址解析函数*/
    if ((host = gethostbyname(argv[1])) == NULL)
    memset(buf, 0, sizeof(buf));
    sprintf(buf, "%s", argv[2]);

    /*创建socket*/
    if ((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
    
    /*设置sockaddr_in 结构体中相关参数*/
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
    bzero(&(serv_addr.sin_zero), 8);
    
    /*调用connect函数主动发起对服务器端的连接*/
    res = connect(sockfd,(struct sockaddr *)&serv_addr, sizeof(struct sockaddr));
  
    //客户端将控制台输入的信息发送给服务器端，服务器原样返回信息,阻塞
    while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
    {
        send(sockfd, sendbuf, strlen(sendbuf),0); ///发送
        recv(sockfd, recvbuf, sizeof(recvbuf),0); ///接收
    }
    
    close(sockfd);
    exit(0);
}

服务端

#define PORT                4321
#define MAX_QUE_CONN_NM            5
#define MAX_SOCK_FD            10
#define BUFFER_SIZE            1024

int main()
{
    struct sockaddr_in server_sockaddr, client_sockaddr;
    int sin_size, count;
    fd_set inset, tmp_inset;
    int sockfd, client_fd, fd;
    char buf[BUFFER_SIZE];
    
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
  
    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);
    int i = 1;/* 使得重复使用本地地址与套接字进行绑定 */
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
    if (bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr)) == -1)
    
    if(listen(sockfd, MAX_QUE_CONN_NM) == -1)
    
    /*将调用socket函数的描述符作为文件描述符*/
    FD_ZERO(&inset);
    FD_SET(sockfd, &inset);
 
    while(1)
    {
        tmp_inset = inset;
        sin_size=sizeof(struct sockaddr_in);
        memset(buf, 0, sizeof(buf));     
        /*调用select函数--阻塞*/
        if (!(select(MAX_SOCK_FD, &tmp_inset, NULL, NULL, NULL) > 0))
       
        for (fd = 0; fd < MAX_SOCK_FD; fd++)
        {
            if (FD_ISSET(fd, &tmp_inset) > 0) 
            {       
                if (fd == sockfd)
                { /* 服务端接收客户端的连接请求 */
                    if ((client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &sin_size))== -1)              
                    FD_SET(client_fd, &inset); 
                }
                else /* 处理从客户端发来的消息 */
                {
                    if ((count = recv(fd, buf, BUFFER_SIZE, 0)) > 0)
                    {
                        send(fd, buf, count, 0);
                    }
                    else        
                    {
                        close(fd);
                        FD_CLR(fd, &inset);                     
                    }                        
                }        
            } /* end of if FD_ISSET*/ 
        } /* end of for fd*/
    } /* end if while while*/
    
    close(sockfd);
    exit(0);
}

 

I/O模型

 总的来说，I/O 处理的模型有5种。 
·  阻塞I/O模型：在这种模型下，若所调用的I/O 函数没有完成相关的功能就会使进程挂起，直到相关数据到才会出错返回。如常见对管道设备、终端设备和网络设备进行读写时经常会出现这种情况。 
·  非阻塞模型：在这种模型下，当请求的I/O 操作不能完成时，则不让进程睡眠，而且返回一个错误。非阻塞I/O使用户可以调用不会永远阻塞的I/O 操作，如open、write
和read。如果该操作不能完成，则会立即出错返回，且表示该I/O 如果该操作继续执行就会阻塞。
·  I/O多路转接模型：在这种模型下，如果请求的I/O 操作阻塞，且它不是真正阻塞I/O，而是让其中的一个函数等待，在这期间，I/O 还能进行其他操作。如本节要介绍的select函数和poll 函数，就是属于这种模型。 
·  信号驱动I/O 模型：在这种模型下，通过安装一个信号处理程序，系统可以自动捕获特定信号的到来，从而启动I/O。这是由内核通知用户何时可以启动一个I/O 操作决定的。 
·  异步I/O模型：在这种模型下，当一个描述符已准备好，可以启动I/O 时，进程会通知内核。现在，并不是所有的系统都支持这种模型。 

可以看到，select的I/O 多路转接模型是处理I/O 复用的一个高效的方法。它可以具体设置每一个所关心的文件描述符的条件、希望等待的时间等，从select函数返回时，内核会通知用户已准备好的文件描述符的数量、已准备好的条件等。通过使用select返回值，就可以调用相应的I/O 处理函数了。	

 

函数原型

#include <sys/select.h> int select(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, fd_set *restrict errorfds,

struct timeval *timeout);

(1)参数nfds：指定待测试描述字（就是描述符）的个数（不是最大值，概念上一定要区分），因为描述符是从0开始的，所以他的值就是待测试的最大描述符加1（多一个0）。
(2)参数readfds、writefds、errorfds：3个参数都是fd_set类型。这3个参数在函数调用地不同时段有两种用途：
(2.1)作为参数传入：我们把关心的描述符按照关心事件的事件类型分别放入其中。怎么放？见下。
(2.2)作为函数返回时的返回值：这3个参数装载这我们关心并且I/O条件就绪的描述符，未就绪的描述被清楚了。所以每次调用select时都要重新设置这三个参数，这非常重要。
(3)参数timeout：select中地类型，超时间类型分别：

struct timespec{
__time_t tv_sec;  /*seconds 秒*/
long int tv_nsec; /*nanoseconds 纳秒*/
} 

struct timeval {
__kernel_time_t         tv_sec;         /* seconds */
__kernel_suseconds_t    tv_usec;        /* microseconds */
};

(4)参数sigmask：信号屏蔽掩码。


相关API

 
(1)描述符fd和描述符集合fdset操作宏：
void FD_CLR(int fd, fd_set *fdset);//congfdset删除fd。
int FD_ISSET(int fd, fd_set *fdset);//测试fd是否在fdset当中
void FD_SET(int fd, fd_set *fdset);//向fdset添加fd
void FD_ZERO(fd_set *fdset);//清零，类似bzero。
(2)select的FD_SETSIZE限制。
现在的linux所能打开的描述符个数，只受内存和管理性的限制。但由于在select函数设计之初，select的内部实现参考了FD_SETSIZE,就是select最多能处理的描述符个数是FD_SETSIZE个，一般为1024。
#define __FD_SETSIZE 1024