网络编程基础项目二：UDP聊天室

于 2024-09-13 22:41:10 发布
阅读量502 收藏 16
点赞数 15
文章标签： 网络 udp 网络协议 服务器 linux 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QR70892/article/details/142232166
版权

目录

项目功能介绍

问题思考

补充参考函数 

程序流程图

服务器

客户端

代码流程

代码

服务器

客户端

 总结

项目功能介绍

利用UDP协议，实现一套聊天室软件。服务器端记录客户端的地址，客户端发送消息后，服务器群发给各个客户端软件。

问题思考

 ● 客户端会不会知道其它客户端地址？

不知道，服务器完成，服务器存储连接的客户端信息---》链表

● 有几种消息类型？

        登录

        聊天

        退出

● 客户端如何同时处理发送和接收？

客户端不仅需要读取服务器消息，而且需要发送消息。读取需要调用recvfrom，发送需要先调用fgets，两个都是阻塞函数。所以必须使用多任务来同时处理，可以使用多进程或者多线程来处理。

补充参考函数 

链表节点结构体：

struct node{

struct sockaddr_in addr;//data memcmp

struct node *next;

};

消息对应的结构体(同一个协议)

typedef struct msg_t

{

int type;//'L' C Q enum un{login,chat,quit};

char name[32];//用户名

char text[128];//消息正文

}MSG_t;

int memcmp(void *s1,void *s2,int size);//对比       相等时返回值为0

程序流程图

服务器

客户端

代码流程

代码

服务器

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <dirent.h>
#include <sys/stat.h>
#include <signal.h>
#include <pthread.h>

enum type_t
{
    login,
    chat,
    quit,
};

// 消息对应的结构体
typedef struct msg_t
{
    int type;
    char name[32];
    char text[128];
} MSG_t;

// 链表
typedef struct node
{
    struct sockaddr_in addr;
    struct node *next;
} node_t, *node_p;

// 登录
void Login(int sockfd, MSG_t msg, node_p p, struct sockaddr_in caddr)
{
    sprintf(msg.text, "%s %s", msg.name, "已登录！！！");
    while (p->next != NULL)
    {
        p = p->next;
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&(p->addr), sizeof(p->addr));
    }
    node_p pnew = (node_p)malloc(sizeof(node_t));
    if (NULL == pnew)
    {
        perror("p malloc err");
        return;
    }
    pnew->addr = caddr;
    pnew->next = NULL;
    p->next = pnew;
}

// 聊天
void Chat(int sockfd, MSG_t msg, node_p p, struct sockaddr_in caddr)
{
    while (p->next != NULL)
    {
        p = p->next;
        if (memcmp(&(p->addr), &caddr, sizeof(caddr)))
        {
            sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&(p->addr), sizeof(p->addr));
        }
    }
}

// 退出
void Quit(int sockfd, MSG_t msg, node_p p, struct sockaddr_in caddr)
{
    sprintf(msg.text, "%s %s", msg.name, "已退出！！！");
    while (p->next != NULL)
    {
        if (memcmp(&(p->next->addr), &caddr, sizeof(caddr)))
        {
            p = p->next;
            sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&(p->addr), sizeof(p->addr));
        }
        else
        {
            node_p ptail = p->next;
            p->next = ptail->next;
            free(ptail);
            ptail = NULL;
        }
    }
}

node_p create()
{
    node_p p = (node_p)malloc(sizeof(node_t));
    if (NULL == p)
    {
        perror("p malloc err");
        return NULL;
    }
    p->next = NULL;
    return p;
}
int main(int argc, char const *argv[])
{

    if (argc != 2)
    {
        printf("%s <port>\n", argv[0]);
        return -1;
    }
    int ret;
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("sockfd:%d\n", sockfd);

    struct sockaddr_in saddr, caddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[1]));
    // saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    saddr.sin_addr.s_addr = INADDR_ANY;
    int len = sizeof(caddr);

    if (bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("bind err");
        return -1;
    }
    printf("bind success\n");

    MSG_t msg;
    node_p p = create();
    // 服务器可以给所有用户发送“公告”
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        while (1)
        {
            fgets(msg.text, sizeof(msg.text), stdin);
            if (msg.text[strlen(msg.text) - 1] == '\n')
                msg.text[strlen(msg.text) - 1] = '\0';
            msg.type = chat;
            strcpy(msg.name, "server say ");
            sendto(sockfd, &msg, sizeof(MSG_t), 0, (struct sockaddr *)&saddr, sizeof(saddr));
        }
    }
    else
    {

        while (1)
        {
            memset(msg.text, 0, sizeof(msg.text));
            ret = recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&caddr, &len);
            if (ret < 0)
            {
                perror("recv err\n");
                return -1;
            }

            switch (msg.type)
            {
            case 0:
                printf("%s 上线\n", msg.name);
                Login(sockfd, msg, p, caddr);
                break;
            case 1:
                printf("%s %s\n", msg.name, msg.text);
                Chat(sockfd, msg, p, caddr);
                break;
            case 2:
                printf("%s 下线\n", msg.name);
                Quit(sockfd, msg, p, caddr);
                break;
            }
        }
        close(sockfd);
        return 0;
    }
}

客户端

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <dirent.h>
#include <sys/stat.h>
#include <signal.h>
#include <pthread.h>

enum type_t
{
    login,
    chat,
    quit,
};

// 链表
typedef struct node
{
    struct sockaddr_in addr;
    struct node *next;
} node_t, *node_p;

// 消息对应的结构体
typedef struct msg_t
{
    int type;
    char name[32];
    char text[128];
} MSG_t;

int main(int argc, char const *argv[])
{
    MSG_t msg;
    int ret;
    char buf[128];
    if (argc != 3)
    {
        printf("%s <ip> <port>\n", argv[0]);
        return -1;
    }

    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        perror("socket err");
        return -1;
    }
    printf("%d\n", sockfd);

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(atoi(argv[2]));
    saddr.sin_addr.s_addr = inet_addr(argv[1]);
    int len = sizeof(saddr);

    msg.type = login;
    printf("登录账号：\n");
    fgets(msg.name, sizeof(msg.name), stdin);
    if (msg.name[strlen(msg.name) - 1] == '\n')
        msg.name[strlen(msg.name) - 1] = '\0';

    if (sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
    {
        perror("send1 err");
        return -1;
    }

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        while (1)
        {
            memset(msg.text, 0, sizeof(msg.text));
            printf("请输入消息：\n");
            fgets(msg.text, sizeof(msg.text), stdin);
            if (msg.text[strlen(msg.text) - 1] == '\n')
                msg.text[strlen(msg.text) - 1] = '\0';
            if (strcmp(msg.text, "quit") == 0)
            {
                printf("退出\n");
                msg.type = quit;
                sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&saddr, sizeof(saddr));
                break;
            }
            else
            {
                msg.type = chat;
                if (sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr *)&saddr, sizeof(saddr))<0)
                {
                    perror("send2 err");
                    return -1;
                }
            }
        }
    }
    else
    {
        while (1)
        {
            if ((recvfrom(sockfd, &msg, sizeof(msg), 0, NULL, NULL)) < 0)
            {
                perror("recvfrom err.");
                return -1;
            }
            printf("%s:%s\n", msg.name, msg.text);
        }
    }
    close(sockfd);
    return 0;
}

 总结

一、整体架构和功能

 

  1. 整体架构

    • 基于 UDP 协议实现了一个简单的多人聊天系统。服务器和客户端通过发送和接收特定结构体（MSG_t）封装的消息来进行通信。
    • 服务器端维护一个链表（node_t）来存储已登录客户端的网络地址信息。

  2. 主要功能

    • 登录功能：客户端发送登录消息（login类型），服务器接收后将客户端信息添加到链表中，并通知其他已登录客户端该用户已登录。
    • 聊天功能：客户端发送聊天消息（chat类型），服务器将消息转发给除发送方之外的其他已登录客户端。
    • 退出功能：客户端发送退出消息（quit类型），服务器从链表中删除该客户端信息，并通知其他已登录客户端该用户已退出。
    • 服务器公告功能：服务器可以发送公告消息给所有已登录客户端。
 

二、服务器端分析

 

  1. 数据结构和枚举定义

    • 枚举类型type_t：定义了消息的类型，包括login（登录）、chat（聊天）和quit（退出），使消息处理逻辑更加清晰。
    • 结构体MSG_t：用于封装消息，包含消息类型（type）、发送者姓名（name）和消息内容（text）。
    • 结构体node_t和node_p：定义了链表节点，用于存储客户端的网络地址信息。

  2. 初始化部分

    • 命令行参数检查：检查启动服务器时是否提供了正确的端口号作为命令行参数。
    • 套接字创建和绑定：创建 UDP 套接字（socket函数），并将其与指定的 IP 地址和端口号绑定（bind函数）。

  3. 消息处理函数

    • Login函数
      • 当接收到登录消息时，构建登录通知消息（将用户名和登录状态组合）。
      • 遍历链表，将登录通知消息发送给除发送方之外的所有已登录客户端。
      • 创建新的链表节点，将登录客户端的地址信息添加到链表中。
    • Chat函数
      • 接收到聊天消息后，遍历链表，将消息发送给除发送方之外的所有已登录客户端。
    • Quit函数
      • 构建退出通知消息（将用户名和退出状态组合）。
      • 遍历链表，删除退出客户端的节点，并将退出通知消息发送给其他已登录客户端。

  4. 主循环部分

    • 服务器在一个无限循环中接收客户端发送的消息（recvfrom函数）。
    • 根据消息的类型（通过type字段判断）调用相应的处理函数（Login、Chat或Quit）。

  5. 服务器公告实现

    • 通过fork创建一个子进程，父进程负责处理客户端的消息，子进程用于发送服务器公告。
    • 子进程从标准输入读取公告内容，构建聊天类型的消息（type设置为chat，name设置为server say），并发送给所有已登录客户端。
 

三、客户端分析

 

  1. 数据结构定义

    • 与服务器端类似，定义了type_t枚举类型、MSG_t结构体和node_t、node_p结构体。

  2. 初始化部分

    • 命令行参数检查：检查启动客户端时是否提供了正确的服务器 IP 地址和端口号作为命令行参数。
    • 套接字创建：创建 UDP 套接字。

  3. 登录和消息发送流程

    • 客户端首先发送登录消息（type设置为login），包含用户输入的登录账号。
    • 通过fork创建一个子进程，子进程负责从标准输入读取消息内容，并根据消息内容判断是普通聊天消息还是退出消息。
      • 普通聊天消息（type设置为chat）直接发送给服务器。
      • 退出消息（type设置为quit）发送给服务器后，子进程退出。
    • 父进程在一个无限循环中接收服务器转发的消息（recvfrom函数），并将消息内容打印输出。
 

四、数据传输和处理

 

  1. 消息封装和解析

    • 服务器和客户端都使用MSG_t结构体来封装消息，通过网络传输该结构体的二进制数据。
    • 在接收端（服务器或客户端），直接将接收到的数据解析为MSG_t结构体进行处理。

  2. 网络地址处理

    • 在服务器端，使用struct sockaddr_in来存储客户端的网络地址信息。在Login、Chat和Quit函数中，需要根据客户端的网络地址来发送消息。
    • 客户端在发送消息时，需要指定服务器的网络地址（通过命令行参数获取并填充到struct sockaddr_in结构体中）。
 

五、注意事项和潜在问题

 

  1. 错误处理

    • 在代码中，对于系统调用（如socket、bind、recvfrom、sendto等）的返回值进行了检查，如果返回值小于 0，则表示调用失败，通过perror函数输出错误信息。

  2. 缓冲区溢出

    • 代码中使用固定大小的缓冲区（如MSG_t结构体中的text数组），在接收和处理消息时，如果消息内容长度超过缓冲区大小，可能会导致缓冲区溢出。

  3. 多线程 / 进程安全性

    • 服务器端使用了fork创建子进程来实现服务器公告功能，在多进程环境下，需要注意进程间资源共享和同步的问题。
    • 虽然代码中没有明显的线程相关操作，但如果要对程序进行扩展（如添加图形界面等），可能会引入线程，需要考虑线程安全性。

  4. 链表操作的健壮性

    • 服务器端使用链表来存储客户端信息，在Login、Quit等函数中涉及链表的插入和删除操作。在并发环境下（多个客户端同时登录或退出），可能需要对链表操作进行加锁保护，以确保链表的一致性。
嵌新程
关注
【socket】C语言的Socket网络编程
小鱼菜鸟的博客
10-04 7637
目录 Socket网络编程 1、网络知识 网络中进程之间如何通信？ 什么是Socket？ socket一词的起源 怎么理解端口？ 怎么理解socket ？ 2. 客户/服务器模式 2.1 服务器端： 2.2 客户端： 4. 套接字函数 4.1 创建套接字──sock...
c语言网络编程详解,Socket网络编程详解(TCP)
weixin_33274610的博客
05-18 1454
socket到底是个什么东西，socket是个TCP协议吗？我们平时很多方面都会用到socket，但确定真的了解socket吗？一.说起Socket我们在说什么？Wikipedia:A network socket is an endpoint of a connection in a computer network. In Internet Protocol (IP) networks, th...
C语言网络编程（Socket通信）
网络空间发展与战略研究
05-26 2475
目录 一、通讯示意图 二、函数详解 1、socket()函数 2、bind()函数 3、listen()、connect()函数 4、accept()函数 5、read()、write()等函数 6、close()函数 7、sockaddr_in和sockaddr详解 三、socket三次握手建立连接 四、socket四次握手释放连接 五、服务端和客户端代码 一、通讯示意图 二、函数详解 1、socket()函数 int socket(int domain, in.
C语言 网络编程socket服务端TCP连接创建
weixin_55944697的博客
08-12 453
C语言 网络连接 客户端TCP连接通信建立。
C语言socket编程
LLLLLiangCCCCChen的博客
11-18 235
为了更方便地开发网络应用程序，美国伯克利大学在UNIX上推出了一种应用程序访问通信协议的操作系统调用接字(Socket)。Socket的出现，使得程序员可以很方便地访问 TCP/IP，从而开发各种网络应用程序。后来套接字被引进到 Windows等操作系统，成为开发网络应用程序的有效工具。socket（套接字）是一种通信机制，它是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。
C语言 网络编程_socket编程“陷阱识别”
albertlee0329的博客
11-04 210
socket网络编程遇到的坑，bind函数和accept函数
网络socket编程（c语言）
热门推荐
YanPan12的博客
11-22 1万+
一.socket通信简介 Socket是对TCP/IP协议的封装，Socket本身并不是协议，而是一个调用接口（API），通过Socket，我们才能使用TCP/IP协议,主要利用三元组【ip地址，协议，端口】。 socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。 Socket()函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。
深入理解C语言中的Socket编程
m0_46566693的博客
06-14 1048
深入理解C语言中的Socket编程
socket网络编程基础（客户端C语言实现）
qq_40770277的博客
02-17 1318
#include <stdio.h> #include <ctype.h> #include <sys/socket.h> #include <arpa/inet.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <errno.h> #include <pthread.h> #define SERV_POR
C语言网络编程入门详解
极客代码
08-03 1104
TCP（传输控制协议）是一种面向连接、可靠的传输层协议。它通过三次握手建立连接，确保数据的可靠传输。本部分介绍了TCP套接字编程的基础知识，并通过一个简单的TCP回显服务器和客户端的示例代码，展示了如何在C语言中实现网络通信。这个例子虽然简单，但它涵盖了TCP套接字编程的核心概念，包括创建套接字、绑定地址、监听连接、接受连接、数据传输和关闭套接字。通过理解这些基本步骤，读者可以进一步探索更复杂的网络编程场景，如多客户端连接处理、非阻塞IO、多线程服务器等。
Linux下C语言socket网络编程简例
01-09
　这里给出在linux下的简单socket网络编程的实例，使用tcp协议进行通信，服务端进行监听，在收到客户端的连接后，发送数据给客户端；客户端在接受到数据后打印出来，然后关闭。程序里有详细的说明，其中对具体的...
如何基于C语言socket编程实现TCP通信
01-01
TCP/IP协议（Transmission Control Protocol/Internet Protocol）叫做传输控制/网际协议，又叫网络通信协议。实际上，它包含上百个功能的协议，如ICMP（互联网控制信息协议）、FTP...流式socket（SOCK_STREAM）：流式
socket网络通信 c语言完成 vs运行
01-06
SOCKADDR_IN cAddr={0}; int len=sizeof cAddr; SOCKET clientSocket; int main(){ //1.请求版本号 WSADATA wsaData; WSAStartup(MAKEWORD(2,2),&wsaData); if(LOBYTE(wsaData.wVersion)!=2||HIBYTE...
python网络编程socket实现服务端、客户端操作详解
01-20
本文实例讲述了python网络编程socket实现服务端、客户端操作。分享给大家供大家参考，具体如下： 本文内容： socket介绍 TCP: 服务端 客户端 UDP: 服务端 客户端 首发时间：2018-02-08 01:14 修改： 2018-03...
​数据链路层——流量控制&可靠传输机制 ​
最新发布
qq_25467441的博客
09-09 740
例题:一个信道的数据传输率为4kb/s ,单向传播时延为30ms ,如果使停止-等待协议的信道最大利用率达到80%,要求的数据帧长度至少为。设数据帧的长度为L比特，则发送方发送全部的数据需要时间：L/4。“停止-等待”就是每发送完一个分组就停止发送，等待对方确认，在收到确认后再发送下一个分组。因为是在讨论可靠传输的原理,所以并不考虑数据是在哪一个层次上传送的。发送方在一个发送周期内,有效地发送数据所需要的时间占整个发送周期的比率。数据链路层的流量控制是点对点的，而传输层的流量控制是端到端的。
200 Gb/s和400 Gb/s网络
dncsk的专栏
09-07 1432
116.200 Gb/s和400 Gb/s网络简介写在前面 :1.需要英文原文请自行官网下载2.本人无授权故亦不接受相关付费服务 如有商业性需求建议寻找有资质的书籍供应商购买3.翻译纯粹为爱发电,因为机器翻译所以错乱较多 建议参照英文原文对比使用 4.欢迎评论区提出建议或意见 原则上不删除评论 原则上不回复私信 和解呈现200GBASE-RPCSPMDIEEEStd802.3-2022，IEEE以太网标准第八节116.200Gb/s和400Gb/s网络116.1概述116.1范围本条款描述了200千兆位和4
[网络]HTTP协议 Cookie与Session
m0_74910646的博客
09-07 792
HTTP Cookie（也称为 Web Cookie、浏览器 Cookie 或简称 Cookie）是服务器发送到 用户浏览器并保存在浏览器上的一小块数据，它会在浏览器之后向同一服务器再次发 起请求时被携带并发送到服务器上。通常，它用于告知服务端两个请求是否来自同一浏览器，如保持用户的登录状态、记录用户偏好等。HTTP Session 是服务器用来跟踪用户与服务器交互期间用户状态的机制。由于 HTTP 协议是无状态的（每个请求都是独立的），因此服务器需要通过 Session 来记住用户的信息。
145-Linux权限维持&Rootkit后门&Strace监控&Alias别名&Cron定时任务
DamnVanish的博客
09-07 866
Linux中最强权限维持rootkit
亚信安全出席第五届国际反病毒大会 探究AI现代网络勒索治理
亚信安全官方账号的博客
09-09 498
亚信安全出席活动并发表题为《AI时代下现代网络勒索治理》的演讲
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值