网络编程 8/15 基于UDP多人聊天室

于 2024-08-15 17:51:14 发布
阅读量26 收藏
点赞数
文章标签： 网络 udp 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Artorias_Ch/article/details/141228242
版权 
//客户端代码
#include <myhead.h>
struct msgType
{
    char type; // 消息类型L:登录，Q:退出，C:聊天
    char usrName[20];
    char msgText[1024];
};
#define SER_PORT 6666          // 服务器端口
#define SER_IP "192.168.2.161" // 服务器IP
int main(int argc, char const *argv[])
{
    int cfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (cfd == -1)
    {
        perror("socket error");
        return -1;
    }
    // 端口号快速重用
    int reuse = 1;
    if (setsockopt(cfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
    {
        perror("setsockopt error");
        return -1;
    }
    // 初始化服务器地址
    struct sockaddr_in sin;                  // 对端服务器地址结构体
    sin.sin_family = AF_INET;                // 协议族
    sin.sin_port = htons(SER_PORT);          // 端口号
    sin.sin_addr.s_addr = inet_addr(SER_IP); // IP地址
    socklen_t len = sizeof(sin);             // 地址长度

    struct msgType msg;
    msg.type = 'L';
    printf("请输入用户名：");
    fgets(msg.usrName, 20, stdin);
    msg.usrName[strlen(msg.usrName) - 1] = '\0';
    char temp[20]; // 将用户名保存起来
    strcpy(temp, msg.usrName);
    strcpy(msg.msgText, "");
    sendto(cfd, &msg, sizeof(msg), 0, (struct sockaddr *)&sin, len);

    // 创建子进程用于收消息
    pid_t pid = fork();
    if (pid == -1)
    {
        perror("fork error");
        return -1;
    }

    if (pid == 0)
    {
        // 子进程
        {
            while (1)
            {
                bzero(&msg, sizeof(msg));
                // 接收消息
                recvfrom(cfd, &msg, sizeof(msg), 0, NULL, NULL);
                switch (msg.type)
                {
                case 'L':
                    printf("%s\n", msg.msgText);
                    break;
                case 'Q':
                {
                    if (strcmp(temp, msg.usrName) == 0)
                    {
                        printf("退出成功\n");
                        exit(EXIT_SUCCESS);
                    }
                    printf("%s\n", msg.msgText);
                }
                break;
                case 'C':
                    printf("[%s]:%s\n", msg.usrName, msg.msgText);
                    break;
                }
            }
        }
    }
    else if (pid > 0)
    {
        // 父进程
        msg.type = 'C';
        while (1)
        {
            sleep(1);
            // 发送消息
            fgets(msg.msgText, 1024, stdin);
            msg.msgText[strlen(msg.msgText) - 1] = '\0';
            if (strcmp(msg.msgText, "q") == 0 || strcmp(msg.msgText, "Q") == 0)
            {
                msg.type = 'Q';
                sendto(cfd, &msg, sizeof(msg), 0, (struct sockaddr *)&sin, len);
                sleep(2);
                goto end;
            }

            sendto(cfd, &msg, sizeof(msg), 0, (struct sockaddr *)&sin, len);
        }
    }

end:
    kill(pid, SIGKILL);
    wait(NULL);
    close(cfd);

    return 0;
}

//服务器主代码
#include "head.h"
#define SER_PORT 6666          // 服务器端口
#define SER_IP "192.168.2.161" // 服务器IP
int main(int argc, char const *argv[])
{
    // 创建用于通信的服务器套接字文件描述符
    int sfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sfd == -1)
    {
        perror("socket error");
        return 1;
    }
    // 将端口号快速重启
    int reuse = 1;
    if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1)
    {
        perror("setsockopt error");
        return 1;
    }
    // 绑定服务器套接字
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(SER_PORT);
    sin.sin_addr.s_addr = inet_addr(SER_IP);
    if (bind(sfd, (struct sockaddr *)&sin, sizeof(sin)) == -1)
    {
        perror("bind error");
        return 1;
    }
    printf("服务器启动成功\n");
    // 创建链表
    NodePtr L = list_create();
    // 接收客户端发送的数据
    struct sockaddr_in cin;
    socklen_t len = sizeof(cin);
    struct msgType msg;
    bzero(&msg, sizeof(msg));
    while (1)
    {
        // 创建子进程
        pid_t pid = fork();
        // 接收客户端发送的数据
        if (pid == 0)
        {
            while (1)
            {
                // 接收信息
                recvfrom(sfd, &msg, sizeof(msg), 0, (struct sockaddr *)&cin, &len);
                switch (msg.type) // 判断信息类型
                {
                case 'L':
                {
                    list_insert(L, msg.usrName, &cin);
                    strcpy(msg.msgText, "欢迎您进入聊天室 开始聊天吧"); // 发送欢迎信息
                    sendto(sfd, &msg, sizeof(msg), 0, (struct sockaddr *)&cin, len);

                    strcpy(msg.msgText, "*******欢迎");
                    strcat(msg.msgText, msg.usrName);
                    strcat(msg.msgText, "进入聊天室*******");
                    NodePtr p = L->next;
                    while (p != NULL) // 发送所有人进入聊天室信息（除了刚进来的人 因为已经发了欢迎)
                    {

                        if (p->addr.sin_port == cin.sin_port)
                        {
                            p = p->next;
                            continue;
                        }
                        if (p == NULL)
                        {
                            break;
                        }
                        sendto(sfd, &msg, sizeof(msg), 0, (struct sockaddr *)&p->addr, len);
                        p = p->next;
                    }
                }
                break;
                case 'C':
                {
                    printf("[%s]:%s\n", msg.usrName, msg.msgText); // 先在终端展示
                    for (NodePtr p = L->next; p != NULL; p = p->next)
                    {
                        sendto(sfd, &msg, sizeof(msg), 0, (struct sockaddr *)&p->addr, len);
                    }
                    printf("发送成功\n");
                }
                break;
                case 'Q':
                {
                    strcpy(msg.msgText, "*********");
                    strcat(msg.msgText, msg.usrName);
                    strcat(msg.msgText, "退出聊天室*********");
                    for (NodePtr p = L->next; p != NULL; p = p->next)
                    {
                        sendto(sfd, &msg, sizeof(msg), 0, (struct sockaddr *)&p->addr, len);
                    }
                    sleep(1);
                    list_delete(L, msg.usrName);
                }
                break;
                }
            }
        }
        else if (pid > 0)
        {
            // 发送数据给客户端

            while (1)
            {
                msg.type = 'C';
                strcpy(msg.usrName, "GM");
                fgets(msg.msgText, sizeof(msg.msgText), stdin);
                msg.msgText[strlen(msg.msgText) - 1] = '\0';
                sendto(sfd, &msg, sizeof(msg), 0, (struct sockaddr *)&sin, len);
                if (strcmp(msg.msgText, "exit") == 0)
                {
                    goto end;
                }
            }
        }
        else if (pid < 0)
        {
            perror("fork error");
            return 1;
        }
    end:
        kill(pid, SIGKILL);
        list_destroy(L);
        close(sfd);
        wait(NULL);
        return 0;
    }
}
//头文件
#include <myhead.h>
#ifndef __HEAD_H__
#define __HEAD_H__
// 定义结构体

typedef struct Node
{

    union
    {
        int len;       // 节点长度
        char name[20]; // 节点名称
    };
    struct sockaddr_in addr; // 地址信息结构体
    struct Node *next;       // 指向下一个节点
} Node, *NodePtr;

struct msgType
{
    char type;          // 消息类型 L:登录，C:聊天，Q；退出
    char usrName[20];   // 姓名
    char msgText[1024]; // 消息
};
// 创建链表
NodePtr list_create();
// 申请封装节点函数
NodePtr apply_node(char *name, struct sockaddr_in *addr);
// 链表判空
int list_empty(NodePtr L);
// 链表插入
int list_insert(NodePtr L, char *name, struct sockaddr_in *addr);


// 按名字找位置函数
int list_search_name(NodePtr L, char *name);
// 任意位置查找节点
NodePtr list_search_pos(NodePtr L, int pos);
// 任意位置删
int list_delete(NodePtr L, char *name);

// 链表销毁
void list_destroy(NodePtr L);

#endif

//函数文件
#include "head.h"
// 创建链表
NodePtr list_create()
{
    // 申请头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if (NULL == L)
    {
        printf("创建失败\n");
        return NULL;
    }
    // 赋值
    L->len = 0;
    L->next = NULL;
    printf("聊天室创建成功\n");
    return L;
}
// 申请封装节点函数
NodePtr apply_node(char *name, struct sockaddr_in *addr)
{
    // 申请空间
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if (NULL == p)
    {
        printf("申请失败\n");
        return NULL;
    }
    // 赋值
    strcpy(p->name, name);
    p->addr.sin_family = addr->sin_family;
    p->addr.sin_port = addr->sin_port;
    p->addr.sin_addr.s_addr = addr->sin_addr.s_addr;
    p->next = NULL;
    
    return p;
}
// 链表判空
int list_empty(NodePtr L)
{   
    return L->next == NULL;
}
// 链表插入
int list_insert(NodePtr L, char *name, struct sockaddr_in *addr)
{
    // 判断逻辑
    if (NULL == L)
    {
        return -1;
    }
    
    // 申请节点
    NodePtr p = apply_node(name, addr);
    if (NULL == p)
    {
        return -1;
    }
    // 插入逻辑
    p->next = L->next;
    L->next = p;
    printf("*********%s进入聊天室*********\n", p->name);
    L->len++;
    return 0;
}
// 按名字找位置函数
int list_search_name(NodePtr L, char *name)
{
    // 判断逻辑
    if (NULL == L || list_empty(L))
    {
        return -1;
    }
    // 遍历逻辑
    NodePtr q = L->next;
    for (int index = 1;index<=L->len; index++)
    {
        if(strcmp(q->name, name) == 0)
        {
            return index;
            
        }
        q = q->next;
    }
    printf("未找到该用户\n");
    return -1;
}
// 任意位置查找节点
NodePtr list_search_pos(NodePtr L, int pos)
{
    if (NULL == L || list_empty(L) || pos < 0 || pos > L->len)
    {
        return NULL;
    }
    //查找逻辑
    //定义指针从头结点出发
    NodePtr q = L;
    for (int i = 0; i < pos; i++)
    {
        q = q->next;
    }
    return q; //返回找到的节点
}
// 任意明治删
int list_delete(NodePtr L, char *name)
{
    // 判断逻辑)
    if (NULL == L || list_empty(L))
    {
        return -1;
    }
    // 找到前一个节点
    int pos = list_search_name(L, name);
    NodePtr q = list_search_pos(L, pos-1);
    // 删除逻辑
    NodePtr p = q->next;
    q->next = p->next;
    // 释放空间
    free(p);
    p = NULL;
    printf("*********%s退出聊天室*********\n", name);
    return 0;
}

// 链表销毁
void list_destroy(NodePtr L)
{
    // 判断逻辑
    if (NULL == L)
    {
        return;
    }
    // 遍历逻辑
    while (!list_empty(L))
    {
        list_delete(L, L->next->name);
    }
    // 释放头结点
    free(L);
    L = NULL;
}

_shenash
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux c 基于UDP实现简单的多人聊天室
RED_STARRR的博客
01-11 3374
1.数据报格式套接字 数据报格式套接字(代码为SOCK_DGRAM)，采用此方法计算机只管发送数据而不去验证发送数据的正确性，不论传输是否被接收，数据流是否有丢失，都不再重新发送，特征如下： 1.强调快速传输而非传输顺序； 2.传输的数据可能丢失也可能损毁； 3.限制每次传输的数据大小； 4.数据的发送和接收是并发的。 总之，数据报套接字是一种不可靠的、不按顺序传递的、以追求速度为目的的套接字。 以上总结于套接字有哪些类型？socket有哪些类型？ 2.采用UDP协议 而数据报套接字采
【Linux网络编程】基于UDP实现多人聊天室
m0_65835264的博客
08-21 3357
基于UDP实现的多人聊天室，内附详细的服务器和客户端的思路步骤和代码实现。以及个个模块的实现。最后附上源代码给大家借鉴参考，希望对大家有所帮助。 代码中可能有许多不规范的地方，逻辑可能并不严谨，还请各位大佬不吝赐教。 整体项目并不复杂，只需要想清楚service和client分别需要做什么事。画好流程图，就会很清晰的将思路缕顺。从而只需要模块化的完成相应代码即可。
UDP多人聊天室
嵌入式小企鹅的博客
09-14 457
项目目标：实现一个简单的多人聊天室，利用UDP协议进行消息传输，允许多个用户同时连接和交流。技术实现：采用UDP协议作为通信协议，使用套接字编程实现客户端和服务器之间的连接和通信。通过并发处理实现多个客户端的并发处理。功能特点：实现了基本的聊天室功能，包括用户登录、消息发送和接收，以及用户退出。支持多个用户同时在线，消息广播给所有在线用户。数据结构：使用数据结构存储用户信息和消息缓冲区，使用链表存储用户的ip地址和对应的端口号。
python socket基于TCP/IP协议实现多人聊天室
阿狸的博客
08-13 8743
文章目录前言一、实现原理二、queue队列三、代码实现四、需要注意的地方五、总结 前言 所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议根进行交互的接口。 socket 位于网络层以及传输层之间,它提供了三种类型的传输： 流套接字(SOCK_STREAM) 数据报套接字(S
Java网络编程——基于UDP协议的聊天室
qq_52223733的博客
07-16 2609
UDP（User Datagram Protocol）协议是Internet 协议集支持的一个无连接的传输协议，中文名为用户数据报协议。它为应用程序提供了一种无需建立连接就可以发送封装的 IP 数据报的方法。    Internet 的传输层有两个主要协议，互为补充。无连接的是 UDP，它除了给应用程序发送数据包功能并允许它们在所需的层次上架构自己的协议之外，几乎没有做什么特别的事情。面向连接的是TCP，该协议几乎做了所有的事情。“when in trouble ， use TCP”。...
Python多人聊天室-基于socket UDP协议
Hmily的博客
02-20 3240
使用Python编写的基于socket UDP通信的多功能即时聊天室，包含Tkinter编写的图形化聊天界面，功能包括有账号注册和登录，登录成功后可以查看在线用户，并和聊天室内的其他在线用户聊天，包含私聊和群发，能发送文字、表情包，以及文件等。
基于UDP的简易多人聊天室
qq_52004668的博客
10-27 884
基于UDP的简易多人聊天室
【Socket 编程】基于UDP协议建立多人聊天室
稻草人敲代码的博客
07-19 514
对于服务端来说，除了要接收消息之外，还要实现一个路由转发模块，该路由转发模块可以将相应发送给所有连接的客户端。而对于客户端来说，除了要发送消息给聊天室，还要能实时看到其它所有客户端的消息。下面来看看具体实现的代码，代码只给出核心模块，其余代码模块代码可以借鉴我之前的博客。具体来说，服务器类实现的功能只有收消息。
网络编程项目—— 多人聊天室-＞双人聊天
qq_44886213的博客
10-30 1068
我认为应该用TCP，因为聊天内容和视频不一样，视频在路上丢失几个帧看不出来，但是用户A打出的字必须让用户B能完完整整收到，所以连接必须可靠。在实际开发中，应该是程序中只有一个User类，各个用户在自己主机上把.exe下载下来，用这个User类生成一个User对象。1. 又开始思考这个问题，拿到一个需求，是调用java底层的代码写1000行实现，还是直接调第三方库写50行实现？但是在本次模拟中，我们直接用多个User类代表多台主机，但每个类的代码是一模一样的。2. 应该用传输层协议还是用应用层协议实现呢？
实验三socket编程代码.rar_socket编程_tcp/udp_一对多聊天_多人聊天室_计算机网络实验
09-25
我们将深入理解TCP和UDP这两种传输层协议，并通过具体的代码实现一对多聊天和多人聊天室功能。 首先，TCP（Transmission Control Protocol）是一种面向连接、可靠的协议，它确保了数据的顺序传输和错误检查。在TCP ...
利用UDP的网络编程练习多人聊天室
05-14
利用UDP的网络编程练习多人聊天室
java udp多人聊天室
06-12
Java UDP多人聊天室是一个利用Java语言和用户数据报协议（UDP）开发的多用户交互系统。UDP是一种无连接的、不可靠的传输协议，适用于实时通信和对速度要求较高的场景，因为它无需建立连接，直接发送数据包，减少了...
TCP/UDP网络聊天室.zip
05-28
【TCP/UDP网络聊天室】项目是一个基于Java Swing开发的网络通信应用，旨在模拟企鹅聊天软件的功能，提供一对一、一对多以及多对多的聊天模式。该项目利用TCP和UDP两种传输层协议来实现不同场景下的数据交换，充分...
多进程多人聊天室，运用udp协议socket网络编程
03-28
本项目“多进程多人聊天室，运用udp协议socket网络编程”就是基于UDP的socket编程实现了一个支持多人聊天的平台，管理员还具有群发消息的能力。下面将详细解释这个项目所涉及的知识点。 首先，我们需要理解**UDP...
计算机网络面试题汇总
最新发布
Blocking The Sky
08-14 594
数字证书是指在互联网通讯中标志通讯各方身份信息的一个数字认证，人们可以在网上用它来识别对方的身份。它的出现，是为了避免身份被篡改冒充的。比如Https的数字证书，就是为了避免公钥被中间人冒充篡改。数字证书构成公钥和个人等信息，经过Hash摘要算法加密，形成消息摘要；将消息摘要拿到拥有公信力的认证中心（CA），用它的私钥对消息摘要加密，形成数字签名。公钥和个人信息、数字签名共同构成数字证书。
使用WebSocket实现一个简易的聊天室
qq_51321722的博客
08-14 299
其次，要有相关配置类以及Controller。我这里的框架是SpringBoot。首先，我们要有一个前端页面。
HAProxy基本配置及参数实操
Webston的博客
08-12 916
静态#动态#以下静态和动态取决于hash_type 是否consistentfirst #使用较少static-rr #做了session 共享的web集群leastconn #数据库source#基于客户端公网IP 的会话保持Uri--------------->http #缓存服务器，CDN服务商，蓝汛、百度、阿里云、腾讯url_param--------->http #可以实现session 保持hdr #基于客户端请求报文头部做下一步处理高。
mpls vpn基础实验
wudongfang666的专栏
08-10 489
场景：异地两个站点通过mpls vpn骨干网络实现安全通讯虚拟路由转发 VRF ，相当于在设备内建立一条虚拟通道，一个vpn的实例（vrf）可以简单的理解为一台虚拟设备。拓扑图。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值