Linux(程序设计):56---poll复用技术实现在线群聊程序

最新推荐文章于 2022-08-31 20:55:47 发布
最新推荐文章于 2022-08-31 20:55:47 发布
阅读量681 收藏 5
点赞数 2
分类专栏： Linux(程序设计) 文章标签： poll复用技术实现在线群聊程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41453285/article/details/103667862
版权

一、程序介绍

  • 我们本文使用poll I/O复用来实现一个聊天室程序，能让所有的用户在线群聊
  • 服务端有一个功能：
    • 接收客户端数据，并把客户端数据发送给每一个登录到该服务器上的客户端（数据发送者除外）
  • 客户端有两个功能：
    • 1.从标准输入终端读入数据，并将用户数据发送至服务器
    • 2.往标准输出终端打印服务器发送给自己的数据

二、客户端程序设计

//poll_cli.cpp

#define _GNU_SOURCE 1

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <libgen.h>
#include <errno.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <poll.h>

#define BUFFER_SIZE 1024 //接受数据的缓冲区


int setnonblocking(int fd);

int main(int argc,char* argv[])
{
    //检测是否输入要连接的服务端IP和端口
    if(argc!=3){
        printf("usage:./%s [server ip] [server port]\n",basename(argv[0]));
        exit(EXIT_FAILURE);
    }

    int cli_fd,ser_port;
    const char *ser_ip;
    struct sockaddr_in ser_address;

    //创建套接字
    if((cli_fd=socket(AF_INET,SOCK_STREAM,0))==-1){
        perror("socket");
        exit(EXIT_FAILURE);
    }

    //服务端IP和端口
    ser_ip=argv[1];
    ser_port=atoi(argv[2]);

    //初始化服务端地址
    bzero(&ser_address,sizeof(ser_address));
    ser_address.sin_family=AF_INET;
    ser_address.sin_port=htons(ser_port);
    if(inet_pton(AF_INET,ser_ip,&ser_address.sin_addr.s_addr)==-1){
        perror("inet_pton");
        close(cli_fd);
        exit(EXIT_FAILURE);
    }

    //连接服务端
    if(connect(cli_fd,(struct sockaddr*)&ser_address,sizeof(ser_address))==-1){
        perror("connect");
        exit(EXIT_FAILURE);
    }

    //setnonblocking(cli_fd);

    int poll_ret_val;
    int pipe_fd[2];
    char recv_buff[BUFFER_SIZE];
    struct pollfd fd_array[2];
    bzero(fd_array,sizeof(fd_array));
    bzero(pipe_fd,sizeof(pipe_fd));

    //因为下面需要使用splice函数，创建用到的管道
    if(pipe(pipe_fd)==-1){
        perror("pipe");
        close(cli_fd);
        exit(EXIT_FAILURE);
    }

    //标准输入设置为可以判断:有数据可读
    fd_array[0].fd=0;
    fd_array[0].events=POLLIN;
    fd_array[0].revents=0;
    //连接的套接字设置为可以判断:服务端发送数据过来可读与TCP被对方(服务端)断开连接
    fd_array[1].fd=cli_fd;
    fd_array[1].events=POLLIN|POLLRDHUP;
    fd_array[1].revents=0;

    //开始poll轮询事件表
    while(1)
    {
        //参数3：-1永远阻塞等待
        poll_ret_val=poll(fd_array,2,-1);

        //poll出错，终止程序
        if(poll_ret_val==-1){
            perror("poll");
            close(cli_fd);
            exit(EXIT_FAILURE);
        }

        /*服务端关闭连接
        一定要放在POLLIN前处理,否则客户端将永远接收不到服务端断开的消息,因为
        服务端断开也可以当做POLLIN事件处理
        */
        if(fd_array[1].revents&POLLRDHUP){
            printf("server close\n");
            break;;
        }

        //接收到服务端的数据，打印到标准输出
        else if(fd_array[1].revents&POLLIN){
            int recv_ret_value;
            bzero(recv_buff,sizeof(recv_buff));
            //接收数据
            recv_ret_value=recv(fd_array[1].fd,recv_buff,sizeof(recv_buff)-1,0);
            if(recv_ret_value<0){
                if(errno!=EAGAIN){
                    perror("recv");
                    close(cli_fd);
                    exit(EXIT_FAILURE);
                }
            }
            printf("recv:%s\n",recv_buff);
        }

        //标准输入输入数据，发送给服务端
        if(fd_array[0].revents&POLLIN){
            //从标准输入发送到管道的写端(pipe_fd[1]为写端，数据会发送到管道的读端pipe_fd[0])
            if(splice(0,NULL,pipe_fd[1],NULL,32768,SPLICE_F_MORE|SPLICE_F_MOVE)==-1){
                perror("splice");
                close(cli_fd);
                exit(EXIT_FAILURE);
            }
            //从管道读端(pipe_fd[0])读到数据，发送给服务端
            if(splice(pipe_fd[0],NULL,cli_fd,NULL,32768,SPLICE_F_MORE|SPLICE_F_MOVE)==-1){
                perror("splice");
                close(cli_fd);
                exit(EXIT_FAILURE);
            }
        }
    }
    
    close(cli_fd);
    exit(EXIT_SUCCESS);
}

int setnonblocking(int fd)
{
    int old_options,new_options;
    if((old_options=fcntl(fd,F_GETFL))==-1){
        perror("fcntl");
        exit(EXIT_FAILURE);
    }

    new_options=old_options|O_NONBLOCK;
    if(fcntl(fd,F_SETFL,new_options)==-1){
        perror("fcntl");
        exit(EXIT_FAILURE);
    }

    return old_options;
}

三、服务端程序设计

//poll_ser.cpp
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <strings.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <poll.h>

#define LISTEN_NUM     5   //服务端监听(listen)客户端的最大数量值
#define CLI_LIMIT_NUM  5   //允许处理的客户端数量
#define BUFFER_SIZE    1024//读缓冲区大小

//客户端结构体,存放:客户端地址、待写到客户端数据的位置、从客户端读入的数据
struct client_data
{
    struct sockaddr_in address;
    char* write_buf;
    char recv_buf[BUFFER_SIZE];
};


int setnonblocking(int fd);

int main(int argc,char* argv[])
{
    if(argc!=3){
        printf("usage:./%s [server ip] [server port]\n",basename(argv[0]));
        exit(EXIT_FAILURE);
    }

    int ser_fd,port;
    const char* ip;

    //创建socket
    if((ser_fd=socket(AF_INET,SOCK_STREAM,0))==-1){
        perror("socket");
        exit(EXIT_FAILURE);
    }

    //服务端IP、端口
    ip=argv[1];
    port=atoi(argv[2]);

    //初始化服务端地址
    struct sockaddr_in ser_addr;
    bzero(&ser_addr,sizeof(ser_addr));
    ser_addr.sin_family=AF_INET;
    ser_addr.sin_port=htons(port);
    if(inet_pton(AF_INET,ip,&ser_addr.sin_addr.s_addr)==-1){
        perror("inet_pton");
        close(ser_fd);
        exit(EXIT_FAILURE);
    }

    //绑定服务端地址
    if(bind(ser_fd,(struct sockaddr*)&ser_addr,sizeof(ser_addr))==-1){
        perror("bind");
        close(ser_fd);
        exit(EXIT_FAILURE);
    }

    //监听
    if(listen(ser_fd,LISTEN_NUM)==-1){
        perror("listen");
        close(ser_fd);
        exit(EXIT_FAILURE);
    }

    //当前客户端的数量
    int client_counter,poll_ret_value;
    client_counter=0;
    //存放客户端信息的数组
    struct client_data *client_array=new struct client_data[CLI_LIMIT_NUM];

    //poll可以处理的事件数组，为客户端最大数量+1(标准输入)
    struct pollfd fdarray[CLI_LIMIT_NUM+1];
    //初始化poll事件数组
    for(int i=1;i<=CLI_LIMIT_NUM;++i){
        fdarray[i].fd=-1;
        fdarray[i].events=0;
    }
    /*
    设置服务端监听socket可以处理:
        1.当有客户端连接时，监听socket会变为可读(EPOLLIN)
        2.处理服务端socket的错误(EPOLLERR)
    */
    fdarray[0].fd=ser_fd;
    fdarray[0].events=POLLIN|POLLERR;
    fdarray[0].revents=0;

    //开始poll轮询事件表
    while(1)
    {
        /*参数2:有客户端连接时，client_counter就会增加，
                所以我们只需要轮询client_counter+1即可
          参数3：-1永远阻塞等待
        */
        poll_ret_value=poll(fdarray,client_counter+1,-1);

        //poll出错，退出轮询，完成一些程序清理工作
        if(poll_ret_value==-1){
            perror("listen");
            break;
        }

        //轮询标准输入+所有的客户端
        for(int i=0;i<client_counter+1;++i)
        {
            //如果是服务端socket并且有客户端连接,处理新连接的客户端(客户端连接触发EPOLLIN事件)
            if((fdarray[i].fd==ser_fd)&&(fdarray[i].revents==POLLIN)){
                int cli_fd;
                char cli_ip[24];
                struct sockaddr_in cli_addr;
                bzero(&cli_addr,sizeof(cli_addr));
                socklen_t cli_addr_len=sizeof(cli_addr);
                //等待接收新连接的客户端
                if((cli_fd=accept(ser_fd,(struct sockaddr*)&cli_addr,&cli_addr_len))==-1){
                    perror("accept");
                    continue;
                }

                //如果要处理的客户端数量已经达到上限,则关闭新连接的客户端
                if(client_counter>=CLI_LIMIT_NUM){
                    //将信息告诉标准输出与连接的客户端,并关闭新连接的客户端
                    const char* info="too many client";
                    printf("accept:%s\n",info);
                    if(send(cli_fd,info,strlen(info),0)==-1){
                        perror("send");
                        continue;
                    }
                    close(cli_fd);
                }

                //如果要处理的客户端数量还没达到最大数量,那么接收新客户端,并做一些处理工作
                client_counter++;
                client_array[client_counter].address=cli_addr;//放入到客户端数组
                client_array[client_counter].write_buf=NULL;
                //client_array[client_counter].recv_buf=NULL;

                setnonblocking(cli_fd);//设置为非阻塞
                
                //将新客户端放入到事件表中
                fdarray[client_counter].fd=cli_fd;
                fdarray[client_counter].events=POLLIN|POLLOUT|POLLRDHUP|POLLERR;
                fdarray[client_counter].revents=0;

                bzero(cli_ip,sizeof(cli_ip));
                inet_ntop(AF_INET,&cli_addr.sin_addr.s_addr,cli_ip,sizeof(cli_ip));
                printf("comes a new client,ip:%s,port:%d\n",cli_ip,ntohs(cli_addr.sin_port));
            }

            //如果某个套接字出现错误,获取错误码
            else if(fdarray[i].revents&POLLERR){
                char error_buf[50];
                bzero(error_buf,sizeof(error_buf));
                socklen_t error_buf_len=sizeof(error_buf);

                //获取错误码
                if(getsockopt(fdarray[i].fd,SOL_SOCKET,SO_ERROR,error_buf,&error_buf_len)==-1){
                    perror("getsockopt");
                    continue;
                }
                printf("get an error from socket %d,error:%s\n",fdarray[i].fd,error_buf);
            }

            /*如果有个客户端断开连接，关闭客户端并做处理工作
            同客户端程序，也要放在POLLIN事件前处理
            */
            else if(fdarray[i].revents&POLLRDHUP){
                //将客户端数组的最后一个客户端移动到当前要删除的客户端位置处保存
                client_array[i]=client_array[client_counter];
                close(fdarray[i].fd); //关闭客户端套接字
                fdarray[i]=fdarray[client_counter]; //将最后一个客户端的事件表存放到当前要删除的客户端位置处保存
                i--; //for循环次数减1
                client_counter--;
                printf("a client close\n");
            }

            //如果客户端有数据可读
            else if(fdarray[i].revents&POLLIN){
                //获取客户端的套接字，并从套接字读取数据
                int recv_ret_value;
                //int conn_fd=fdarray[].fd;
                bzero(client_array[i].recv_buf,BUFFER_SIZE);
                recv_ret_value=recv(fdarray[i].fd,client_array[i].recv_buf,BUFFER_SIZE-1,0);

                //如果读取失败，说明出错
                if(recv_ret_value<0){
                    if(errno!=EAGAIN){//错误编码不是EAGAIN，则关闭客户端套接字
                        close(fdarray[i].fd); //关闭套接字
                        //交换客户端数组
                        client_array[i]=client_array[client_counter];
                        //交换POLL事件数组对象
                        fdarray[i].fd=fdarray[client_counter].fd;
                        i--;
                        client_counter--;
                    }
                }
                else if(recv_ret_value==0){  //无数据可读 
                }
                else{
                    //将数据发送给其他客户端
                    for(int j=1;j<=client_counter;j++){
                        if(fdarray[j].fd==fdarray[i].fd)
                            continue;
                        
                        /*发送之后注册fdarray[i]上的事件为可写事件
                        fdarray[i].events|=~POLLIN;
                        fdarray[i].events|=POLLOUT;*/
                        client_array[j].write_buf=client_array[i].recv_buf;
                    }
                }
            }

            //客户端套接字可以写
            else if(fdarray[i].revents&POLLOUT){
                int send_ret_value;
                //int conn_fd=fdarray[i].fd;
                //如果客户端写缓冲区为空
                if(!client_array[i].write_buf)
                    continue;
                //发送数据
                if(send(fdarray[i].fd,client_array[i].write_buf,strlen(client_array[i].write_buf),0)==-1){
                    if(errno!=EAGAIN){//错误编码不是EAGAIN，则关闭客户端套接字
                        close(fdarray[i].fd); //关闭套接字
                        //交换客户端数组
                        client_array[i]=client_array[client_counter];
                        //交换POLL事件数组对象
                        fdarray[i].fd=fdarray[client_counter].fd;
                        i--;
                        client_counter--;
                    }
                }
                //清空写缓冲区
                client_array[i].write_buf=NULL;
                /*发送之后重新注册fdarray[i]上的可读事件
                fdarray[i].events|=~POLLOUT;
                fdarray[i].events|=POLLIN;*/
            }
        }
    }

    delete[] client_array;
    client_array=NULL;
    close(ser_fd);

    exit(EXIT_SUCCESS);
}

int setnonblocking(int fd)
{
    int old_options,new_options;
    if((old_options=fcntl(fd,F_GETFL))==-1){
        perror("fcntl");
        exit(EXIT_FAILURE);
    }

    new_options=old_options|O_NONBLOCK;
    if(fcntl(fd,F_SETFL,new_options)==-1){
        perror("fcntl");
        exit(EXIT_FAILURE);
    }

    return old_options;
}

四、演示效果

  • 开启服务端程序

  • 然后开启两个客户端去连接服务端

  • 可以看到服务端接收到了客户端的连接，并打印了客户端的信息

  • 此时两个客户端向服务端发送数据，对方都可以接收到

  • 当我们在客户端按下crtl+c终止程序时，服务端可以接受到客户端退出的消息

董哥的黑板报
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
linux网络编程十六：I/O复用的应用-poll简单实现聊天室程序
JasonLiu的专栏
04-04 2102
这次我们以poll为例实现一个简单的聊天室程序，实现让所有用户同时在线群聊，分为客户端和服务端两部分。 客户端有两个功能：一是从标准输入终端读取用数据，并将用户数据发关至服务器；二是往标准输出终端打印服务器发送给它的数据。 服务端功能是接收客户数据，并把客户数据发送给每一个登录到该服务器上的客户端（数据发送者除外）。 1. 客户端使用poll监听用户输入和网络连接，并利用sp
Linux程序设计技术技巧与项目实践网络编程第9章.pptx
11-23
在深入探讨Linux程序设计技术技巧与项目实践网络编程的第9章之前，让我们首先理解Socket的基本概念。Socket，也称为套接字，是TCP/IP协议传输层提供的一种接口，用于编程访问网络资源。它是TCP/IP网络应用程序的API...
Linux高性能服务器之poll应用（16）
qq_62309585的博客
08-31 348
poll的应用
关于POLL检测对端关闭连接----《Linux高性能服务器编程》读书笔记
andywang201001的博客
04-05 1373
POLL检测对端关闭连接有两种方法：1）触发POLLIN事件，recv调用返回02）触发POLLRDHUP事件其中POLLRDHUP 需要2.6.17以上内核，而且代码最开始处定义_GNU_SOURCE,实际上测试不定义也行。测试代码如下：聊天室服务器代码//#define _GNU_SOURCE 1 #include &lt;sys/types.h&gt; #include &lt;sys/so...
linux C++ poll实现的聊天室程序 客户端----服务端
晴天的专栏
08-16 3082
//该聊天室程序能让所有用户同时在线群聊，他分为客户端和服务端两个部分，其中客户端有两个功能，一是从标准输入终端读入用户数据，并将用户数据发送服务器，二是往标准输出端打印服务器发送给他的数据，服务器的功能是接收客户数据，并把客户数据发送给每一个登陆到该服务器上的客户端（数据发送者除外） 客户端程序 #define _GNU_SOURCE 1 #include #include #inclu
面经-hangzhou
m0_46338222的博客
07-08 6356
加油
网络并发编程--maoz
有小小的远大抱负
03-22 363
并发网络编程 文章目录1. 网络编程1.1 网络基础知识1.1.1 什么是网络1.1.2 网络通信标准1.1.3 通信地址（IP地址确定计算机，端口号确定网络程序）1.1.4 服务端与客户端1.2 UDP 传输方法1.2.1 套接字简介1.2.3 UDP套接字编程1.2.4 UDP套接字特点1.3 TCP 传输方法1.3.1 TCP传输特点1.3.2 TCP服务端1.3.3 TCP客户端1.3.4 TCP套接字细节1.3.5 TCP与UDP对比...
python123查找指定字符输入m_README.md · chengzi666/python_study3 - Gitee.com
weixin_39979215的博客
12-21 1737
1.网络编程网络功能:数据的传输OSI七层模型 --> 网络通信标准化流程应用层 : 提供用户服务,具体功能有程序体现表示层 : 数据的压缩优化和加密会话层 : 建立应用连接,选择合适的传输服务传输层 : 提供传输服务,进行流量控制网络层 : 路由选择,网络互连链路层 : 进行数据交换,控制具体消息收发,链路连接物理层 : 提供物理硬件传输,网卡,接口设置,传输介质OSI七层模型优势:1.建...
并发编程
哦 卷！
08-18 319
并发编程 文章目录并发编程多任务编程进程（process）进程理论基础基于fork的多进程编程fork使用进程相关函数孤儿和僵尸群聊聊天室multiprocessing 模块创建进程进程创建方法自定义进程类进程池实现进程间通信（IPC）管道通信(Pipe)消息队列共享内存信号量（信号灯集）线程编程（Thread）线程基本概念threading模块创建线程线程对象属性自定义线程类同步互斥线程间通信...
后端架构师技术图谱
HATAO999999的博客
04-06 346
数据结构 队列 集合 链表、数组 字典、关联数组 栈 树 二叉树 完全二叉树 平衡二叉树 二叉查找树（BST） 红黑树 B-，B+，B*树 LSM 树 BitSet 常用算法 排序、查找算法 选择排序 冒泡排序 插入排序 快速排序 归并排序 希尔排序 堆排序 计数排序 桶排序 基数排序 二分查找 Java 中的排序工具 布隆过滤器 字符串比较
商业编程-源码-I-Poll(简单的投票程序).zip
06-21
I-Poll是一个简单的投票应用程序，它为初学者提供了理解基本编程概念和实践的机会，同时也适用于专业人士进行快速原型设计。这个项目的核心目标是实现一个用户友好的界面，允许用户参与投票并查看投票结果。 源码...
NAPI-技术在-Linux-网络驱动上的应用和完善.docx
最新发布
11-28
NAPI 技术是 Linux 上的一种提高网络处理效率的技术，其核心概念是使用 POLL 的方法来轮询数据，而不是使用中断的方式读取数据。该技术已经在网卡驱动层和网络层得到了广泛的应用，驱动层次上已经有 E1000 系列网卡...
longpoll-doc:最新用户LongPoll API的文档
05-08
用户LongPoll API 文件计划： 事件10。重置会话标志 事件12。设置对话标志 事件13。删除对话中的所有消息 事件18。消息更改 事件19。重置邮件缓存 事件20。固定和取消固定对话 事件21.未知 事件51.更改聊天数据（不...
UDP分包与组包
热门推荐
董哥的黑板报
07-09 1万+
一、UDP概述 UDP协议就不过多的介绍了，可以参阅：https://blog.csdn.net/qq_41453285/article/details/103984794，或者其他关于UDP的文章 下面有一个网站可以来查看当前各国的流量速率比，进入之后找到中国，点击查看：https://www.speedtest.net/global-index 二、UDP的特性与应用场景 采用UDP有3个关键点： 网络带宽需求较小，而实时性要求高 大部分应用无需维持连接 需要低功耗 应用场景
Linux(程序设计):15---系统调用函数syscall
董哥的黑板报
06-04 6107
一、格式 #define _GNU_SOURCE /* See feature_test_macros(7) */ #include <unistd.h> #include <sys/syscall.h> /* For SYS_xxx definitions */ int syscall(int number, ...); 二、功能与特点 sys...
Linux(程序设计):29---Zlib库（数据压缩与解压）
董哥的黑板报
06-11 5360
一、Zlib库概述 zlib压缩算法页是对deflate进行的封装，在另一篇文章中我们介绍过了Deflate压缩算法算法，文章最后也提到了zlib压缩算法。具体可以参阅：https://blog.csdn.net/qq_41453285/article/details/106685915 Zlib库相关函数 压缩函数： deflateInit : 参数比较少，里面的实现其实是调用的deflateInit2 deflateInit2: 压缩初始化的基础函数，有很多参数，下面会重点介绍 ...
Linux(程序设计):18---libmysqlclient-dev库（C语言操作MySQL）
董哥的黑板报
10-19 4442
一、C语言访问MySQL的前提 ①安装了MySQL服务端 见文章：https://blog.csdn.net/qq_41453285/article/details/102638547 ②安装MySQL库 使用C语言访问MySQL之前需要安装MySQL库，输入以下命令安装： #环境：Ubuntu 14.04 sudo apt-get install libmysqlclient-...
Linux(程序设计):27---iconv库（转换字符编码）
董哥的黑板报
06-11 3809
待续
Linux程序设计基础：第三版英文详解
7. 网络编程：介绍套接字编程，包括TCP/IP协议栈、客户端/服务器模型、多路复用技术如select、poll和epoll，以及异步非阻塞I/O。 8. 设备驱动编程：对于高级用户，书籍可能还会涉及Linux内核模块开发和设备驱动编写...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

董哥的黑板报

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值