• IO多路复用 Linux C Server-Client 多用户聊天系统

     

    目录

    Server-Client

    mutiplexingServer

    mutiplexingClient

    mutiplexing

    Server-Client

    在Linux系统中，IO多路复用是一种机制，它允许一个进程能够监视多个文件描述符（sockets、pipes等）的可读、可写和异常等事件。这样，一个进程就能够同时等待多个IO操作，而不需要创建多个线程来处理每个IO操作。

    常见的IO多路复用函数包括select、poll、epoll等。这些函数允许程序员编写高效的IO多路复用代码，从而使得单个进程能够同时处理多个IO事件，提高系统的并发性能。

    使用IO多路复用的好处在于，它可以避免创建大量的线程或进程来处理IO事件，从而减少了系统资源的消耗，并且降低了上下文切换的开销。这对于高性能的网络服务器等应用是非常重要的。

    编写程序实现多个Client之间通过Server来传递消息从而实现client间的通信功能。要求如下：

    服务器创建3个众所周知的命名管道FIFO_1, FIFO_2, FIFO_3, 分别接收用户的注册请求、登录请求和聊天请求，服务器等待任一管道来的请求，收到时立即响应；不同用户不允许使用同一用户名注册，并设置密码。

    每个用户都建立一个以自己用户名为名字的命名管道，用户A发送给用户B的信息发送给服务器，然后服务器通过B的专用FIFO发送给用户B。

    基本思路是用select函数实现IO多路复用，使得单个线程能够同时处理多个IO事件。

    服务器能够处理多个用户的注册请求、登录请求和聊天请求，不同用户之间可以通过服务器进行通信。

    我们编写的代码文件有实现服务器的mutiplexingServer.c，实现客户端的mutiplexingClient.c，以及通信配置的mutiplexing.h。

    首先是配置通信的头文件mutiplexing.h，在这里我们定义了服务器众所周知的三个命名管道和规定了服务器可容纳用户的数目。

    User结构体存储用户的命名管道信息以及用户名和密码。

    Chat结构体存储聊天信息，包括目标用户的命名管道信息和发送者的命名管道信息，还有要发送的聊天信息。

    还有一个Response结构体用来存储服务器返回客户端的响应信息，由于操作不一定总是客户端所期望的，所以我们除了正常的响应信息外，还存储了一个ok值，当ok值不为0时，说明操作异常。

    接下来我们来看服务器的实现。

    首先定义了一个全局变量userNumber来记录当前用户的数量，还有一个users数组存储所有用户的信息。

    然后创建三个众所周知的命名管道文件并打开。

    指定检查这三个文件描述符并获取最大的文件描述符。

    关键用select监听这些文件描述符。

    然后发现哪个文件描述符准备好可读的时候就调用我们写好的处理函数来处理。

    下面逐个讲解我们写的处理函数。

    首先是处理注册请求的函数。

    我们拿到用户名判断现有的用户组中是否有相同的用户名，如果有，那么我们向客户端返回该用户名已经存在的信息。

    如果没有用户名与它相同，那么我们把这个用户的信息加到现有的用户组里面，并向客户端返回注册成功的消息，并且在服务器端打印该用户注册的信息。

    然后看登录处理函数。

    首先看看当前用户组里面有没有这个用户，找到的话就比较密码是否相同，相同就向客户端发送登录成功的信息，并在服务器端打印该用户登录的信息；密码不同就发送密码错误的信息；如果没有找到这个用户就发送用户名错误的信息。

    最后看聊天处理函数。

    首先判断该用户要发生的目标用户存不存在，存在的话就向目标用户发送聊天信息，并向发送者反馈信息发送成功，如果目标用户不存在，向发送者反馈该用户不存在。

    再看客户端实现。

    主函数是创建命名管道，然后进入功能页面显示函数。

    在主功能页面，我们首先提示用户输入r表示注册，输入l表示登录，输入q表示退出。如果是输入l或者r，即注册或者登录，我们就收集用户名和密码然后跳转到相应的请求发送函数，如果收到其他字符则给出输入错误信息并重新展示主功能页面。

    然后我们看注册请求发送函数。

    打开众所周知的注册命名管道，向其写入我们收集的用户名和密码，等待服务器响应后打印响应信息并返回主页面，因为不管注册的结果如何，都需要返回主页面进行下一步的操作。

    然后是登录请求函数。

    同样我们打开众所周知的登录命名管道，向其写入收集的用户名和密码，如果登录成功，那么进入聊天页面，否则返回主页面。

    最后看聊天请求函数。

    先展示功能，提示用户按下r表示接收消息，按下s表示发送消息，按下q表示退出当前页面。

    如果是发送消息，那么需要输入发送目标用户的用户名已经要发送的消息并打印服务器返回的发送结果。

    如果是接收消息，就从自己的命名管道中读取数据并打印。

    如果用户按下的其他按键，那么提示用户按错了，重新展示聊天页面。

    现在我们来展示运行结果。

    首先编译运行服务器，可以看到服务器已经启动。

    再编译运行一个客户端，可以看到功能展示页面。

    然后我们输入r注册，输入用户名yemaolin和密码2021155015，可以看到服务器返回的注册成功的信息。

    然后我们输入l登录，输入刚刚注册的用户名和密码进行登录，可以看到登录成功。

    然后我们再开一个客户端注册一个game101，密码是OpenGL并登录。

    然后我们用game101给yemaolin发消息hello, I am game101。

    然后我们用yemaolin接收消息。

    然后yemaolin再给game101发一条消息I love C++。

    同样game101可以收到yemaolin发来的消息。

    最后我们可以看一下服务器端打印的消息，这展示了用户的状态。

    圆满结束IO多路复用。 

    这个过程还是比较难顶的，但是结果还是比较美好的。

    首先不得不说，IO多路复用真的是美妙。我大二曾经用Java写过多个客户端的聊天程序，但是是用的多线程实现的。如今居然可以用单线程实现多用户访问服务器，真是神奇。当然多路复用只能让服务器同时处理多个用户的请求，轮到客户端本身发送和接受消息的时候，在同一时间，客户端只能选择发送消息或者是接收消息。如果要同时接收和发送的话，那估计只有多线程可以实现了。

    这次使用select实现的IO多路复用聊天程序除了能够处理正常的用户注册、用户登录和用户间通信之外，还对一些异常情况做了处理，例如用户重复注册，登录用户名错误或者是密码错误，已经发送消息时目标用户不存在等情况做了处理，让我们的程序更加健壮。

    除此之外，为了之后的功能拓展以及便于修改，我们将每个功能模块化，并将一些基本的配置消息单独写在一个头文件，这为我们之后的进一步完善做了比较坚实的基础。

    mutiplexingServer

    1. #include <unistd.h>
    2. #include <stdlib.h>
    3. #include <stdio.h>
    4. #include <string.h>
    5. #include <sys/stat.h>
    6. #include <fcntl.h>
    7. #include "mutiplexing.h"
    8. #include <sys/select.h>
    9.  
    10. int userNumber = 0; // 当前用户量
    11. User users[UserCapacity];
    12.  
    13. void registerHandler(User*user) {
    14.     char message[BuffSize];
    15.     int ok = 0;
    16.     for (int i = 0; i < userNumber; i++) {
    17.         if (strcmp(user->username, users[i].username) == 0) {
    18.             sprintf(message, "The username has already exited!");
    19.             ok = -1;
    20.             break;
    21.         }
    22.     }
    23.     if (ok == 0) {
    24.         strcpy(users[userNumber].username, user->username);
    25.         strcpy(users[userNumber].password, user->password);
    26.         sprintf(message, "Register succeed!");
    27.         printf("User %s register\n",user->username);
    28.         userNumber++;
    29.     }
    30.     int fd = open(user->fifo, O_RDWR | O_NONBLOCK);
    31.     write(fd, message, BuffSize);
    32. }
    33.  
    34. void loginHandler(User*user) {
    35.     Response response;
    36.     response.ok = -1;
    37.     for (int i = 0; i < userNumber; i++) {
    38.         if (strcmp(user->username, users[i].username) == 0) {
    39.             if (strcmp(user->password, users[i].password) == 0) {
    40.                 strcpy(users[i].fifo, user->fifo);
    41.                 sprintf(response.message, "Login succeed!");
    42.                 printf("User %s login\n",user->username);
    43.                 response.ok = 0;
    44.                 break;
    45.             } else {
    46.                 sprintf(response.message, "Wrong password!");
    47.                 response.ok=-2;
    48.                 break;
    49.             }
    50.         }
    51.     }
    52.     if (response.ok == -1) {
    53.         sprintf(response.message, "Wrong username!");
    54.     }
    55.     int fd = open(user->fifo, O_RDWR | O_NONBLOCK);
    56.     write(fd, &response, sizeof(Response));
    57. }
    58.  
    59. void chatHandler(Chat*chat) {
    60.     char message[BuffSize];
    61.     int ok = -1;
    62.     for (int i = 0; i < userNumber; i++) {
    63.         if (strcmp(chat->targetUser, users[i].username) == 0) {
    64.             int fd = open(users[i].fifo, O_RDWR | O_NONBLOCK);
    65.             write(fd, chat->message, BuffSize);
    66.             sprintf(message, "Send succeed!");
    67.             ok = 0;
    68.             break;
    69.         }
    70.     }
    71.     if (ok == -1) {
    72.         sprintf(message, "User %s does not exit!", chat->targetUser);
    73.     }
    74.     int fd = open(chat->fifo, O_RDWR | O_NONBLOCK);
    75.     write(fd, message, BuffSize);
    76. }
    77.  
    78. int main() {
    79.     fd_set fds, read_fds; // 文件描述符集合
    80.     int max_fd;
    81.     int register_fd, login_fd, chat_fd;
    82.     // 创建或打开FIFO文件
    83.     mkfifo(Register_FIFO, 0777);
    84.     mkfifo(Login_FIFO, 0777);
    85.     mkfifo(Chat_FIFO, 0777);
    86.     // 打开FIFO文件 O_RDWR 可读写 O_NONBLOCK 非阻塞
    87.     register_fd = open(Register_FIFO, O_RDWR | O_NONBLOCK);
    88.     login_fd = open(Login_FIFO, O_RDWR | O_NONBLOCK);
    89.     chat_fd = open(Chat_FIFO, O_RDWR | O_NONBLOCK);
    90.     // 指定要检查的文件描述符
    91.     FD_ZERO(&fds);
    92.     FD_SET(register_fd, &fds);
    93.     FD_SET(login_fd, &fds);
    94.     FD_SET(chat_fd, &fds);
    95.     // 获取最大文件描述符
    96.     max_fd = register_fd > login_fd ? register_fd : login_fd;
    97.     max_fd = max_fd > chat_fd ? max_fd : chat_fd;
    98.     printf("MutiplexingServer Listening\n");
    99.     while (1) {
    100.         read_fds = fds;
    101.         User registerData;
    102.         User loginData;
    103.         Chat chatData;
    104.         // 使用select监听文件描述符
    105.         if (select(max_fd + 1, &read_fds, NULL, NULL, NULL) == -1) {
    106.             perror("select");
    107.             exit(EXIT_FAILURE);
    108.         }
    109.         // 检查哪些文件描述符已经准备好
    110.         if (FD_ISSET(register_fd, &read_fds)) {
    111.             // 处理注册
    112.             read(register_fd, &registerData, sizeof(User));
    113.             registerHandler(&registerData);
    114.         }
    115.         if (FD_ISSET(login_fd, &read_fds)) {
    116.             // 处理登录
    117.             read(login_fd, &loginData, sizeof(User));
    118.             loginHandler(&loginData);
    119.         }
    120.         if (FD_ISSET(chat_fd, &read_fds)) {
    121.             // 处理聊天
    122.             read(chat_fd, &chatData, sizeof(Chat));
    123.             chatHandler(&chatData);
    124.         }
    125.     }
    126. }

    mutiplexingClient

    1. #include<unistd.h>
    2. #include<stdio.h>
    3. #include <stdlib.h>
    4. #include<string.h>
    5. #include<sys/stat.h>
    6. #include<fcntl.h>
    7. #include"mutiplexing.h"
    8.  
    9. void showPage(User*user);
    10.  
    11. void registerClient(User*user){
    12.     int register_fd = open(Register_FIFO, O_RDWR | O_NONBLOCK);
    13.     write(register_fd, user, sizeof(User));
    14.     int fd=open(user->fifo,O_RDWR | O_NONBLOCK);
    15.     char message[BuffSize];
    16.     while(1){
    17.         int result= read(fd,message,BuffSize);
    18.         if(result>0){
    19.             printf("%s\n",message);
    20.             break;
    21.         }
    22.     }
    23.     showPage(user);
    24. }
    25. void chatClient(User*user){
    26.     char what;
    27.     printf("Chat Page:\npress r for receive | s for send | q for quit\n");
    28.     while((what=getchar())=='\n'){}
    29.     if (what == 'q') {
    30.         exit(0);
    31.     } else if(what =='s') { // 发送信息
    32.         Chat chat;
    33.         strcpy(chat.fifo,user->fifo);
    34.         printf("send username: ");
    35.         scanf("%s",chat.targetUser);
    36.         getchar();
    37.         printf("send data: ");
    38.         scanf("%[^\n]",chat.message);
    39.         int chat_fd=open(Chat_FIFO,O_RDWR | O_NONBLOCK);
    40.         write(chat_fd,&chat,sizeof(Chat));
    41.         // 等待服务器响应
    42.         int fd=open(user->fifo,O_RDWR | O_NONBLOCK);
    43.         char message[BuffSize];
    44.         while(1){
    45.             int result= read(fd,message,BuffSize);
    46.             if(result>0){
    47.                 printf("%s\n",message);
    48.                 break;
    49.             }
    50.         }
    51.     } else if(what=='r'){ //接收消息
    52.         int fd=open(user->fifo,O_RDWR | O_NONBLOCK);
    53.         char message[BuffSize];
    54.         while(1){
    55.             int result= read(fd,message,BuffSize);
    56.             if(result>0){
    57.                 printf("%s\n",message);
    58.                 break;
    59.             }
    60.         }
    61.     }else{
    62.         printf("Wrong press key, please try again!\n");
    63.     }
    64.     chatClient(user);
    65. }
    66. void loginClient(User*user){
    67.     int login_fd = open(Login_FIFO, O_RDWR | O_NONBLOCK);
    68.     write(login_fd, user, sizeof(User));
    69.     int fd=open(user->fifo,O_RDWR | O_NONBLOCK);
    70.     Response response;
    71.     while(1){
    72.         int result= read(fd,&response,sizeof(Response));
    73.         if(result>0){
    74.             printf("%s\n",response.message);
    75.             break;
    76.         }
    77.     }
    78.     if(response.ok!=0){ // 登录失败
    79.         showPage(user);
    80.     }else{
    81.         chatClient(user);
    82.     }
    83. }
    84.  
    85. void showPage(User*user){
    86.     char what;
    87.     printf("Chat Client:\npress r for register | l for login | q for quit\n");
    88.     while((what=getchar())=='\n'){}
    89.     if (what == 'q') {
    90.         exit(0);
    91.     } else if(what=='r'||what=='l') {
    92.         printf("username: ");
    93.         scanf("%s", user->username);
    94.         printf("password: ");
    95.         scanf("%s", user->password);
    96.     }else{
    97.         printf("Wrong press key, please try again!\n");
    98.         showPage(user);
    99.     }
    100.     if (what == 'r') {
    101.         registerClient(user);
    102.     }else if(what=='l'){
    103.         loginClient(user);
    104.     }
    105. }
    106. int main() {
    107.     User user;
    108.     sprintf(user.fifo, "client_fifo/client_fifo%d", getpid());
    109.     mkfifo(user.fifo, 0777);
    110.     showPage(&user);
    111.     exit(0);
    112. }

    mutiplexing

    1. #ifndef SYSTEMPROGRAM_MESSAGE_H
    2. #define SYSTEMPROGRAM_MESSAGE_H
    3. #define Register_FIFO "register_fifo" // 注册
    4. #define Login_FIFO "login_fifo"       // 登录
    5. #define Chat_FIFO "chat_fifo"         // 聊天
    6. #define BuffSize 100
    7. #define UserCapacity 10 // 可容纳用户量
    8. typedef struct {
    9.     char fifo[BuffSize]; //client's FIFO name
    10.     char username[20];
    11.     char password[20];
    12. } User;
    13. typedef struct {
    14.     char fifo[BuffSize]; //client's FIFO name
    15.     char targetUser[20]; // 向谁发送信息
    16.     char message[BuffSize];
    17. } Chat;
    18. typedef struct{
    19.    int ok;
    20.    char message[BuffSize];
    21. }Response;
    22. #endif //SYSTEMPROGRAM_MESSAGE_H
  • 相关阅读:
    【云原生】Kubernetes----轻量级的现代HTTP反向代理和负载均衡器之Traefik
    html - 如何在 html5 中居中画布
    JavaIO系列——字节缓冲流，对象流，序列化与反序列化
    C++的学习
    Ubuntu虚拟机使用桥接网络设置静态IP
    Alfred v5.1.2(Mac应用快速启动)
    ABB机器人常用指令功能说明
    Mysql 官方提供的公共测试数据集 Example Databases
    java毕业设计儿童教育系统Mybatis+系统+数据库+调试部署
    学习笔记：如何在 Vue 项目中使用 MQTT
  • 原文地址：https://blog.csdn.net/weixin_62264287/article/details/134279590