广播 on MeloBrush的技术博客

01-UDP基础编程：Linux下C语言Socket通信实战

Wed, 10 Dec 2025 15:40:00 +0800

本文通过一个完整的C语言示例，详细讲解如何在Linux环境下使用UDP协议实现基本的客户端与服务器通信，涵盖核心函数、实现步骤及常见问题排查。

一、实验目的

利用UDP协议，实现一个简单的客户端-服务器（Client-Server）通信程序，理解UDP无连接通信的基本模型。

二、核心原理与概念

UDP（用户数据报协议）是一种无连接、不可靠但高效的传输层协议。

通信特点

无连接：每次数据传输都是独立的，必须指定目标IP和端口。
面向数据报：以完整的报文为单位进行收发，保留边界。
适用场景：适用于对实时性要求高、可容忍少量丢包的场景，如视频流、音频通话、DNS查询等。

通信流程

通信双方（A和B）的流程是对称的，但在典型客户端/服务器模型中角色稍有不同：

服务端： socket() -> bind() -> recvfrom() -> sendto()

客户端： socket() -> sendto() -> recvfrom()

网络通信的三种情况

本机通信：使用回环地址 127.0.0.1。
局域网内跨机通信：使用目标主机的局域网IP（如 192.168.1.100）。
跨网/公网通信：必须知道目标主机的公网IP，且需要路由器进行端口转发（NAT）。

三、核心函数详解

3.1 关键函数

1.`socket()` - 创建通信端点

1
2
3

#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);

作用：创建通信端点，返回一个文件描述符用于后续操作。

参数：

domain：协议族，如 AF_INET (IPv4)。

type：套接字类型，SOCK_DGRAM 表示UDP。

protocol：通常设为 0，系统自动选择。

返回值：成功返回文件描述符(>=0)，失败返回-1。

2.`bind()`-绑定地址（服务器必需）

`1`	`int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);`

作用：将一个套接字 (sockfd) 与一个特定的 IP 地址和端口号（由 addr 指定）绑定在一起。服务器程序必须调用此函数来声明它在哪里监听。

参数解释：
sockfd：socket() 函数返回的套接字描述符。

addr：指向 struct sockaddr 的指针，包含了要绑定的地址和端口信息。对于 IPv4，我们实际使用 struct sockaddr_in 并强制转换。

addrlen：addr 结构体的长度，通常为 sizeof(struct sockaddr_in)。

返回值：成功返回 0，失败返回 -1。

3.`sendto()`- 发送UDP数据报

1
2

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, 
socklen_t addrlen);

作用：向指定的目标地址 (dest_addr) 发送一个数据报。

参数解释：

sockfd：套接字描述符。

buf：指向待发送数据缓冲区的指针。

len：要发送数据的长度（字节数）。

flags：控制标志，通常设为 0。

dest_addr：指向目标地址结构体的指针，决定了数据发往哪里。

addrlen：目标地址结构体的长度。

返回值：成功返回实际发送的字节数，失败返回 -1。

4.`recvfrom()`-接收UDP数据报

`1`	`ssize_t recvfrom(int sockfd, void buf, size_t len, int flags, struct sockaddr src_addr, socklen_t *addrlen);`

作用：从套接字接收一个数据报，并获取发送者的地址信息 (src_addr)。

参数解释：

sockfd：套接字描述符。

buf：指向接收数据缓冲区的指针。

len：缓冲区的最大容量。

flags：控制标志，通常设为 0。

src_addr：指向 struct sockaddr 的指针，用于存放发送者的地址信息。如果不需要，可设为 NULL。

addrlen：这是一个值-结果参数。调用前，需将其初始化为零

src_addr：缓冲区的长度；返回时，它会被设置为实际存放的地址长度。返回值：成功返回接收到的字节数，失败返回 -1。返回 0 在UDP中不表示连接关闭，而是收到了一个长度为0的数据报。

3.2 辅助函数与字节序转换

1.地址转换函数

#include <arpa/inet.h>
// 字符串IP -> 网络字节序二进制 (Presentation to Network)
int inet_pton(int af, const char *src, void *dst);
// 网络字节序二进制 -> 字符串IP (Network to Presentation)
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

2.字节序转换函数

网络字节序采用大端序，主机字节序可能不同，必须转换。

#include <arpa/inet.h>
// 主机 -> 网络 (Host to Network)
uint16_t htons(uint16_t hostshort); // 用于端口
uint32_t htonl(uint32_t hostlong);  // 用于IP地址
// 网络 -> 主机 (Network to Host)
uint16_t ntohs(uint16_t netshort);
uint32_t ntohl(uint32_t netlong);

3.3关键数据结构

#include <netinet/in.h>
struct sockaddr_in {
    sa_family_t    sin_family; // 地址族，如 AF_INET
    in_port_t      sin_port;   // 16位端口号（网络字节序）
    struct in_addr sin_addr;   // 32位IP地址（网络字节序）
    char           sin_zero[8]; // 填充字段，通常置零
};
struct in_addr {
    in_addr_t      s_addr;     // 32位IPv4地址
};

四.实现步骤分析

服务器端实现步骤

理解了核心函数后，我们按步骤构建服务器。

1.创建udp套接字

int sfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sfd == -1)
{
    perror("socket failed");
    exit(1);
}

2.准备并绑定服务器地址

这里需要理解 struct sockaddr_in 这个重要的结构体。

#include <netinet/in.h>
struct sockaddr_in {
    sa_family_t    sin_family; // 地址族，必须为 AF_INET
    in_port_t      sin_port;   // 16位端口号，必须使用网络字节序 (htons)
    struct in_addr sin_addr;   // 32位IPv4地址
    char           sin_zero[8]; // 未使用，填充为0
};
struct in_addr {
    in_addr_t      s_addr;     // 32位IPv4地址 (网络字节序)
};

配置并绑定地址

struct sockaddr_in saddr;
bzero(&saddr, sizeof(saddr)); // 清空结构体

saddr.sin_family = AF_INET; // IPv4
saddr.sin_port = htons(SER_PORT); // 端口转为网络字节序
saddr.sin_addr.s_addr = htonl(INADDR_ANY); // 绑定到本机所有IP

if (bind(sfd, (struct sockaddr*)&saddr, sizeof(saddr)) == -1) {
    perror("bind failed");
    close(sfd);
    exit(1);
}
printf("服务器已启动，正在监听端口 %d...\n", SER_PORT);

3.循环接收与处理数据址

struct sockaddr_in caddr;// 用于存储客户端地址
socklen_t clen = sizeof(caddr);
char buf[MAXLINE];

while (1)
{
    ssize_t n = recvfrom(sfd, buf, MAXLINE, 0,(struct sockaddr*)&caddr, &len);
    if (n > 0)
    {
        buf[n] = '\0';
        char client_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &caddr.sin_addr, client_ip, INET_ADDRSTRLEN);
        printf("来自[%s:%d]的消息：%s\n", client_ip, ntohs(caddr.sin_port), buf);
         // ... (后续可在此添加 sendto 回复客户端的逻辑)
    }
}

3.3客户端实现步骤

客户端流程与服务器类似，但不需要 bind 固定端口。

1.创建udp套接字

同服务端

2.设置目标服务器地址

struct sockaddr_in saddr;
bzero(&addr, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(SER_PORT);// 服务器端口
// 将字符串形式的IP（如“127.0.0.1”）转换为网络字节序的二进制形式,argv[1]是main()传进来的参数
if (inet_pton(AF_INET, argv[1], &saddr.sin_addr) <= 0)
{
    perror("invalid address or address not supported")
    exit(1);
}

3.发送与接收循环

char send_buf[MAXLINE], recv_buf[MAXLINE];
socklen_t addr_len = sizeof(saddr);

while (1) 
{
    printf("请输入要发送的消息: ");
    fgets(send_buf, MAXLINE, stdin);
    
    // 使用 sendto 将数据发送到步骤二中设定的 saddr
    if (sendto(cfd, send_buf, strlen(send_buf), 0, (struct sockaddr*)&saddr, addr_len) == -1) 
    {
        perror("sendto failed");
        continue;
    }
    
    // 使用 recvfrom 接收回复。注意，这里最后一个参数可以是NULL，因为我们已经知道服务器地址。
    ssize_t n = recvfrom(cfd, recv_buf, MAXLINE, 0, NULL, NULL);
    if (n > 0) 
    {
        recv_buf[n] = '\0';
        printf("服务器回复: %s\n", recv_buf);
    }
}

四、完整代码实现

以下是将前面步骤整合后的、可直接编译运行的完整程序代码。

1.服务端：

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<ctype.h>
#define SER_PORT 2500
#define MAXLINE 80

int main()
{
    struct sockaddr_in saddr,caddr;
    socklen_t clen;
    int sfd;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];
    char rbuff[50] = {0},sbuff[50] = {0};
    int n;

    sfd = socket(AF_INET,SOCK_DGRAM,0);
    bzero(&saddr,sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(SER_PORT);
    saddr.sin_addr.s_addr = htonl(INADDR_ANY);

    bind(sfd,(struct sockaddr*)&saddr,sizeof(saddr));
    printf("accept connections...\n");
    //处理客户端信息
    while(1)
    {
        clen = sizeof(caddr);
        n = recvfrom(sfd,buf,MAXLINE,0,(struct sockaddr*)&caddr,&clen);
        if(n > 0)
        {
            buf[n] = '\0';
            printf("client say:%s\n",buf);
        }
        printf("say sth to client:\n");
        bzero(sbuff,sizeof(sbuff));
        fgets(sbuff,sizeof(sbuff),stdin);
        n = sendto(sfd,sbuff,strlen(sbuff),0,(struct sockaddr*)&caddr,sizeof(caddr));
        if(n == -1)
             perror("sendto error");
        bzero(buf,sizeof(buf));
    }
    close(sfd);
    return 0;
}

2.客户端：


#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include<arpa/inet.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<net/if.h>
#define SER_PORT 2500
#define MAXLINE 80

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("./client IP");
        exit(1);
    }
    struct sockaddr_in saddr;
    int cfd,n;
    char sbuff[256]={0},rbuff[256]={0};
    cfd = socket(AF_INET,SOCK_DGRAM,0);
    bzero(&saddr,sizeof(saddr));

    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(SER_PORT);
    inet_pton(AF_INET,argv[1], &saddr.sin_addr.s_addr);
    socklen_t len = sizeof(saddr);

    while(1)
    {
        printf("say sth to server:\n");
        fgets(sbuff,MAXLINE,stdin);
        n = sendto(cfd,sbuff,strlen(sbuff),0,(struct sockaddr*)&saddr,sizeof(saddr));
        if(n == -1)
        {
            perror("sendto error");
            exit(1);
        }
        n = recvfrom(cfd,rbuff,MAXLINE,0,(struct sockaddr*)&saddr,&len);
        if(n > 0)
        {
        printf("server say:%s\n",rbuff);
        bzero(rbuff,sizeof(rbuff));// 清空接收缓冲区，为下次准备
        }
    }
    return 0;
}

3.编译运行：

# 编译服务器
gcc -o udp_server server.c
# 编译客户端
gcc -o udp_client client.c

# 运行（需要两个终端窗口）
 ./udp_server
# 运行客户端，并指定服务器IP（本地测试用127.0.0.1）
 ./udp_client 127.0.0.1

五.遇到的问题

问题：缓冲区污染
现象：客户端有时会显示上一次的旧消息。
根因：在最初的代码中，发送和接收复用了同一个字符数组 sbuff/rbuff，recvfrom 可能没有覆盖全部旧数据。
解决：严格区分 send_buf (专用于发送) 和 recv_buf (专用于接收)，并在每次接收后使用 bzero 或 memset 清空接收缓冲区。

六.学习总结

✅ 无连接：每次通信都需指定目标地址，没有“连接”状态。

✅ 服务端必备 bind()：固定端口，等待数据。

✅ 客户端指定地址：通过 sendto 的目标地址参数确定服务器。

✅ 缓冲区分离：发送与接收缓冲区独立，避免数据混乱。

✅ 循环处理：双方通常使用 while(1) 循环持续通信。

下一步

掌握了基础通信后，可以探索： 02-UDP广播编程，学习如何向局域网内所有主机发送消息。

02-udp-broadcast-programming

Wed, 10 Dec 2025 20:48:00 +0800

本文详细讲解如何在Linux环境下使用UDP协议实现广播通信，包括广播地址概念、核心函数setsockopt()的用法、完整的发送端和接收端实现，以及常见问题的解决方案。

一、实验目的

掌握UDP广播通信的原理，实现一个向局域网内所有主机发送广播消息的程序，并实现接收广播消息的程序。

二、核心原理/知识点

2.1 广播概述

广播是一种一对所有的通信方式。在局域网内，发送到一个广播地址的数据包，会被该网段内的所有主机接收和处理（如果该主机程序监听在了相应端口）。

2.2 广播地址

受限广播地址：255.255.255.255。该地址不会被路由器转发，仅限本网络内部。

定向广播地址：网络号.主机号全为1，例如，对于 192.168.1.0/24 网段，其广播地址是 192.168.1.255。传统上，路由器可转发此类广播，但现代网络常默认禁止。

三、核心函数详解

广播编程在单播基础上，主要增加了一个关键的系统调用。

setsockopt() - 设置套接字选项

#include<sys/types.h>
#include<sys/socket.h>

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);

作用：用于控制套接字的各种行为。在本实验中，用于启用套接字的广播发送权限。

参数解释： sockfd：由 socket() 创建的套接字描述符。 level：选项定义的层次。设置为 SOL_SOCKET，表示在套接字API层面操作。 optname：要设置的选项名。启用广播需设置为 SO_BROADCAST。 optval：指向包含新选项值的缓冲区的指针。对于布尔选项，指向一个 int 型变量，1 表示开启。 optlen：optval 缓冲区的大小，例如 sizeof(int)。返回值：成功返回 0，失败返回 -1 并设置 errno。

头文件：#include <sys/socket.h>

备注：只有发送方需要设置此选项。接收方只需像普通UDP程序一样，绑定到广播地址或 INADDR_ANY 并监听特定端口即可。

四、实现步骤分解

发送端

1.创建UDP套接字

`1`	`int sockfd = socket(AF_INET, SOCK_DGRAM, 0);`

2.启用套接字广播选项 (关键步骤)

int optval = 1; // 1表示“启用”
if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &optval, sizeof(optval)) < 0) {
    perror(“Setsockopt SO_BROADCAST failed”);
    exit(EXIT_FAILURE);
}

3.设置目标广播地址

struct sockaddr_in broadcast_addr;
memset(&broadcast_addr, 0, sizeof(broadcast_addr));
broadcast_addr.sin_family = AF_INET;
broadcast_addr.sin_port = htons(BROADCAST_PORT); // 定义一个广播端口，如 8888
// 使用定向广播地址，例如 192.168.1.255这个要使用本机的广播地址
inet_pton(AF_INET, “192.168.1.255”, &broadcast_addr.sin_addr);

4.循环发送广播消息

while (1) {
    char msg[256];
    sprintf(msg, “Broadcast message at %ld”, time(NULL));
    sendto(sockfd, msg, strlen(msg), 0,
           (struct sockaddr*)&broadcast_addr, sizeof(broadcast_addr));
    sleep(2); // 间隔2秒发送一次
}

接收端

1.创建UDP套接字

同发送

2.绑定到任意地址和广播端口

struct sockaddr_in recv_addr;
memset(&recv_addr, 0, sizeof(recv_addr));
recv_addr.sin_family = AF_INET;
recv_addr.sin_port = htons(BROADCAST_PORT); // 端口必须与发送端一致
recv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 接收所有网卡的数据

bind(sockfd, (struct sockaddr*)&recv_addr, sizeof(recv_addr));

3.循环接收广播消息

while (1) {
    char buf[256];
    struct sockaddr_in src_addr;
    socklen_t addr_len = sizeof(src_addr);
    ssize_t n = recvfrom(sockfd, buf, sizeof(buf)-1,0,(struct sockaddr*)&src_addr, &addr_len);
    if (n > 0) {
        buf[n] = '\0';
        char ip_str[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &src_addr.sin_addr, ip_str, sizeof(ip_str));
        printf(“[%s:%d] %s\n”, ip_str, ntohs(src_addr.sin_port), buf);
    }
}

五、完整代码实现

发送端：


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

#define BROAD_PORT 8888
#define BROAD_ADDR "192.168.245.255"
#define BUF_LEN 256

int main() 
{
    int sock;
    struct sockaddr_in broad_addr;
    char buf[BUF_LEN];
    int count = 37;
    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) 
    {
        perror("socket err");
        exit(1);
    }
    int opt = 1;
    setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(opt));
    // 初始化广播地址
    memset(&broad_addr, 0, sizeof(broad_addr));
    broad_addr.sin_family = AF_INET;
    broad_addr.sin_port = htons(BROAD_PORT);
    inet_pton(AF_INET, BROAD_ADDR, &broad_addr.sin_addr);
    // 循环发送广播
    while (1) 
    {
        snprintf(buf, BUF_LEN, "The villagers have noticed that everyone's fund-raising has reached %d yuan.", count);
        // 发送广播
        sendto(sock, buf, strlen(buf), 0, (struct sockaddr*)&broad_addr, sizeof(broad_addr));
        count++;
        sleep(1);
    }

    close(sock);
    return 0;
}

接收端：


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

#define BROAD_PORT 8888
#define BUF_LEN 256

int main()
{
    int sock;
    struct sockaddr_in local_addr;
    socklen_t addr_len = sizeof(local_addr);
    char buf[BUF_LEN];
    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
        perror("socket err");
        exit(1);
    }

    memset(&local_addr, 0, sizeof(local_addr));
    local_addr.sin_family = AF_INET;
    local_addr.sin_port = htons(BROAD_PORT);
    local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(sock, (struct sockaddr*)&local_addr, sizeof(local_addr));

    // 循环接收广播
    while (1)
{
        memset(buf, 0, BUF_LEN);
        recvfrom(sock, buf, BUF_LEN-1, 0, NULL, NULL);
        printf("%s\n", buf);
    }
    close(sock);
    return 0;
}

六、编译与运行

# 1. 分别编译发送端和接收端程序
gcc -o broadcast_sender broadcast_sender.c -Wall
gcc -o broadcast_receiver broadcast_receiver.c -Wall

# 2. 运行（需要两台在同一局域网的主机，或一台主机开两个终端模拟）
# 在主机A（或终端1）运行接收端，监听广播：
./broadcast_receiver

# 在主机B（或终端2）运行发送端，开始广播：
./broadcast_sender

注意：要先将两个主机ping通如果在一台机器测试，请确保防火墙允许该端口的UDP数据包。

七、遇到的问题与解决

问题一：虚拟机无法接收到广播消息现象：发送端正常发送，但另一台虚拟机的接收端无任何输出。

原因分析：虚拟机的网络适配器模式可能设置为NAT，该模式通常不支持主机间的广播。需要改为桥接模式，使虚拟机直接接入物理局域网。

解决方案：关闭虚拟机，修改其网络设置，将网络连接从“NAT”改为“桥接模式”，然后重启虚拟机并重新获取IP。

问题二：bind error: Address already in use 现象：接收端程序启动失败。

原因分析：之前运行的程序未完全退出，端口仍被占用。

解决方案：

# 查找占用端口的进程
sudo netstat -tulnp | grep <端口号>
# 终止该进程
kill -9 <进程PID>

八、实验总结与思考

✅ 掌握了UDP广播的通信模型和广播地址的概念。

✅ 理解了 setsockopt() 函数及其 SO_BROADCAST 选项的关键作用。

✅ 成功实现了广播的发送端与接收端程序。

✅ 了解了桥接模式对局域网通信的重要性。

导航：

03-udp-multicast-programming

Wed, 10 Dec 2025 20:48:00 +0800

本文详细讲解如何在Linux环境下使用UDP协议实现组播（多播）通信，包括组播地址分类、核心数据结构struct ip_mreqn的用法、完整的发送端和接收端实现，以及实际应用场景。

一、实验目的

使用UDP实现组播发送消息

二、核心原理/知识点

1. 多播（组播）特点

组播组可以是永久的也可以是临时的永久组播组：由官方分配固定IP地址范围，组成员动态变化（成员可以是任意的，甚至可以为零）临时组播组：使用未被永久组占用的地址

2.IP多播地址分类

D类IP地址（224.0.0.0 ~ 239.255.255.255）用于多播：

地址范围	用途	说明
224.0.0.0 ~ 224.0.0.255	局部保留，不跨路由器	`224.0.0.1`：所有主机`224.0.0.2`：所有路由器
224.0.1.0 ~ 224.0.1.255	公用组播地址，可用于Internet	使用时需要申请
224.0.2.0 ~ 238.255.255.255	用户可用的临时组播地址	实验环境中常用
239.0.0.0 ~ 239.255.255.255	本地管理组播地址	仅在特定本地范围内有效示例代码中使用：`239.0.0.2`

三、核心函数详解

3.1 新函数解析

这里没有涉及新的函数，不在阐述

3.2 关键数据结构

struct ip_mreqn {
    struct in_addr imr_multiaddr;  // 多播组IP地址
    struct in_addr imr_address;    // 本地IP地址（0.0.0.0表示自动选择）
    int imr_ifindex;               // 网络接口索引
};

四、实现步骤分解

服务端

1.创建udp套接字

`1`	`int sfd = socket(AF_INET,SOCK_DGRAM, 0);`

2.绑定服务器地址

struct socket_in saddr;
saddr.sin_family = AF_INET;
saddr.sin_port = htnos(SERVER_PORT);
saddr.sin_addr.s_addr = htonl(INADDR_ANY);

3.配置多播参数

// 设置多播组和网络接口
inet_pton(AF_INET, "239.0.0.2", &group.imr_multiaddr);
inet_pton(AF_INET, "0.0.0.0", &group.imr_address);
group.imr_ifindex = if_nametoindex("ens33"); // 指定本机网卡

// 设置多播出口
setsockopt(sfd, IPPROTO_IP, IP_MULTICAST, &group, sizeof(group));

4. 发送多播数据

maddr.sin_family = AF_INET;
inet_pton(AF_INET, "239.0.0.2", &maddr.sin_addr);
maddr.sin_port = htons(CLIENT_PORT);
sendto(sfd, msg, strlen(msg), 0, (struct sockaddr*)&maddr, sizeof(maddr));

客户端

1. 创建UDP套接字并绑定

int confd = socket(AF_INET, SOCK_DGRAM, 0);
// 绑定到特定端口接收数据
client_addr.sin_family = AF_INET;
clinet_addr.sin_port = htons(CLIENT_POORT);
client_addr.sin_addr.s_addr = htonl(INADDR_ANY);
bind(conf, (struct sockaddr*)&client_addr, sizeof(client_addr));

2. 加入多播组

// 设置要加入的多播组
inet_pton(AF_INET, "239.0.0.2", &group.imr_multiaddr);
inet_pton(AF_INET, "0.0.0.0", &group.imr_address);
group.imr_ifindex = if_nametoindex("ens33");

// 加入组播组
setsockopt(confd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &group, sizeof(group));

3. 接收多播数据

1
2

// 循环接收组播消息
recvfrom(confd, buf, sizeof(buf)-1, 0, (struct sockaddr*)&client_addr, &addr_len);

重要注意事项

网络接口选择代码中使用 if_nametoindex(“ens33”) 指定网卡。实际部署时需要根据系统网卡名称调整（可能是eth0、wlan0等）。
端口使用服务端：绑定在8000端口（发送端口）。客户端：绑定在9000端口（接收端口）。多播发送时指定目标端口为9000。
地址范围选择实验环境建议使用 239.x.x.x 范围。避免使用保留地址段。
一对多通信一个服务端可以向多个客户端发送相同数据。客户端只需加入相同的多播组即可接收。

五、完整代码实现

服务端

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

#define GROUP "239.0.0.2"
#define CLIENT_PORT 9000
#define SERVER_PORT 8000

int main()
{
    int sfd;
    struct sockaddr_in saddr,maddr;
    struct ip_mreqn group;
    sfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sfd < 0)
    {
        perror("socket failed");
        exit(1);
    }
    bzero(&saddr,sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(SERVER_PORT);
    saddr.sin_addr.s_addr = htonl(INADDR_ANY);
    if(bind(sfd,(struct sockaddr*)&saddr,sizeof(saddr)) < 0)
    {
        perror("bind failed");
        exit(1);
    }
    //设置组播
    inet_pton(AF_INET,GROUP,&group.imr_multiaddr);
    inet_pton(AF_INET,"0.0.0.0",&group.imr_address);
    group.imr_ifindex = if_nametoindex("ens33");
    //组播出口网卡
    setsockopt(sfd, IPPROTO_IP,IP_MULTICAST_IF,&group,sizeof(group));
    //组播目标地址
    bzero(&maddr,sizeof(maddr));
    maddr.sin_family = AF_INET;
    inet_pton(AF_INET,GROUP,&maddr.sin_addr);
    maddr.sin_port = htons(CLIENT_PORT);
    //循环发送组播消息
    char msg[128];
    int cnt = 1;
    while(1)
    {
        snprintf(msg,sizeof(msg),"group msg %d:The villagers' fund reached %d",cnt, 36+cnt);
        sendto(sfd,msg,strlen(msg),0,(struct sockaddr*)&maddr,sizeof(maddr));
        printf("sent:%s\n",msg);
        cnt++;
        sleep(1);
    }
    close(sfd);
    return 0;
}

客户端

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

#define GROUP "239.0.0.2"
#define CLIENT_PORT 9000

int main() {
    int confd;
    struct sockaddr_in client_addr;
    struct ip_mreqn group;
    char buf[128];
    socklen_t addr_len = sizeof(client_addr);

    if ((confd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket");
        exit(1);
    }

    //绑定监听端口
    bzero(&client_addr, sizeof(client_addr));
    client_addr.sin_family = AF_INET;
    client_addr.sin_port = htons(CLIENT_PORT);
    client_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(confd, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0) {
        perror("bind");
        exit(1);
    }

    //设置组地址，加入组播组
    inet_pton(AF_INET, GROUP, &group.imr_multiaddr);
    inet_pton(AF_INET, "0.0.0.0", &group.imr_address);
    group.imr_ifindex = if_nametoindex("ens33");
    // 加入组播组
    setsockopt(confd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &group, sizeof(group));

    // 接收并打印组播消息
    printf("Waiting for group messages...\n");
    while (1) {
        memset(buf, 0, sizeof(buf));
        int n = recvfrom(confd, buf, sizeof(buf)-1, 0, (struct sockaddr*)&client_addr, &addr_len);
        if (n > 0) {
            printf("Received: %s\n", buf);
        }
    }

    close(confd);
    return 0;
}

六、编译与运行

# 编译服务端
gcc -o server server.c

# 编译客户端
gcc -o client client.c
# 在不同终端运行/或者不同虚拟机
./server    # 启动服务端，开始发送组播消息
./client    # 启动客户端，加入组播组接收消息

# 可以启动多个客户端实例，都会收到相同的消息

重要注意事项

网络接口选择代码中使用 if_nametoindex(“ens33”) 指定网卡

实际部署时需要根据系统网卡名称调整：

Ubuntu/CentOS: ens33, eth0, enp0s3

查看网卡名称：ip addr 或 ifconfig

端口使用服务端：绑定在8000端口（发送端口）

客户端：绑定在9000端口（接收端口）

多播发送：指定目标端口为9000

地址范围选择实验环境建议使用 239.x.x.x 范围

避免使用保留地址段（224.0.0.0~224.0.0.255）

一对多通信一个服务端可以向多个客户端发送相同数据

客户端只需加入相同的多播组即可接收

组播比广播更节省网络带宽

七、应用场景

视频直播：一个源向多个接收者发送视频流

股票行情推送：实时向多个客户端推送行情数据

在线游戏：同步多个玩家的游戏状态

会议系统：多方视频/音频通信

八、实验总结与思考

总结：多播通过使用特定的IP地址范围（224.0.0.0~239.255.255.255），实现了高效的一对多通信。编程时需要注意正确设置多播组、网络接口，并确保发送和接收端口一致。

导航：

04-unix-domain-socket

Wed, 10 Dec 2025 20:48:00 +0800

本文详细讲解如何在Linux环境下使用Unix域数据报套接字实现本机进程间通信，包括Unix域套接字的核心概念、关键数据结构、线程模型设计以及完整的双向通信实现。

一、实验目的

使用数据报域套接字实现本机两个进程的通信

二、核心原理/知识点

1. 什么是Unix域套接字

IPC机制：进程间通信（Inter-Process Communication）的一种方式

基于文件系统：使用文件路径作为地址，而不是IP地址和端口

高效通信：只在内核中传输数据，无需网络协议栈处理

仅限本地：只能在同一台主机上的进程间通信

2. 域套接字类型

类型	特点	示例
流式套接字 (SOCK_STREAM)	面向连接、可靠、双向字节流	类似TCP
数据报套接字 (SOCK_DGRAM)	无连接、不可靠、保留消息边界	类似UDP

三、核心函数详解

3.1 关键API函数

删除已存在的套接字

1
2
3

// 删除已存在的套接字文件
# include <unistd.h>
int unlink(const char *pathname);

3.2 关键数据结构

地址结构

struct sockaddr_un {
    sa_family_t sun_family;     // 地址族，AF_UNIX或AF_LOCAL
    char sun_path[108];         // 文件路径名
};

四、实现步骤分解

1.关键API函数

(1) 创建套接字

int sfd = socket(AF_UNIX, SOCK_DGRAM, 0);
// AF_UNIX：使用Unix域协议

// SOCK_DGRAM：创建数据报套接字

(2) 绑定地址

// 1. 删除已存在的套接字文件
unlink(SOCK_PATH_A);

// 2. 设置地址结构
struct sockaddr_un myaddr;
bzero(&myaddr, sizeof(myaddr));
myaddr.sun_family = AF_UNIX;
strncpy(myaddr.sun_path, SOCK_PATH_A, sizeof(myaddr.sun_path)-1);

// 3. 绑定
bind(sfd, (struct sockaddr*)&myaddr, sizeof(myaddr));

(3) 发送数据

1
2

sendto(sfd, buf, strlen(buf), 0, 
       (struct sockaddr*)&paddr, sizeof(paddr));

(4) 接收数据

1
2

recvfrom(sfd, buf, BUF_SIZE-1, 0, 
         (struct sockaddr*)&paddr, &len);

2. 线程模型设计

4.关键代码片段详解

(1). 接收线程函数

void *recv_msg(void *arg) {
    int sfd = *(int *)arg;
    char buf[BUF_SIZE];
    struct sockaddr_un paddr;
    socklen_t len = sizeof(paddr);
    
    while(1) {
        // 阻塞接收消息
        ssize_t n = recvfrom(sfd, buf, BUF_SIZE-1, 0, 
                            (struct sockaddr*)&paddr, &len);
        if(n > 0) {
            buf[n] = '\0';  // 添加字符串结束符
            printf("peer say:%s", buf);
        }
    }
    return NULL;
}

(2). 主线程发送循环

while(1) {
    printf("input sth:\n");
    fgets(buf, BUF_SIZE, stdin);  // 从标准输入读取
    
    // 设置目标地址（对方进程的套接字文件）
    bzero(&paddr, sizeof(paddr));
    paddr.sun_family = AF_UNIX;
    strncpy(paddr.sun_path, SOCK_PATH_B, sizeof(paddr.sun_path)-1);
    
    // 发送消息
    sendto(sfd, buf, strlen(buf), 0, 
          (struct sockaddr*)&paddr, sizeof(paddr));
}

五、完整代码实现

fileb:


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<string.h>
#include<pthread.h>
#include<unistd.h>
#define SOCK_PATH_A "/tmp/uds_filea"
#define SOCK_PATH_B "/tmp/uds_fileb"
#define BUF_SIZE 256

void *recv_msg(void *arg)
{
    int sfd = *(int *)arg;
    char buf[BUF_SIZE];
    struct sockaddr_un paddr;
    socklen_t len = sizeof(paddr);
    while(1)
    {
        ssize_t n = recvfrom(sfd,buf,BUF_SIZE-1,0,(struct sockaddr*)&paddr,&len);
        if(n > 0)
        {
            buf[n] = '\0';
            printf("peer say:%s",buf);
        }
    }
    return NULL;
}

int main()
{
    struct sockaddr_un myaddr,paddr;
    int sfd;
    pthread_t tid;
    
    sfd = socket(AF_UNIX,SOCK_DGRAM,0);
    if(sfd < 0)
    {
        perror("socket falied");
        exit(1);
    }
    //绑定地址
    unlink(SOCK_PATH_A);
    bzero(&myaddr,sizeof(myaddr));
    myaddr.sun_family = AF_UNIX;
    strncpy(myaddr.sun_path,SOCK_PATH_A,sizeof(myaddr.sun_path)-1);
    
    if( bind(sfd,(struct sockaddr*)&myaddr,sizeof(myaddr)) < 0)
    {
        perror("bind failed");
        exit(1);
    }
    //创建次线程接收
    if(pthread_create(&tid,NULL,recv_msg,&sfd) != 0)
    {
        perror("pthread_create failed");
        exit(1);
    }
    //主线程循环发送消息
    bzero(&paddr,sizeof(paddr));
    paddr.sun_family = AF_UNIX;
    strncpy(paddr.sun_path,SOCK_PATH_B,sizeof(paddr.sun_path)-1);
    char buf[BUF_SIZE];
    while(1)
    {
        printf("input sth:\n");
        fgets(buf,BUF_SIZE,stdin);
        sendto(sfd,buf,strlen(buf),0,(struct sockaddr*)&paddr,sizeof(paddr));
    }
    close(sfd);
    unlink(SOCK_PATH_A);
    return 0;
}

fileb:


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/socket.h>
#include<sys/un.h>
#include<pthread.h>

#define SOCK_PATH_A "/tmp/uds_filea"
#define SOCK_PATH_B "/tmp/uds_fileb"
#define BUF_SIZE 256

//次线程处理接收
void *recv_msg(void *arg)
{
    int sfd = *(int *)arg;
    char buf[BUF_SIZE];
    struct sockaddr_un paddr;
    socklen_t len = sizeof(paddr);
    //无限循环接收消息
    while(1)
    {
        ssize_t n = recvfrom(sfd,buf,BUF_SIZE-1,0,(struct sockaddr*)&paddr,&len);
        //接收成功打印
        if(n>0)
        {
            buf[n] = '\0';
            printf("peer say:%s",buf);
        }
        else if (n<0)
        {
            perror("recvfrom failed");
            continue;
        }
    }
    return NULL;
}

int main()
{
    int sfd;
    struct sockaddr_un myaddr,paddr;
    pthread_t tid;
    //创建域数据报套接字
    sfd = socket(AF_UNIX,SOCK_DGRAM,0);
    if(sfd < 0)
    {
        perror("socket failed");
        exit(1);
    }
    //删除就套接字文件
    unlink(SOCK_PATH_B);
    bzero(&myaddr,sizeof(myaddr));
    //设置地址族
    myaddr.sun_family = AF_UNIX;
    strncpy(myaddr.sun_path,SOCK_PATH_B,sizeof(myaddr.sun_path));
    //绑定地址
    if(bind(sfd,(struct sockaddr*)&myaddr,sizeof(myaddr)) < 0)
    {
        perror("bind failed");
        exit(1);
    }
    //创建次线程处理接收
    if(pthread_create(&tid,NULL,recv_msg,&sfd) != 0)
    {
        perror("pthread_create falied");
        exit(1);
    }
    //主线程循环发送消息
    bzero(&paddr,sizeof(paddr));
    paddr.sun_family = AF_UNIX;
    strncpy(paddr.sun_path,SOCK_PATH_A,sizeof(paddr.sun_path)-1);
    char buf[BUF_SIZE];
    while(1)
    {
        printf("input sth:\n");
        fgets(buf,BUF_SIZE,stdin);
        sendto(sfd,buf,strlen(buf),0,(struct sockaddr*)&paddr,sizeof(paddr));
    }
    close(sfd);
    unlink(SOCK_PATH_B);
    return 0;
}

重要注意事项

1. 文件路径选择

使用/tmp目录：系统重启自动清理

路径长度限制：sun_path最多108字节

权限问题：确保有权限在目标目录创建文件

2. 线程安全

线程分离：接收线程设置为分离状态可避免资源泄漏

信号处理：考虑添加信号处理，优雅终止线程

资源清理：确保程序退出时删除套接字文件

六、编译与运行

# 1. 分别编译两个进程
gcc -o filea filea.c -Wall -pthread
gcc -o fileb fileb.c -Wall -pthread

# 2. 在两个不同的终端运行
# 终端1 - 运行进程A
./filea

# 终端2 - 运行进程B  
./fileb

# 3. 测试通信
# 在进程A的终端输入: Hello from A
# 在进程B的终端可以看到: peer say: Hello from A
# 在进程B的终端输入: Hi from B  
# 在进程A的终端可以看到: peer say: Hi from B

七、遇到的问题与解决

问题1：bind: Address already in use 现象：程序启动失败，提示地址已被使用原因：上次运行后套接字文件未删除解决：确保每次启动前调用unlink()删除文件

问题2：Permission denied 现象：无法在指定路径创建套接字文件原因：对目标目录没有写权限解决：使用/tmp目录或确保有足够权限

问题3：消息丢失现象：发送速度快时部分消息丢失原因：数据报套接字不保证可靠性解决：

实现应用层确认机制

使用流式套接字(SOCK_STREAM)

添加消息序列号和重传机制

八、Unix域套接字 vs 其他IPC方式

IPC方式	特点	适用场景
Unix域套接字	类似网络编程接口，支持流和数据报	需要类似网络接口的IPC
管道(pipe)	单向字节流，有亲缘关系限制	父子进程间通信
FIFO(命名管道)	单向字节流，无亲缘关系限制	无亲缘关系进程间通信
消息队列	结构化消息，支持优先级	需要消息分类的通信
共享内存	最快，需要同步机制	大数据量、高性能通信

关键收获 ✅

Unix域套接字原理：掌握了基于文件系统的本地IPC机制

双向通信模型：实现了主线程发送+次线程接收的并发模型

地址管理：学会了使用文件路径作为通信地址

资源管理：理解了套接字文件的创建和清理

性能优势

高效：数据直接在内核空间传递，无需网络协议栈

低延迟：比网络套接字通信快2-3倍

安全：仅限于本机通信，无网络暴露风险

应用场景

数据库连接：客户端与本地数据库服务通信

GUI应用：图形界面与后台服务通信

系统服务：系统守护进程间的通信

容器内部：Docker容器内进程间通信

扩展方向

可靠性增强：实现消息确认和重传机制

多客户端支持：扩展为服务器-多客户端模型

性能优化：使用内存映射文件或共享内存

安全增强：添加权限控制和消息加密

导航：

广播 on MeloBrush的技术博客

01-UDP基础编程：Linux下C语言Socket通信实战

一、实验目的

二、核心原理与概念

通信特点

通信流程

网络通信的三种情况

三、核心函数详解

3.1 关键函数

1.socket() - 创建通信端点

2.bind()-绑定地址（服务器必需）

3.sendto()- 发送UDP数据报

4.recvfrom()-接收UDP数据报

3.2 辅助函数与字节序转换

1.地址转换函数

2.字节序转换函数

3.3关键数据结构

四.实现步骤分析

服务器端实现步骤

1.创建udp套接字

2.准备并绑定服务器地址

3.循环接收与处理数据址

3.3客户端实现步骤

1.创建udp套接字

2.设置目标服务器地址

3.发送与接收循环

四、完整代码实现

1.服务端：

2.客户端：

3.编译运行：

五.遇到的问题

六.学习总结

下一步

02-udp-broadcast-programming

一、实验目的

二、核心原理/知识点

2.1 广播概述

2.2 广播地址

三、核心函数详解

setsockopt() - 设置套接字选项

四、实现步骤分解

发送端

1.创建UDP套接字

2.启用套接字广播选项 (关键步骤)

3.设置目标广播地址

4.循环发送广播消息

接收端

1.创建UDP套接字

2.绑定到任意地址和广播端口

3.循环接收广播消息

五、完整代码实现

发送端：

接收端：

六、编译与运行

七、遇到的问题与解决

八、实验总结与思考

03-udp-multicast-programming

一、实验目的

二、核心原理/知识点

1. 多播（组播）特点

2.IP多播地址分类

三、核心函数详解

3.1 新函数解析

3.2 关键数据结构

四、实现步骤分解

服务端

1.创建udp套接字

2.绑定服务器地址

3.配置多播参数

4. 发送多播数据

客户端

1. 创建UDP套接字并绑定

2. 加入多播组

3. 接收多播数据

重要注意事项

五、完整代码实现

服务端

客户端

六、编译与运行

重要注意事项

1.`socket()` - 创建通信端点

2.`bind()`-绑定地址（服务器必需）

3.`sendto()`- 发送UDP数据报

4.`recvfrom()`-接收UDP数据报