1. #include <stdio.h>  
    2. #include <stdlib.h>  
    3. #include <unistd.h>  
    4. #include <errno.h>  
    5. #include <string.h>  
    6. #include <sys/types.h>  
    7. #include <sys/socket.h>  
    8. #include <netinet/in.h>  
    9. #include <arpa/inet.h>  
    11. #define MYPORT 88960    // the port users will be connecting to  
    13. #define BACKLOG 10     // how many pending connections queue will hold  
    15. #define BUF_SIZE 200  
    17. int fd_A[BACKLOG];    // accepted connection fd  
    18. int conn_amount;    // current connection amount  
    20. void showclient()  
    21. {  
    22.     int i;  
    23.     printf("client amount: %d\n", conn_amount);  
    24.     for (i = 0; i < BACKLOG; i++) {  
    25.         printf("[%d]:%d  ", i, fd_A[i]);  
    26.     }  
    27.     printf("\n\n");  
    28. }  
    30. int main(void)  
    31. {  
    32.     int sock_fd, new_fd;  // listen on sock_fd, new connection on new_fd  
    33.     struct sockaddr_in server_addr;    // server address information  
    34.     struct sockaddr_in client_addr; // connector's address information  
    35.     socklen_t sin_size;  
    36.     int yes = 1;  
    37.     char buf[BUF_SIZE];  
    38.     int ret;  
    39.     int i;  
    41.     if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {  
    42.         perror("socket");  
    43.         exit(1);  
    44.     }  
    46.     if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {  
    47.         perror("setsockopt");  
    48.         exit(1);  
    49.     }  
    51.     server_addr.sin_family = AF_INET;         // host byte order  
    52.     server_addr.sin_port = htons(MYPORT);     // short, network byte order  
    53.     server_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP  
    54.     memset(server_addr.sin_zero, '\0', sizeof(server_addr.sin_zero));  
    56.     if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {  
    57.         perror("bind");  
    58.         exit(1);  
    59.     }  
    61.     if (listen(sock_fd, BACKLOG) == -1) {  
    62.         perror("listen");  
    63.         exit(1);  
    64.     }  
    66.     printf("listen port %d\n", MYPORT);  
    68.     fd_set fdsr;  
    69.     int maxsock;  
    70.     struct timeval tv;  
    72.     conn_amount = 0;  
    73.     sin_size = sizeof(client_addr);  
    74.     maxsock = sock_fd;  
    75.     while (1) {  
    76.         // initialize file descriptor set  
    77.         FD_ZERO(&fdsr);  
    78.         FD_SET(sock_fd, &fdsr);  
    80.         // timeout setting  
    81.         tv.tv_sec = 30;  
    82.         tv.tv_usec = 0;  
    84.         // add active connection to fd set  
    85.         for (i = 0; i < BACKLOG; i++) {  
    86.             if (fd_A[i] != 0) {  
    87.                 FD_SET(fd_A[i], &fdsr);  
    88.             }  
    89.         }  
    91.         ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv);  
    92.         if (ret < 0) {  
    93.             perror("select");  
    94.             break;  
    95.         } else if (ret == 0) {  
    96.             printf("timeout\n");  
    97.             continue;  
    98.         }  
    100.         // check every fd in the set  
    101.         for (i = 0; i < conn_amount; i++) {  
    102.             if (FD_ISSET(fd_A[i], &fdsr)) {  
    103.                 ret = recv(fd_A[i], buf, sizeof(buf), 0);  
    105.                 char str[] = "Good,very nice!\n";  
    107.                 send(fd_A[i],str,sizeof(str) + 1, 0);  
    110.                 if (ret <= 0) {        // client close  
    111.                     printf("client[%d] close\n", i);  
    112.                     close(fd_A[i]);  
    113.                     FD_CLR(fd_A[i], &fdsr);  
    114.                     fd_A[i] = 0;  
    115.                 } else {        // receive data  
    116.                     if (ret < BUF_SIZE)  
    117.                         memset(&buf[ret], '\0', 1);  
    118.                     printf("client[%d] send:%s\n", i, buf);  
    119.                 }  
    120.             }  
    121.         }  
    123.         // check whether a new connection comes  
    124.         if (FD_ISSET(sock_fd, &fdsr)) {  
    125.             new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size);  
    126.             if (new_fd <= 0) {  
    127.                 perror("accept");  
    128.                 continue;  
    129.             }  
    131.             // add to fd queue  
    132.             if (conn_amount < BACKLOG) {  
    133.                 fd_A[conn_amount++] = new_fd;  
    134.                 printf("new connection client[%d] %s:%d\n", conn_amount,  
    135.                         inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));  
    136.                 if (new_fd > maxsock)  
    137.                     maxsock = new_fd;  
    138.             }  
    139.             else {  
    140.                 printf("max connections arrive, exit\n");  
    141.                 send(new_fd, "bye", 4, 0);  
    142.                 close(new_fd);  
    143.                 break;  
    144.             }  
    145.         }  
    146.         showclient();  
    147.     }  
    149.     // close other connections  
    150.     for (i = 0; i < BACKLOG; i++) {  
    151.         if (fd_A[i] != 0) {  
    152.             close(fd_A[i]);  
    153.         }  
    154.     }  
    156.     exit(0);  
    157. }