select实现tcp并发服务器的基本框架流程

服务端初始化：

socket();

bind();

listen();

for( ; ; )   

{

        FD_SET(listen_fd , &allset);//设置监听读写文件描述符

        select();//调用select函数

        if()//如果是倾听套接字就绪,说明一个新的连接请求建立

        {

                建立连接(accept);

                加入到监听文件描述符中去;

        }

        else//否则说明是一个已经连接过的描述符

        {

                进行操作(read或者write);

        }

}

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <errno.h>
#include <strings.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>
#include <pthread.h>


#define SERV_PORT 9888
#define WAIT_COUNT 5
#define READ_SIZE 32


//void send_myself(int fd);


//void *pthread_handle(void *arg);


int main(int argc, char **argv)
{ 
        pthread_t tid;
        
        int i,max_i,listen_fd,max_fd,conn_fd,sock_fd;
        int nready,client[FD_SETSIZE];


        fd_set allset;


        struct sockaddr_in  listen_addr,client_addr;
        socklen_t len = sizeof(struct sockaddr_in);
listen_fd = socket(PF_INET,SOCK_STREAM,0);
if(listen_fd == -1)
{
perror("socket failed !");
return -1;
}


        max_i = -1;
        max_fd = listen_fd;

bzero(&listen_addr,sizeof(listen_addr));
listen_addr.sin_family = AF_INET;
listen_addr.sin_addr.s_addr = htonl(INADDR_ANY);
listen_addr.sin_port = htons(SERV_PORT);
bind(listen_fd,(struct sockaddr *)&listen_addr,len);
listen(listen_fd,WAIT_COUNT);
    
        for(i = 0; i < FD_SETSIZE; ++i)
client[i] = -1;
FD_ZERO(&allset);


    
        for(;;)
        {
   FD_SET(listen_fd,&allset);
            
            nready = select(max_fd+1,&allset,NULL,NULL,NULL);

            if(FD_ISSET(listen_fd,&allset))
            {
                len = sizeof(struct sockaddr);
       conn_fd = accept(listen_fd,(struct sockaddr *)&listen_addr,&len);
       if(conn_fd == -1)
                {
                    perror("accept fail !");
                    return -1;
                }
       for(i = 0; i < FD_SETSIZE; ++i)
                {
           if(client[i] < 0)
           {
               client[i] = conn_fd;
       break;
           }
       }


       if(FD_SETSIZE == i)
       {
           perror("too many clients!");
           return -1;
       }


       FD_SET(conn_fd,&allset);/*add new descriptor to allset*/


       if(conn_fd > max_fd)
           max_fd = conn_fd;
       if(i > max_i)
           max_i = i;
                if(--nready <= 0)
                    continue;
            }
            else
            { 
            for(i = 0; i <= max_i; ++i)/*check all clients for data*/
            {
                if((sock_fd = client[i]) < 0)
           continue;


       if(FD_ISSET(sock_fd,&allset))
       {
                    //int *lptr = (int*)malloc(sizeof(int));
                    //*lptr = sock_fd;
           //int err = pthread_create(&tid,NULL,pthread_handle,lptr);
                    //send_myself(sock_fd);
                    char tmp[READ_SIZE] = {0};
                    int size = read(sock_fd,tmp,READ_SIZE-1);
                    write(STDOUT_FILENO,tmp,size);
                    bzero(tmp,READ_SIZE);
                    
                    FD_CLR(sock_fd,&allset);
                    close(sock_fd);
                    client[i] = -1;
               
                    continue;
                    
                    //if(--nready <= 0)
                        //break; 
       }
            }
            }
    }
    return 0;
}


/*
void *pthread_handle(void *arg)
{
    int connfd = *((int*)arg);
    free(arg);
    pthread_detach(pthread_self());
    send_myself(connfd);
    close(connfd);
    return NULL;
}
*/


/*
void send_myself(int fd)
{
char tmp[READ_SIZE] = {0};
char *p_tmp = tmp;
while(1)
{
int size = read(fd, tmp,READ_SIZE-1);
write(STDOUT_FILENO,tmp,size);
if(0 == size)
{
perror("read fail!");
return;
}
if(0 == write(fd,tmp,size))
{
perror("write client failed !");
return;
}
bzero(tmp,READ_SIZE);
}
}
*/