Select模式和超时

      fd_set rset;
         FD_ZERO(&rset);
 
         int nready;
         int maxfd;
         int fd_stdin = fileno(stdin);
         if(fd_stdin > sock)
         {
                 maxfd = fd_stdin;
         }
         else
         {
                 maxfd = sock;
         }
 
         char sendbuf[] = {  };
         char recvbuf[] = {  };
         while()
         {
                 FD_SET(fd_stdin,&rset);
                 FD_SET(sock,&rset);
                 nready = select(maxfd+,&rset,NULL,NULL,NULL);
                 if(nready == -)
                         ERR_EXIT("select");
                 if(nready == )
                         continue;
 
                 if(FD_ISSET(sock,&rset))
                 {
 
                         int ret = readline(sock,recvbuf,sizeof(sendbuf));
                         if(ret == -)
                                 ERR_EXIT("readn");
                         else if(ret ==  )
                         {
                                 printf("server close");
                                 break;
                         }
 
                         fputs(recvbuf,stdout);
                         memset(sendbuf,, sizeof(sendbuf));
                         memset(recvbuf,, sizeof(recvbuf));
                 }
 
                 if(FD_ISSET(fd_stdin,&rset))
                 {
                         if(fgets(sendbuf,sizeof(sendbuf),stdin) == NULL)
                                 break;
                         writen(sock,sendbuf,strlen(sendbuf));
                 }
         }
         close(sock);

• void FD_CLR(int fd,fd_set *set);
• int FD_ISSET(int fd,fd_set *set);
• void FD_SET(int fd,fd_set *set);
• void FD_ZERO(fd_set *set);
• select的超时
  • 　　

     //读超时
     int read_timeout(int fd,unsigned int wait_seconds)
     {
         int ret = ;
         if(wait_seconds > )
         {
             fd_set read_fdset;
             struct timeval timeout;
     
             FD_ZERO(&read_fdset);
             FD_SET(fd,&read_fdset);
     
             timeout.tv_sec = wait_seconds;
             timeout.tv_usec = ;
             do
             {
                 ret = select(fd+,&read_fdset,NULL,NULL,&timeout);
             }while(ret <  && errno == EINTR)
     
             if(ret == )
             {
                 ret = -;
                 errno = ETIMEDOUT;
             }
             else if(ret == )
                 ret = ;
         }
         return ret;
     }
     
     //接收超时
     int accept_timeout(int fd,struct sockaddr_in *addr,unsigned int wait_seconds)
     {
         int ret;
         socklen_t addrlen = sizeof(struct sockaddr_in);
     
         if(wait_seconds > )
         {
             fd_set accept_fdset;
             struct timeval timeout;
             FD_ZERO(&accept_fdset);
             FD_SET(fd,&accept_fdset);
             timeout.tv_sec = wait_seconds;
             timeout.tv_usec = ;
             do
             {
                 ret = select(fd+,&accept_fdset,NULL,NULL,&timeout);
             }while(ret <  && errno == EINTR)
     
             if(ret == -)
                 return -;
             else if(ret == )
             {
                 errno = ETIMEDOUT;
                 return -;
             }
         }
         if(addr != NULL)
             ret = accept(fd,(struct sockaddr*)addr,&addrlen);
         else
             ret = accept(fd,NULL,NULL);
         if(ret == -)
             ERR_EXIT("accept");
         return ret;
     }
     
     void activate_nonblock(int fd)
     {
         int ret;
         int flags = fcntl(fd,F_GETFL);
         if(flags == -)
             ERR_EXIT("fcntl");
         flags |= O_NONBLOCK;
         ret = fcntl(fd,F_SETFL,flags);
         if(ret == -)
             ERR_EXIT("fcntl");
     }
     
     void deactivate_nonblock(int fd)
     {
         int ret;
         int flags = fcntl(fd,F_GETFL);
         if(flags == -)
             ERR_EXIT("fcntl");
         flags &~ O_NONBLOCK;
         ret = fcntl(fd,F_SETFL,flags);
         if(ret == -)
             ERR_EXIT("fcntl");
     }
     
     //连接超时
     int connect_timeout(int fd,struct sockaddr_in *addr, unsigned int wait_seconds)
     {
         int ret;
         socklen_t addrlen = sizeof(struct sockaddr_in);
     
         if(wait_seconds > )
             activat_nonblock(fd);
     
         ret = connect(fd,(struct sockaddr*)addr,addrlen);
         if(ret <  && errno == EINPROGRESS)
         {
             fd_set connect_fdset;
             struct timeval timeout;
             FD_ZERO(&connect_fdset);
             FD_SET(fd,&connect_fdset);
             timeout.tv_sec = wait_seconds;
             timeout.tv_usec = ;
             do
             {
                 ret = select(fd+,NULL,&connect_fdset,NULL,&timeout);
             }while(ret <  && errno == EINTR)
             if(ret == )
             {
                 ret = -;
                 errno = ETIMEDOUT;
             }
             else if(ret < )
                 return -;
             else if(ret == )
             {
                 int err;
                 socklen_t socklen = sizeof(err);
                 int sockoptret = getsockopt(fd,SOL_SOCKET,SO_ERROR,&err,&socklen);
                 if(sockoptret == -)
                 {
                     return -;
                 }
                 if(err == )
                     ret = ;
                 else
                 {
                     errno = err;
                     ret = -;
                 }
             }
         }
     
         if(wait_seconds > )
         {
             deactivate_nonblock(fd);
         }
         return ret;
     }