tcp select模型服务端示例

select_server.c

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

#define MAXLINE 1024

void handle(int* client_fds, int max_fds, fd_set* p_read_set, fd_set* p_all_set);

int main(int argc, char** argv)
{
    char* serv_host = "0.0.0.0";
    int serv_port = 53101;
    // 等待队列的最大长度
    int listen_q = 1024;
    int fd_sock, fd_conn;

    if (3 == argc)
    {
	serv_host = argv[1];
	serv_port = atoi(argv[2]);
    }
    else if(1 != argc)
    {
	printf("Usage:%s Ip Port\n", argv[0]);
	return -1;
    }

    if(0 >= serv_port)
    {   
        perror("set port error");
        return -1; 
    }  

    struct sockaddr_in cli_addr, serv_addr;
    socklen_t socklen = sizeof(struct sockaddr_in);
    int n_ready;
    // select最大可支持的描述符，1024
    int client_fds[FD_SETSIZE];
    fd_set read_set, all_set;
    int max_fd;

    // SOCK_STREAM 面向连接 提供有序的双向的字节流,为Internet地址族使用TCP
    // SOCK_DGRAM 面向无连接 不可靠的数据报服务,为Internet地址族使用UDP
    fd_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(0 > fd_sock)
    {
        perror("socket error");
        return fd_sock;
    }

    int opt = 1;
    // reuseaddr close之后不立即关闭而是进入TIME_WAIT，已备重用
    if (0 > setsockopt(fd_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)))
    {
        perror("setsockopt SO_REUSEADDR error");
        return -1;
    }

    bzero(&serv_addr, sizeof(serv_addr));
    // 协议类型，AF_INET, AF_INET6, AF_UNIX 分别代表ipv4 ipv6 和unix本地通信
    serv_addr.sin_family = AF_INET;
    // 点分地址转换为网络字节序的
    serv_addr.sin_addr.s_addr = inet_addr(serv_host);
    // 主机字节序转换为网络字节序 host to network long, host to network short
    // serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(serv_port);

    // sockaddr为通用套接字地址，sockaddr_in为internet环境下地址形式，二者长度一致
    if(0 > bind(fd_sock, (struct sockaddr *) &serv_addr, socklen))
    {
        perror("bind error");
        return -1;
    }

    if (0 > listen(fd_sock, listen_q))
    {
        perror("listen error");
        return -1;
    }
    size_t i; 
    for (i = 0; i < FD_SETSIZE; i++)
    {
	// 初始化连接池
        client_fds[i] = -1;
    }

    // 清空集合
    FD_ZERO(&all_set);
    // 将socket描述符加入到集合中
    FD_SET(fd_sock, &all_set);
    max_fd = fd_sock;

    printf("select_server startup, listen on %s:%d\n", serv_host, serv_port);
    printf("max connection: %d\n", FD_SETSIZE);

    for( ; ; )
    {
        read_set = all_set;
	/*select 参数列表
	  int maxfdp是一个整数值，是指集合中所有文件描述符的范围，即所有文件描述符的最大值加1，不能错！
	  在Windows中这个参数的值无所谓，可以设置不正确。 
	  　　
	  fd_set *readfds是指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的读变化的，即我们关心是否可以从这些文件中读取数据了，
	  如果这个集合中有一个文件可读，select就会返回一个大于0的值，表示有文件可读，如果没有可读的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，
	  select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的读变化。 
	  　　
	  fd_set *writefds是指向fd_set结构的指针，这个集合中应该包括文件描述符，我们是要监视这些文件描述符的写变化的，即我们关心是否可以向这些文件中写入数据了，
	  如果这个集合中有一个文件可写，select就会返回一个大于0的值，表示有文件可写，如果没有可写的文件，则根据timeout参数再判断是否超时，若超出timeout的时间，
	  select返回0，若发生错误返回负值。可以传入NULL值，表示不关心任何文件的写变化。 
	  　　
	  fd_set *errorfds同上面两个参数的意图，用来监视文件错误异常。 
	  　　
	  struct timeval* timeout是select的超时时间，这个参数至关重要，它可以使select处于三种状态：
	  第一，若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；
	  第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；
	  第三，timeout的值大于0，这就是等待的超时时间，即 select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。
	*/
        n_ready = select(max_fd+1, &read_set, NULL, NULL, NULL);
        if(0 > n_ready)
        {
            perror("select error");
            continue;
        }

	// 检查是否新的连接进来（socket是否可读写）
        if(FD_ISSET(fd_sock, &read_set))
        {
	    // 接收客户端连接 产生于该连接的描述符
            fd_conn = accept(fd_sock, (struct sockaddr *) &cli_addr, &socklen);
            if (0 > fd_conn)
            {
                perror("accept error");
                continue;
            }
            printf("accept form %s:%d\n", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));

            for (i = 0; i < FD_SETSIZE; i++)
            {
                if (-1 == client_fds[i])
                {
		    // 把连接放入连接池
                    client_fds[i] = fd_conn;
                    break;
                }
            }
            
            if (FD_SETSIZE == i)
            {
                printf("too many connection, more than %d\n", FD_SETSIZE);
                close(fd_conn);
                continue;
            }

            if (max_fd < fd_conn)
            {
                max_fd = fd_conn;
            }

	    // 把连接描述符加入集合
            FD_SET(fd_conn, &all_set);
            if (--n_ready <= 0)
            {
                continue;
            }
        }

	// n_ready 大于0, 且非新连接才会执行到这里 意味着已有连接收到了数据 
        handle(client_fds, max_fd, &read_set, &all_set);
    }

    close(fd_sock);
    return 0;
}


void handle(int* client_fds, int max_fd, fd_set* p_read_set, fd_set* p_all_set)
{
    int n_read;
    int i;
    char buf[MAXLINE];
    for(i=0; i<max_fd; i++)
    {
        if (-1 == client_fds[i])
            continue;

        if (FD_ISSET(client_fds[i], p_read_set))
        {
            n_read = read(client_fds[i], buf, MAXLINE);
            if (0 > n_read)
            {
                perror("read error");
                close(client_fds[i]);
                FD_CLR(client_fds[i], p_all_set);
                client_fds[i] = -1;
                continue;
            }
            else if(0 == n_read || 0 == strncmp("exit", buf, 4))
            {
                printf("client close the connection\n");
                close(client_fds[i]);
                FD_CLR(client_fds[i], p_all_set);
                client_fds[i] = -1;
                continue;
            }

            write(client_fds[i], buf, n_read);
        }
    }
}