select

select用于探测多个句柄状态的变化

  #include <sys/select.h>
  #include <sys/time.h>
  #include <sys/types.h>
  #include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);

fd_set 类型可以简单的理解为按 bit 位标记句柄的队列。
nfds句柄的最大数+1，
readfds关心读事件文件描述符集，
writefds关心写事件文件描述符集，
exceptfds关系异常事件文件描述符集，
timeout阻塞时间，它可以使select处于三种状态：
第一，若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；
第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；
第三，timeout的值大于0，这就是等待的超时时间，即select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。
select返回值：负值，select错误。
0值，时间超时，没有事件就绪
正值，某些文件可读，可写，异常

void FD_CLR(int fd, fd_set *set);//将set中第fd位置为0
int  FD_ISSET(int fd, fd_set *set);//检测fd位是否被标记
void FD_SET(int fd, fd_set *set);//在set中将第fd位置为1
void FD_ZERO(fd_set *set);//将set全部置零

在某一事件就绪时，用FD_SET将该位标记。
select在输入输出时都必须检测事件是否就绪。如果输⼊的readfds 标记了 16 号句柄，则 select() 将检测 16 号句柄是否可读。在 select()返回后，可以通过检查 readfds 有否标记 16 号句柄，来判断该“可读”事件是否发⽣。

server.c

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

#define MYPORT 1234 //连接时使用的端口

#define MAXCLINE 5 //连接队列中的个数

#define BUF_SIZE 200

int fd[MAXCLINE]; //连接的fd

int conn_amount; //当前的连接数


void showclient()
{
      int i;
      printf("client amount:%d\n",conn_amount);
      for(i=0;i<MAXCLINE;i++)
      {
          printf("[%d]:%d ",i,fd[i]);
      }
      printf("\n\n");
}


int main(void)
{
    int sock_fd,new_fd; //监听套接字 连接套接字
    struct sockaddr_in server_addr; // 服务器的地址信息
    struct sockaddr_in client_addr; //客户端的地址信息
    socklen_t sin_size;
    int yes = 1;
    char buf[BUF_SIZE];
    int ret;
    int i;  //建立sock_fd套接字
    if((sock_fd = socket(AF_INET,SOCK_STREAM,0))==-1)
    {
        perror("setsockopt");
        exit(1);
    }
//设置套接口的选项 SO_REUSEADDR 允许在同一个端口启动服务器的多个实例
// setsockopt的第二个参数SOL SOCKET 指定系统中，解释选项的级别 普通套接字
    if(setsockopt(sock_fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int))==-1)
    {
        perror("setsockopt error \n");
        exit(1);
    }
    server_addr.sin_family = AF_INET; //主机字节序
    server_addr.sin_port = htons(MYPORT);
    server_addr.sin_addr.s_addr = INADDR_ANY;//通配IP
    memset(server_addr.sin_zero,'\0',sizeof(server_addr.sin_zero));
    if(bind(sock_fd,(struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)
    {
        perror("bind error!\n");
        exit(1);
    }
    if(listen(sock_fd,MAXCLINE)==-1)
    {
        perror("listen error!\n");
        exit(1);
    }
    printf("listen port %d\n",MYPORT);
    fd_set fdsr; //文件描述符集的定
    int maxsock;
    struct timeval tv;
    conn_amount =0;
    sin_size = sizeof(client_addr);
    maxsock = sock_fd; 
    while(1)
    {
        //初始化文件描述符集合
        FD_ZERO(&fdsr); //清除描述符集
        FD_SET(sock_fd,&fdsr); //把sock_fd加入描述符集
        //超时的设定
        tv.tv_sec = 30;
        tv.tv_usec =0;
        //添加活动的连接
        for(i=0;i<MAXCLINE;i++) 
        {
            if(fd[i]!=0)
            {
                FD_SET(fd[i],&fdsr);
            }
        }
        //如果文件描述符中有连接请求 会做相应的处理，实现I/O的复用 多用户的连接通讯
        ret = select(maxsock +1,&fdsr,NULL,NULL,&tv);
        if(ret <0) //没有找到有效的连接 失败
        {
            perror("select error!\n");
            break;
        }
        else if(ret ==0)// 指定的时间到，
        {
            printf("timeout \n");
            continue;
        }
        //循环判断有效的连接是否有数据到达
        for(i=0;i<MAXCLINE;i++)
        {
            if(FD_ISSET(fd[i],&fdsr))
            {
                ret = recv(fd[i],buf,sizeof(buf),0);
                if(ret <=0) //客户端连接关闭，清除文件描述符集中的相应的位i
                {
                    printf("client[%d] close\n",i);
                    close(fd[i]);
                    FD_CLR(fd[i],&fdsr);
                    fd[i]=0;
                    conn_amount--;
                }
                //否则有相应的数据发送过来 ，进行相应的处理
                else
                {
                    if(ret <BUF_SIZE)
                        memset(&buf[ret],'\0',1);
                    printf("client[%d] send:%s\n",i,buf);
                }
            }
        }
        if(FD_ISSET(sock_fd,&fdsr))
        {
            new_fd = accept(sock_fd,(struct sockaddr *)&client_addr,&sin_size);
            if(new_fd <=0)
            {
                perror("accept error\n");
                continue;
            }
            //添加新的fd 到数组中 判断有效的连接数是否小于最大的连接数，如果小于的话，就把新的连接套接字加入集合
            if(conn_amount <MAXCLINE)
            {
                for(i=0;i< MAXCLINE;i++)
                {
                    if(fd[i]==0)  
                    {
                        fd[i] = new_fd;
                        break;
                    }
                }
                conn_amount++;
                printf("new connection client[%d]%s:%d\n",conn_amount,inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
                if(new_fd > maxsock)
                {
                    maxsock = new_fd;
                }
            }

            else
            {
                printf("max connections arrive ,exit\n");

                send(new_fd,"bye",4,0);
                      close(new_fd);
                      continue;
            }
        }
        showclient();
    }
    for(i=0;i<MAXCLINE;i++)
    {
        if(fd[i]!=0)
        {
            close(fd[i]);
        }
    }
    exit(0);
} 

client.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>

#define MAXDATASIZE 100
#define SERVPORT 1234
#define MAXLINE 1024
int main(int argc,char *argv[])
{
      int sockfd,sendbytes;
      char send[MAXLINE];
      char buf[MAXDATASIZE];
      struct hostent *host;
      struct sockaddr_in serv_addr;
      if(argc <2)
      {
          fprintf(stderr,"Please enter the server's hostname\n");
          exit(1);
      }

      if((host = gethostbyname(argv[1])) == NULL)
      {
          perror("gethostbyname");
          exit(1);
      }
      if((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
      {
          perror("socket error \n");
          exit(1);
      }
      serv_addr.sin_family = AF_INET;
      serv_addr.sin_port = htons(SERVPORT);
      serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
      bzero(&(serv_addr.sin_zero),8);
      if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(struct sockaddr)) ==-1)
      {
          perror("connect \n");
          exit(1);
      }
      while(fgets(send,1024,stdin)!=NULL)
      {
          if((sendbytes = write(sockfd,send,100)) ==-1)
          {
              perror("send error \n");
              exit(1);
          }
      }
      close(sockfd);
}