LINUX select socket编程 TCP

使用select函数可以以非阻塞的方式和多个socket通信。程序只是演示select函数的使用，功能非常简单，即使某个连接关闭以后也不会修改当前连接数，连接数达到最大值后会终止程序。

1. 程序使用了一个数组fd_A，通信开始后把需要通信的多个socket描述符都放入此数组。

2. 首先生成一个叫sock_fd的socket描述符，用于监听端口。

3. 将sock_fd和数组fd_A中不为0的描述符放入select将检查的集合fdsr。

4. 处理fdsr中可以接收数据的连接。如果是sock_fd，表明有新连接加入，将新加入连接的socket描述符放置到fd_A。

 
 

  
  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 
  
  <
  
  netinet
  
  /
  
  in
  
  .h
  
  >
  
  
#include 
  
  <
  
  arpa
  
  /
  
  inet.h
  
  >
  
  


  
  #define
  
   MYPORT 1234    
  
  //
  
   the port users will be connecting to
  
  


  
  #define
  
   BACKLOG 5     
  
  //
  
   how many pending connections queue will hold
  
  


  
  #define
  
   BUF_SIZE 200
  
  


  
  int
  
   fd_A[BACKLOG];    
  
  //
  
   accepted connection fd
  
  

  
  int
  
   conn_amount;    
  
  //
  
   current connection amount
  
  

  
  

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


  
  int
  
   main(
  
  void
  
  )
{
    
  
  int
  
   sock_fd, new_fd;  
  
  //
  
   listen on sock_fd, new connection on new_fd
  
  

  
      
  
  struct
  
   sockaddr_in server_addr;    
  
  //
  
   server address information
  
  

  
      
  
  struct
  
   sockaddr_in client_addr; 
  
  //
  
   connector's address information
  
  

  
      socklen_t sin_size;
    
  
  int
  
   yes 
  
  =
  
   
  
  1
  
  ;
    
  
  char
  
   buf[BUF_SIZE];
    
  
  int
  
   ret;
    
  
  int
  
   i;

    
  
  if
  
   ((sock_fd 
  
  =
  
   socket(AF_INET, SOCK_STREAM, 
  
  0
  
  )) 
  
  ==
  
   
  
  -
  
  1
  
  ) {
        perror(
  
  "
  
  socket
  
  "
  
  );
        exit(
  
  1
  
  );
    }

    
  
  if
  
   (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, 
  
  &
  
  yes, 
  
  sizeof
  
  (
  
  int
  
  )) 
  
  ==
  
   
  
  -
  
  1
  
  ) {
        perror(
  
  "
  
  setsockopt
  
  "
  
  );
        exit(
  
  1
  
  );
    }
    
    server_addr.sin_family 
  
  =
  
   AF_INET;         
  
  //
  
   host byte order
  
  

  
      server_addr.sin_port 
  
  =
  
   htons(MYPORT);     
  
  //
  
   short, network byte order
  
  

  
      server_addr.sin_addr.s_addr 
  
  =
  
   INADDR_ANY; 
  
  //
  
   automatically fill with my 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
  
  "
  
  );
        exit(
  
  1
  
  );
    }

    
  
  if
  
   (listen(sock_fd, BACKLOG) 
  
  ==
  
   
  
  -
  
  1
  
  ) {
        perror(
  
  "
  
  listen
  
  "
  
  );
        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
  
  ) {
        
  
  //
  
   initialize file descriptor set
  
  

  
          FD_ZERO(
  
  &
  
  fdsr);
        FD_SET(sock_fd, 
  
  &
  
  fdsr);

        
  
  //
  
   timeout setting
  
  

  
          tv.tv_sec 
  
  =
  
   
  
  30
  
  ;
        tv.tv_usec 
  
  =
  
   
  
  0
  
  ;

        
  
  //
  
   add active connection to fd set
  
  

  
          
  
  for
  
   (i 
  
  =
  
   
  
  0
  
  ; i 
  
  <
  
   BACKLOG; i
  
  ++
  
  ) {
            
  
  if
  
   (fd_A[i] 
  
  !=
  
   
  
  0
  
  ) {
                FD_SET(fd_A[i], 
  
  &
  
  fdsr);
            }
        }

        ret 
  
  =
  
   select(maxsock 
  
  +
  
   
  
  1
  
  , 
  
  &
  
  fdsr, NULL, NULL, 
  
  &
  
  tv);
        
  
  if
  
   (ret 
  
  <
  
   
  
  0
  
  ) {
            perror(
  
  "
  
  select
  
  "
  
  );
            
  
  break
  
  ;
        } 
  
  else
  
   
  
  if
  
   (ret 
  
  ==
  
   
  
  0
  
  ) {
            printf(
  
  "
  
  timeout\n
  
  "
  
  );
            
  
  continue
  
  ;
        }

        
  
  //
  
   check every fd in the set
  
  

  
          
  
  for
  
   (i 
  
  =
  
   
  
  0
  
  ; i 
  
  <
  
   conn_amount; i
  
  ++
  
  ) {
            
  
  if
  
   (FD_ISSET(fd_A[i], 
  
  &
  
  fdsr)) {
                ret 
  
  =
  
   recv(fd_A[i], buf, 
  
  sizeof
  
  (buf), 
  
  0
  
  );
                
  
  if
  
   (ret 
  
  <=
  
   
  
  0
  
  ) {        
  
  //
  
   client close
  
  

  
                      printf(
  
  "
  
  client[%d] close\n
  
  "
  
  , i);
                    close(fd_A[i]);
                    FD_CLR(fd_A[i], 
  
  &
  
  fdsr);
                    fd_A[i] 
  
  =
  
   
  
  0
  
  ;
                } 
  
  else
  
   {        
  
  //
  
   receive data
  
  

  
                      
  
  if
  
   (ret 
  
  <
  
   BUF_SIZE)
                        memset(
  
  &
  
  buf[ret], 
  
  '
  
  \0
  
  '
  
  , 
  
  1
  
  );
                    printf(
  
  "
  
  client[%d] send:%s\n
  
  "
  
  , i, buf);
                }
            }
        }

        
  
  //
  
   check whether a new connection comes
  
  

  
          
  
  if
  
   (FD_ISSET(sock_fd, 
  
  &
  
  fdsr)) {
            new_fd 
  
  =
  
   accept(sock_fd, (
  
  struct
  
   sockaddr 
  
  *
  
  )
  
  &
  
  client_addr, 
  
  &
  
  sin_size);
            
  
  if
  
   (new_fd 
  
  <=
  
   
  
  0
  
  ) {
                perror(
  
  "
  
  accept
  
  "
  
  );
                
  
  continue
  
  ;
            }

            
  
  //
  
   add to fd queue
  
  

  
              
  
  if
  
   (conn_amount 
  
  <
  
   BACKLOG) {
                fd_A[conn_amount
  
  ++
  
  ] 
  
  =
  
   new_fd;
                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);
                
  
  break
  
  ;
            }
        }
        showclient();
    }

    
  
  //
  
   close other connections
  
  

  
      
  
  for
  
   (i 
  
  =
  
   
  
  0
  
  ; i 
  
  <
  
   BACKLOG; i
  
  ++
  
  ) {
        
  
  if
  
   (fd_A[i] 
  
  !=
  
   
  
  0
  
  ) {
            close(fd_A[i]);
        }
    }

    exit(
  
  0
  
  );
}

CLIENT.C
    /* File Name: client.c */  
      
    #include<stdio.h>  
    #include<stdlib.h>  
    #include<string.h>  
    #include<errno.h>  
    #include<sys/types.h>  
    #include<sys/socket.h>  
    #include<netinet/in.h>  
      
    #define MAXLINE 4096  
      
      
    int main(int argc, char** argv)  
    {  
        int    sockfd, n,rec_len;  
        char    recvline[4096], sendline[4096];  
        char    buf[MAXLINE];  
        struct sockaddr_in    servaddr;  
      
      
        if( argc != 2){  
        printf("usage: ./client <ipaddress>\n");  
        exit(0);  
        }  
      
      
        if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){  
        printf("create socket error: %s(errno: %d)\n", strerror(errno),errno);  
        exit(0);  
        }  
      
      
        memset(&servaddr, 0, sizeof(servaddr));  
        servaddr.sin_family = AF_INET;  
        servaddr.sin_port = htons(1234);  
        if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){  
        printf("inet_pton error for %s\n",argv[1]);  
        exit(0);  
        }  
      
      
        if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){  
        printf("connect error: %s(errno: %d)\n",strerror(errno),errno);  
        exit(0);  
        }  
      
      
        printf("send msg to server: \n");  
        fgets(sendline, 4096, stdin);  
        if( send(sockfd, sendline, strlen(sendline), 0) < 0)  
        {  
        printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);  
        exit(0);  
        }  
        if((rec_len = recv(sockfd, buf, MAXLINE,0)) == -1) {  
           perror("recv error");  
           exit(1);  
        }  
        buf[rec_len]  = '\0';  
        printf("Received : %s ",buf);  
        close(sockfd);  
        exit(0);  
    }