I/O复用的高级应用二——聊天室程序

Jane_Librastar

已于 2023-06-20 21:10:22 修改

阅读量96

点赞数

分类专栏： Linux学习记录文章标签：服务器 linux 网络网络协议

于 2023-06-20 19:41:29 首次发布

本文链接：https://blog.csdn.net/qq_43797135/article/details/131293849

版权

Linux学习记录专栏收录该内容

29 篇文章 1 订阅

订阅专栏

类似ssh这样的登录服务通常要同时处理网络连接和用户输入，利用I/O复用也可以实现。本章以poll为例实现一个简单的聊天室程序，以阐述如何使用I/O复用技术同时处理网络连接和用户接入。该聊天室程序能让所有用户同时在线群聊，它分为客户端和服务器两个部分。其中客户端程序有两个功能：一是从标准输入终端读入用户数据，并将用户数据发送至服务器；二是往标准输出终端打印服务器发送给它的数据。服务器的功能是接收客户数据，并把客户数据发送给每一个登录到该服务器上的客户端（数据发送者除外）。下面我们依次给出客户端程序和服务器程序的代码。

客户端

客户端程序使用poll同时监听用户输入和网络连接，并利用splice函数将用户输入内容直接定向到w网络连接上以发送之，从而实现数据零拷贝，提高了程序执行效率。客户端程序如下面代码所示。

#define _GNU_SOURCE 1
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <poll.h>
#include <fcntl.h>

#define BUFFER_SIZE 64

int main( int argc, char* argv[] )
{
    //输入服务器的ip地址和端口号
    if( argc <= 2 )
    {
        printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi( argv[2] );

    struct sockaddr_in server_address;
    bzero( &server_address, sizeof( server_address ) );
    server_address.sin_family = AF_INET;
    inet_pton( AF_INET, ip, &server_address.sin_addr );
    server_address.sin_port = htons( port );

    int sockfd = socket( PF_INET, SOCK_STREAM, 0 );
    assert( sockfd >= 0 );
    if ( connect( sockfd, ( struct sockaddr* )&server_address, sizeof( server_address ) ) < 0 )
    {
        printf( "connection failed\n" );
        close( sockfd );
        return 1;
    }
    //监控若干个文件描述符
    pollfd fds[2];
    fds[0].fd = 0;//注册文件描述符0（标准输入）
    fds[0].events = POLLIN;//监听fds上的事件（POLLIN数据可读）
    fds[0].revents = 0;//实际发生的事件，由内核填充

    fds[1].fd = sockfd;//文件描述符socket上的可读事件
    fds[1].events = POLLIN | POLLRDHUP;
    //POLLRDHUP:它在socket上接收到对方关闭连接的请求之后触发,需要在代码最开始处定义_GNU_SOURCE
    fds[1].revents = 0;
    char read_buf[BUFFER_SIZE];
    int pipefd[2];//pipefd[1]写入管道，pipefd[0]读出管道
    int ret = pipe( pipefd );//建立半双工管道
    assert( ret != -1 );

    while( 1 )
    {
        ret = poll( fds, 2, -1 );//timeout=-1表示永远等待
        if( ret < 0 )//错误返回
        {
            printf( "poll failure\n" );
            break;
        }

        if( fds[1].revents & POLLRDHUP )//服务器端关闭连接之后触发
        {
            printf( "server close the connection\n" );
            break;
        }
        else if( fds[1].revents & POLLIN )//监听到事件发生：可读数据
        {
            memset( read_buf, '\0', BUFFER_SIZE );
            recv( fds[1].fd, read_buf, BUFFER_SIZE-1, 0 );//从服务器端接收其他用户发的消息
            printf( "%s\n", read_buf );
        }
        /*使用splice将用户输入的数据直接写到sockfd上（零拷贝），通过管道实现*/
        if( fds[0].revents & POLLIN )
        {
            //   待输入文件描述符   输出（管道） 移动数据长度
            ret = splice( 0, NULL, pipefd[1], NULL, 32768, SPLICE_F_MORE | SPLICE_F_MOVE );
            //SPLICE_F_MORE:告知操作系统内核下一个 splice 系统调用将会有更多的数据传来
            //SPLICE_F_MOVE:如果输出是文件，这个值则会使得操作系统内核尝试从输入管道缓冲区
            //直接将数据读入到输出地址空间，这个数据传输过程没有任何数据拷贝操作发生
            ret = splice( pipefd[0], NULL, sockfd, NULL, 32768, SPLICE_F_MORE | SPLICE_F_MOVE );
        }
    }
    
    close( sockfd );
    return 0;
}

服务器端

服务器程序使用poll同时管理监听socket和连接socket，并且使用牺牲空间换取时间的策略来提高服务器性能，代码如下所示：

#define _GNU_SOURCE 1
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <poll.h>

#define USER_LIMIT 5  //最大用户数量
#define BUFFER_SIZE 64  //读缓冲区的大小
#define FD_LIMIT 65535  //文件描述符数量限制

/*客户数据：客户端socket,待写到客户端的数据位置，从客户端读入的数据*/
struct client_data
{
    sockaddr_in address;
    char* write_buf;
    char buf[ BUFFER_SIZE ];
};
//非阻塞I/O读写
/*阻塞与非阻塞的区别在于，没有数据到达的时候是否立刻返回。*/
int setnonblocking( int fd )
{
    int old_option = fcntl( fd, F_GETFL );
    int new_option = old_option | O_NONBLOCK;
    fcntl( fd, F_SETFL, new_option );
    return old_option;
}

int main( int argc, char* argv[] )
{
    if( argc <= 2 )
    {
        printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi( argv[2] );

    int ret = 0;
    struct sockaddr_in address;
    bzero( &address, sizeof( address ) );
    address.sin_family = AF_INET;
    inet_pton( AF_INET, ip, &address.sin_addr );
    address.sin_port = htons( port );

    int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
    assert( listenfd >= 0 );

    ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
    assert( ret != -1 );

    ret = listen( listenfd, 5 );
    assert( ret != -1 );
    /*创建users数组，分配FD_LIMIT个client_data对象。可以预期：每个可能的
socket连接都可以获得一个这样的对象，并且socket的值可以直接用来索引（作为数组的下
标）socket连接对应的client_data对象，这是将socket和客户数据关联的简单而高效的方式*/
    client_data* users = new client_data[FD_LIMIT];
    /*尽管我们分配了足够多的client_data对象，但为了提高poll的性能，仍然有必要限制用户的数量*/
    pollfd fds[USER_LIMIT+1];//此处加一是因为多的那个对象需要返回信息
    int user_counter = 0;
    //初始化每个文件描述符
    for( int i = 1; i <= USER_LIMIT; ++i )
    {
        fds[i].fd = -1;
        fds[i].events = 0;
    }
    fds[0].fd = listenfd;
    fds[0].events = POLLIN | POLLERR;
    fds[0].revents = 0;

    while( 1 )
    {
        ret = poll( fds, user_counter+1, -1 );
        if ( ret < 0 )
        {
            printf( "poll failure\n" );
            break;
        }
        //poll机制：开始循环扫描
        for( int i = 0; i < user_counter+1; ++i )
        {
            if( ( fds[i].fd == listenfd ) && ( fds[i].revents & POLLIN ) )//监听的事件发生，有可读数据到达
            {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof( client_address );
                int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
                if ( connfd < 0 )
                {
                    printf( "errno is: %d\n", errno );
                    continue;
                }
                /*如果请求太多，则关闭新到的连接*/
                if( user_counter >= USER_LIMIT )
                {
                    const char* info = "too many users\n";
                    printf( "%s", info );
                    send( connfd, info, strlen( info ), 0 );
                    close( connfd );
                    continue;
                }
                /*对于新的连接，同时修改fds和users数组。
                前文已经提到，users[connfd]对应于新连接文件描述符connfd的客户数据*/
                user_counter++;
                users[connfd].address = client_address;
                setnonblocking( connfd );
                fds[user_counter].fd = connfd;
                fds[user_counter].events = POLLIN | POLLRDHUP | POLLERR;
                fds[user_counter].revents = 0;
                printf( "comes a new user, now have %d users\n", user_counter );
            }
            else if( fds[i].revents & POLLERR )//当前这个socket发生错误
            {
                printf( "get an error from %d\n", fds[i].fd );
                char errors[ 100 ];
                memset( errors, '\0', 100 );
                socklen_t length = sizeof( errors );
                if( getsockopt( fds[i].fd, SOL_SOCKET, SO_ERROR, &errors, &length ) < 0 )
                {
                    printf( "get socket option failed\n" );
                }
                continue;
            }
            else if( fds[i].revents & POLLRDHUP )//TCP连接被对方关闭或者对方关闭了写操作
            {
                /*如果客户端关闭连接，则服务器也关闭对应的连接，并将用户总数减1*/
                users[fds[i].fd] = users[fds[user_counter].fd];
                close( fds[i].fd );
                fds[i] = fds[user_counter];
                i--;
                user_counter--;
                printf( "a client left\n" );
            }
            else if( fds[i].revents & POLLIN )//数据可读
            {
                int connfd = fds[i].fd;
                memset( users[connfd].buf, '\0', BUFFER_SIZE );
                ret = recv( connfd, users[connfd].buf, BUFFER_SIZE-1, 0 );
                printf( "get %d bytes of client data %s from %d\n", ret, users[connfd].buf, connfd );
                if( ret < 0 )
                {   /*如果读操作出错，则关闭连接*/
                    if( errno != EAGAIN )
                    {
                        close( connfd );
                        users[fds[i].fd] = users[fds[user_counter].fd];
                        fds[i] = fds[user_counter];
                        i--;
                        user_counter--;
                    }
                }
                else if( ret == 0 )
                {
                    printf( "code should not come to here\n" );
                }
                else
                {   /*如果接收到客户数据，则通知其他socket连接准备写数据*/
                    for( int j = 1; j <= user_counter; ++j )
                    {
                        if( fds[j].fd == connfd )
                        {
                            continue;
                        }
                        
                        fds[j].events |= ~POLLIN;
                        fds[j].events |= POLLOUT;
                        users[fds[j].fd].write_buf = users[connfd].buf;//把这个用户的消息写道其他用户的缓冲区中，这样大家都能看到消息
                    }
                }
            }
            else if( fds[i].revents & POLLOUT )//数据可写
            {
                int connfd = fds[i].fd;
                if( ! users[connfd].write_buf )
                {
                    continue;
                }
                ret = send( connfd, users[connfd].write_buf, strlen( users[connfd].write_buf ), 0 );
                users[connfd].write_buf = NULL;
                /*写完数据后需要重新注册fds[i]上的可读事件*/
                fds[i].events |= ~POLLOUT;
                fds[i].events |= POLLIN;
            }
        }
    }

    delete [] users;
    close( listenfd );
    return 0;
}

分别在两端运行程序，可以多开几个客户端进行聊天，这里开了3个客户端：

很有意思，每个客户端发消息，其他用户都可以看得见，在同一个聊天程序中

服务器端可以看见所有消息