用select多路io复用实现简单聊天程序

最新推荐文章于 2023-07-30 16:07:34 发布
最新推荐文章于 2023-07-30 16:07:34 发布
阅读量347 收藏 2
点赞数 1
分类专栏： linux网络编程 综合实践 文章标签： linux 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60292931/article/details/125789614
版权

文章目录

1、服务端

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

#define PORT 2233  //端口号
#define MAX_CLI 32 //系统能容纳的客户数


/*记录客户信息*/
struct client_info{
    char msg[1024];
    char c_name[64];//客户名字
    char s_name[64];//私聊客户名字
    int fd;//新连接描述符
    struct sockaddr_in client;//其IP地址
};
/*记录客户发来信息*/
struct client_recvinfo{
    char msg[1024];
    char c_name[64];//客户名字
    char s_name[64];//私聊客户名字
};
struct client_info bak_cli[MAX_CLI];//备份用户信息
/*将发送过来的信息保存*/
struct client_info  copy_recv(struct client_info bak,const struct client_recvinfo new){
    strncpy(bak.msg,new.msg, strlen(new.msg));
    strncpy(bak.c_name,new.c_name, strlen(new.c_name));
    strncpy(bak.s_name,new.s_name, strlen(new.s_name));
    return bak;
}

/*打包要发送的信息*/
void buf_send(char* buf,const struct client_recvinfo new){

    if(strcmp(new.s_name,"all")==0){
        strcat(buf,"\033[31m");
        strcat(buf,new.c_name);
        strcat(buf,"\033[0m");
        strcat(buf,"(群发)");
        strcat(buf,": ");
        strcat(buf,new.msg);
        //printf("\n==pu==\n");
    }
    else{
        strcat(buf,"\033[31m");
        strcat(buf,new.c_name);
        strcat(buf,"\033[0m");
        strcat(buf,"(私发)");
        strcat(buf,": ");
        strcat(buf,new.msg);
        //printf("\n==pr==\n");
    }
}

//向所有在线用户发送在线的用户列表
void send_oname(){
    char on_names[1024];
    long ret;
    //记录在线的用户列表
    memset(&on_names,0, sizeof(on_names));
    strcat(on_names,"当前在线用户: ");
    for(int i =0;i<MAX_CLI;i++){
        if(bak_cli[i].fd!=0){
            strcat(on_names,"[");
            strcat(on_names,bak_cli[i].c_name);
            strcat(on_names,"] ");
        }
    }
    //printf("=%s=\n",on_names);

    //向所有在线用户发送
    for(int i = 0;i<MAX_CLI;i++){
        if(bak_cli[i].fd!=0) {
            ret = send(bak_cli[i].fd, &on_names, strlen(on_names), 0);
            if (ret < 0) {
                perror("send name");
            }
        }
    }
}

/*初始化服务器*/
int init_tcp_server(unsigned short port){
    int listen_fd;
    int ret;
    int opt;
    struct sockaddr_in self;

    //监听描述符
    listen_fd = socket(AF_INET,SOCK_STREAM,0);
    if(listen_fd < 0){
        perror("socket");
        return -1;
    }

    // 配置监听描述符地址复用属性
    opt = 1;
    ret = setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR,&opt, sizeof(opt));
    if (ret < 0) {
        perror("set socket opt");
        return -1;
    }

    // 填充服务器开放接口和端口号信息
    memset(&self,0, sizeof(self));
    self.sin_family = AF_INET;
    self.sin_port = htons(port);
    self.sin_addr.s_addr = htonl(INADDR_ANY);

    //将self与listen_fd绑定
    ret = bind(listen_fd,(struct sockaddr *)&self, sizeof(self));
    if(ret<0){
        perror("bind");
        return  -1;
    }

    // 默认socket是双向，配置成监听模式
    listen(listen_fd, 5);

    return listen_fd;
}
/*与客户端建立连接，并保存登陆信息*/
struct client_info  listen_hander(int fd){
    long ret;
    struct  client_info new;
    struct client_recvinfo name;

    memset(&new,0, sizeof(new));
   unsigned int len = sizeof(new.client);
    //监听描述符
    new.fd= accept(fd,(struct sockaddr *) &(new.client),&len);
    if(new.fd<0){
        perror("accept");
    }

    //接收新的用户名
    ret = recv(new.fd,&name, sizeof(name),0);
    if(ret<0){
        perror("recv name");
    }
    //检测是否同名
    for(int i=0;i<MAX_CLI;i++) {
        if (strcmp(bak_cli[i].c_name, name.c_name) == 0) {
            ret = send(new.fd, "repetitive name", 15, 0);
            if (ret < 0) {
                perror("send repetitive name");
            }
            ret = -1;//用于下个循环判断是否重名
            close(new.fd);
            memset(&new, 0, sizeof(new));
            memset(&name, 0, sizeof(name));
            break;
        }
    }
    //保存新连接用户信息
    for(int i=0;i<MAX_CLI;i++) {
        if(ret < 0){
            break;
        }
        else if(bak_cli[i].fd==0){
            bak_cli[i] = copy_recv(new,name);

            //每上线一个用户就更新在线用户列表
            send_oname();

            printf("\033[32m%s\033[0m  %s:%d \033[32m online\033[0m\n",name.c_name,
                   inet_ntoa(new.client.sin_addr), ntohs(new.client.sin_port));
            break;
        }
    }

    return  new;
}

/*接收客户端数据并处理*/
int data_hander(int new_fd){

    struct client_recvinfo new;
    long ret;
    char buf[2048];
    int w_name = 1; //判断私发用户是否存在

    memset(&new,0, sizeof(new));
    ret = recv(new_fd, &new, sizeof(new), 0);
    if (ret < 0) {
        perror("recv");
        return -1;
    } else if (ret == 0) {
        //清理退出的用户
        for(int i =0;i<MAX_CLI;i++){
            if(bak_cli[i].fd==new_fd) {

                printf("\033[32m%s\033[0m  %s:%d \033[32m offline\033[0m\n",
                       bak_cli[i].c_name,
                       inet_ntoa(bak_cli[i].client.sin_addr),
                       ntohs(bak_cli[i].client.sin_port));

                memset(&bak_cli[i], 0, sizeof(bak_cli[i]));
                //每下线一个用户就更新在线用户列表
                send_oname();
            }

        }


        return 0;
    }
    else {
        // 打印消息

        //找到当前用户的备份信息
        for (int j = 0; j < MAX_CLI; j++) {
            if (bak_cli[j].fd == new_fd) {
                bak_cli[j] = copy_recv(bak_cli[j], new);
            }
        }
        //分析接收的消息并处理
        for (int i = 31; i >= 0; i--) {
            //群发
            if (strcmp(new.s_name,"all")==0) {
                if (new_fd != bak_cli[i].fd&&bak_cli[i].fd != 0) {
                    memset(&buf,0, sizeof(buf));
                    buf_send(buf, new);
                    ret = send(bak_cli[i].fd, buf, strlen(buf), 0);
                    if (ret < 0) {
                        perror("public send");
                    }
                    printf(" (群)%s send %s to %s\n",
                           new.c_name, new.msg, bak_cli[i].c_name);
                    w_name = 0;
                }
            }
                //私发
            else if (strcmp(new.s_name,
                            bak_cli[i].c_name) == 0) {
                memset(&buf,0, sizeof(buf));
                buf_send(buf, new);
                ret = send(bak_cli[i].fd, buf, strlen(buf), 0);
                if (ret < 0) {
                    perror("private send");
                }
                printf(" (私)%s send %s to %s\n",
                       new.c_name, new.msg, bak_cli[i].c_name);
                w_name = 0;
                break;
            }
        }

        if(w_name){
            ret = send(new_fd,"404",3, 0);
            if (ret < 0) {
                perror("send 404");
            }
            printf("%s send %s to %s failed！\n",
                   new.c_name, new.msg, new.s_name);
        }
        //回应收到了消息
//         ret = send(new_fd,"server: msg recv",16,0);
//         if(ret < 0){
//             perror("answer");
//         }
    }

    return (int)ret;
}

void main_loop(int listen_fd){
    fd_set set,bak_set;
    int max_fds;
    int ret;
    struct  client_info new;

    // 把监听描述符、标准输入描述符添加到集合
    FD_ZERO(&set);
    FD_SET(listen_fd,&set);
    FD_SET(0,&set);
    max_fds = listen_fd;


    while(1){
        bak_set = set;
        ret = select(max_fds+1,&bak_set,NULL,NULL,NULL);
        if(ret < 0){
            perror("select");
            break;
        }

        for(int i = 0;i<=max_fds;i++){
            if(FD_ISSET(i,&bak_set)){
                if(i == 0){
                    // 标准输入可读 fgets
                    continue;
                }
                else if(i == listen_fd){
                    // 监听描述符可读  accept
                    memset(&new,0, sizeof(new));
                    new = listen_hander(i);
                    if(new.fd<0||new.fd==0){
                        fprintf(stderr, "listen handler error!\n");
                        continue;
                    }
                    FD_SET(new.fd, &set);
                    max_fds = new.fd > max_fds ? new.fd : max_fds;
                }
                else{
                    // 新的连接描述符可读  recv
                    ret = data_hander(i);
                    if (ret <= 0) {
                        // 收尾处理
                        close(i);
                        FD_CLR(i, &set);
                    }
                }
            }
        }
    }
}

int main(){
    int listen_fd;
    listen_fd = init_tcp_server(PORT);
    if (listen_fd < 0) {
        fprintf(stderr, "init tcp server failed!\n");
        return -1;
    }
    printf("listening...\n");

    main_loop(listen_fd);
    close(listen_fd);
    return 0;
}

2、客户端

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

static  short PORT = 2233;
static  char *HOST = "192.168.200.134";

/*打包要发送的信息*/
struct send_info{
    char msg[1024];
    char c_name[64];//客户名字
    char s_name[64];//私聊客户名字

};

static struct send_info msg;
static  char cname[64];
/*初始化*/
int inti_tcp_client(const char *host,unsigned short  port){
    int scoket_server;
    int ret;
    struct sockaddr_in dest;

    scoket_server = socket(AF_INET, SOCK_STREAM, 0);
    if(scoket_server < 0){
        perror("socket");
        return -1;
    }

    memset(&dest,0, sizeof(dest));
    dest.sin_family = AF_INET;
    dest.sin_port = htons(port);
    dest.sin_addr.s_addr = inet_addr(host);

    ret = connect(scoket_server, (struct sockaddr *)&dest, sizeof(dest));
    if(ret < 0){
        perror("connect");
        return -1;
    }
    return scoket_server;
}

/*记录用户名称，并接收服务器在线的用户*/
int set_name(int scoket_server) {
    char buf[1024];
    long ret;

    // 保存登陆名并发给服务器
    memset(&msg,0, sizeof(msg));
    strcat(msg.c_name,cname);


    ret = send(scoket_server,&msg, sizeof(msg),0);
    if(ret<0){
        perror("send");
        return -1;
    }
    //打印连接信息
    memset(&buf,0, sizeof(buf));
    ret = recv(scoket_server, &buf, sizeof(buf)-1, 0);
    //buf[strlen(buf)] = 0;
    if (ret > 0) {
        if(strncmp(buf,"repetitive name\n",15)==0){
            printf("名称重复！\n");
            exit(0);
        }
        else {
            printf("成功连接到主机:  %d!\t", PORT);
            printf("%s\n", buf); //打印在线的用户
        }

    }
    return 0;
}

/*接收服务器的消息*/
void recv_hander(int client_fd){
    char buf[1024];
    long ret;
    memset(buf,0, sizeof(buf));

    while (1){
        ret = recv(client_fd, &buf, sizeof(buf)-1, 0);
        if (ret < 0) {
            perror("recv hander");
            break;
        }
        else if(ret == 0){
            printf("服务器崩了！！！！\n");
            break;
        }
        if(strncmp(buf,"404",3)==0){
            printf("\033[31m服务器\033[0m: 找不到该用户！\n");
        }
        else{
            printf("%s\n", buf);
        }
        memset(buf,0, sizeof(buf));
    }
}

/*打包消息并发给服务器*/
void send_hander(int client_fd){
    int type;
    long ret;

    while(1){
        usleep(1000);
        printf("请输入聊天方式(1 群聊，0私聊):\n");
        scanf("%d",&type);
        fgets(msg.msg, sizeof(msg.msg), stdin);//清除stdin的内容
        if(type){
            printf("请输入聊天信息:\n");
            memset(&msg,0, sizeof(msg));
            fgets(msg.msg, sizeof(msg.msg), stdin);//要发送的信息
            msg.msg[strlen(msg.msg)-1] = 0;
            strcat(msg.s_name,"all");//要发送的对象
            strcat(msg.c_name,cname);//用户姓名
        }
        else{
            printf("请输入接收方姓名:\n");
            memset(&msg,0, sizeof(msg));
            fgets(msg.s_name, sizeof(msg.s_name), stdin);
            msg.s_name[strlen(msg.s_name)-1] = 0;
            printf("请输入聊天信息:\n");
            fgets(msg.msg, sizeof(msg.msg), stdin);
            msg.msg[strlen(msg.msg)-1] = 0;
            strcat(msg.c_name,cname);

        }
        ret = send(client_fd,&msg, sizeof(msg),0);
        if(ret<0){
            perror("send");
            break;
        }
    }
}

int main(){

    int client_socket;
    //记录登陆名
    printf("请输入你的名字:\t");
    fgets(cname, sizeof(cname), stdin);
    cname[strlen(cname)-1]=0;

    client_socket = inti_tcp_client(HOST,PORT);
    if (client_socket < 0) {
        fprintf(stderr, "init tcp client failed!\n");
        return -1;
    }
    set_name(client_socket);

    pid_t pid;
    pid = fork();

    if (pid < 0) {
        perror("fork");
    } else if (pid == 0) {
        recv_hander(client_socket);
        close(client_socket);
        exit(0);
    } else {
        send_hander(client_socket);
        close(client_socket);
        kill(pid,9); //关闭接收子进程，准备退出
        wait(NULL);
    }
    return  0;
}

3、测试截图

在这里插入图片描述

之前做的，没有优化，写的有点混乱，但基本实现了群聊和私聊

z呀哈哈z
关注
专栏目录
利用select函数实现聊天室程序
博客
10-24 936
要求 利用select函数实现在Linux环境下实现一个聊天室程序，要求： 用户默认处于广播模式，一个客户在其客户端发送的消息，其它客户端用户全部可以收到； 程序支持下列命令 /help:显示帮助信息（思考：信息是放在客户端还是服务器端）； /quit:用户退出聊天室，同时将退出信息广播给其他用户； /who:显示在线用户； /send 用户名 消息：向指定用户发送点到点消息 程序退出时清理所有...
select I/O 多路复用实现服务器聊天室功能
鹰击长空
04-25 2559
基本概念　IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合：　　（1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。　　（2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。　　（3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。　　（4）如果一个服务器即
linux多人 聊天程序,linux下简单的聊天程序（多路复用I/O）
weixin_28972687的博客
05-15 268
#include #define MAX_BUF_SIZE 1024int main(int argc, char *argv[]){int sockfd;int sin_size;struct sockaddr_in dest;char buf[MAX_BUF_SIZE + 1];fd_set rfds;struct timeval tv;int retval, maxfd = -1;if (a...
Linux Linux程序练习十二（select实现QQ群聊）
weixin_33670786的博客
09-25 113
//头文件--helper.h #ifndef _vzhang #define _vzhang #ifdef __cplusplus extern "C" { #endif #define MAX_SOCKET_NUM 1024 #define BUF_SIZE 1024 //server create socket int server_socket(int ...
C++ select模型简单聊天室
田螺姑娘的博客
04-13 920
C++ select模型简单聊天室 TIPS：以下使用CMake项目进行开发。关于何为CMake，链接：https://blog.csdn.net/qq135595696/article/details/124052273 简单聊天室效果展示 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bDMBn3Ri-1649842308734)(https://audioandvideo.ufgnix0802.cn/resources/%E5%9F%BA%E4%BA%8Eselec
windows下多路复用IO（select,WSAAsyncSelect,WSAEventSelect）
11-17
本篇文章将深入探讨三种在Windows环境下实现多路复用I/O的主要方法：`select`、`WSAAsyncSelect`和`WSAEventSelect`。 ### 1. `select`函数 `select`是跨平台的I/O多路复用机制，不仅在Windows中可用，也在大多数...
IO多路复用之select全面总结(必看篇)
01-10
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： （1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 （2）当一个客户...
IO多路复用之epoll全面总结(必看篇)
09-15
在Linux系统中，epoll是针对IO多路复用的一种高效实现，尤其适用于大规模并发连接的场景。以下是关于epoll的详细总结： 1. **基本概念** - **epoll** 是在Linux 2.6内核引入的，是对早期的`select`和`poll`函数的...
详解Python IO口多路复用
12-17
在Python中，可以使用select模odule来实现I/O多路复用，如select.select()函数，以及更高效的选择器epoll（在selectors模块中）。这样，服务器就可以有效地处理大量并发连接，提高服务效率和响应速度。
基于TCP协议分别使用多线程、IO 多路复用的方法实现多人聊天室（python）.zip
最新发布
01-19
这个项目名为“基于TCP协议分别使用多线程、IO 多路复用的方法实现多人聊天室（python）”，它深入探讨了Python中如何利用这两种并发模型来处理多个客户端连接，从而创建一个高效的多人聊天平台。下面我们将详细探讨...
用IO多路复用之select与poll/epoll来浅谈网络聊天室
weixin_53272394的博客
09-04 348
IO多路复用： IO多路复用模型是建立在内核提供的多路分离函数select基础之上的，使用select函数可以避免同步非阻塞IO模型中轮询等待的问题。 select 该函数用于监视文件描述符的变化情况–读写或是异常 参数： nfds: 通常被设置为select所监听的所有文件描述符中的最大值+1 指定被监听的文件描述符的总数 文件描述符从0开始 fd_set: 文件描述符集合 fd_set结构体仅包含一个整数数组，该数组的每个元素的每一位(bit) 标记一个文件描述符
网络编程 IO多路复用 [select版] (TCP网络聊天室)
Hellomino_的博客
07-30 820
网络编程 IO多路复用 [select版] (TCP网络聊天室) //head.h 头文件。//TcpGrpSer.c 服务器端。//TcpGrpUsr.c 客户端。
select函数实现三人聊天程序
mykelia的专栏
03-29 582
函数原型： #include int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); select调用用于测试文件描述符集合中，是否有一个文件描述符处于可读可写或者错误状态，它将阻塞以等待某个文件描述符进入上述状态。 nfds是三个文件描述符集
IO 多路复用
you_fathe的博客
08-16 422
Io多路复用和事件通知机制
多路io复用 select
m0_59270003的博客
11-19 159
多路io复用 select
利用select异步I/O模型实现群聊
ChenYitian
03-20 1775
之前所有写的socket程序都是“同步阻塞”的，这里的“同步”是指，应用中的函数调用与相应的操作系统内核中的函数是同步的，“阻塞”指的是当accept，recv，send等函数还没有确认/接收/发送时，相应的线程处于等待状态，无法继续往下执行。 “同步阻塞”虽然易于理解与实现，但是是一种效率很低的模式，因为当阻塞的时候，这个线程是不能干任何事情的，因此，“异步非阻塞”是一种效率更高的方式。 利
linux系统编程，多路IO，select实现群聊
m0_52041679的博客
04-26 137
linux系统编程，多路IO，select实现群聊
使用select.select编写聊天室服务器 《Python网络编程攻略》
zhou8201的博客
03-08 1130
# 现实中，大型网络服务器可能要处理几百或几千个客户端同时连接的请求，此时为每个客户端创建单独的线程或进程可能不实际。因为主机的内存可用量和CPU的能力皆有限制。 要处理大量客户端的连接需要更好的技术，那就是Python提供的select模块。 selectselect最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()
Linux网络编程 - 基于 I/O 复用的服务器端(select 实现)
yunfan
01-12 1619
本文中我们将讨论并发服务器的第二种实现方法——基于I/O复用（Multi-plexing）的服务器端构建，并通过 select 函数实现 I/O 复用服务器端。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值