v1.0 2024年6月5日 发布于博客园

• 序言
  • UDP打洞的原理
  • 应用场景
• 基本理论
• 代码实现
  • udp_client_NAT.c
  • udp_server_NAT.c
  • 结果
• 参考链接

序言

UDP打洞（UDP Hole Punching）是一种用于在NAT（网络地址转换）设备后面建立直接P2P（点对点）连接的技术。NAT设备通常会阻止外部设备直接与内部设备通信，因为它们隐藏了内部网络的IP地址。UDP打洞通过利用NAT设备的行为特性来绕过这些限制，从而实现直接通信。

UDP打洞的原理

1. 初始连接：两个希望进行P2P通信的设备（称为A和B）首先都与一个公共服务器（称为中继服务器）建立连接。中继服务器记录下它们的公共IP地址和端口号。

2. 交换信息：中继服务器将A的公共IP地址和端口号发送给B，同时将B的公共IP地址和端口号发送给A。

3. 打洞尝试：A和B使用从中继服务器获得的对方的公共IP地址和端口号，尝试直接向对方发送UDP数据包。由于NAT设备通常会允许内部设备发起的连接通过，因此这些数据包会在NAT设备上打开一个临时的“洞”。

4. 建立连接：如果A和B的NAT设备都允许这种临时的“洞”，那么A和B就可以通过这些洞进行直接的P2P通信，而不再需要通过中继服务器。

应用场景

UDP打洞技术在许多应用中非常有用，尤其是在需要高效、低延迟的P2P通信时。以下是一些常见的应用场景：

1. 实时通信应用：如VoIP（网络电话）、视频聊天和在线游戏等。这些应用需要低延迟的通信，而通过中继服务器转发数据会增加延迟。

2. 文件共享：P2P文件共享网络（如BitTorrent）可以利用UDP打洞技术来建立直接连接，从而提高传输速度和效率。

3. 远程控制和协作：如远程桌面、在线协作工具等，通过直接P2P连接可以提供更流畅的用户体验。

4. 物联网（IoT）设备：许多IoT设备位于NAT设备后面，UDP打洞可以使它们更容易与外部服务器或其他设备直接通信。

5. 游戏主机和客户端：在线游戏通常需要快速的P2P连接来同步游戏状态和动作，UDP打洞技术可以显著改善游戏体验。

UDP打洞是一种非常有用的技术，尤其是在需要高效、低延迟的P2P通信的应用中。它通过巧妙地利用NAT设备的行为特性，使得位于NAT设备后面的设备也能够进行直接的P2P通信。

基本理论

/**
 * 前提: 服务器具有公网ip, 客户端和服务端已经协商好端口号
 *
 * 第一步: 客户端发送打洞包给服务器 C---NET--->S (此时客户端看得见服务器, 服务器看不见客户端)
 *         客户端向服务器发送一个UDP包。NAT设备会为这个连接分配一个公网IP和端口，并将包转发给服务器。
 *
 * 第二步: 服务器接收并记录客户端信息  (服务器记录客户端的网路信息, 但不知道万恶的运营商有没有关掉这条网路)
 *         服务器接收到包后，记录下客户端的公网IP和端口。
 *
 * 第三步: 服务器发送确认信息给客户端: C<---NET---S (服务器沿着原来的网路回传信息, 客户端若收到后维持网路)
 *         服务器向客户端发送确认消息，确保NAT设备为这对IP和端口建立了映射。
 *
 * 第四步: 保存映射:C<---NET--->S 需要不断发送保活包, 建议为1/2超时时间 (这条路可通, 不断维持这条路)
 *          客户端和服务器通过发送UDP包来保持这个映射。只要映射存在，后续的UDP包可以直接穿过NAT设备。
 *          NAT设备会在一段时间内没有检测到任何活动后关闭映射。这段时间通常被称为“空闲超时时间”或“会话超时时间”。
 *          UDP超时时间：常见的默认值是30秒、60秒或120秒。
 *          TCP超时时间: 通常在数分钟到数小时之间。
 */

由于我并不需要实现2个客户端的直接通信(增加一个中间服务器即可), 而是在典型的NAT穿透场景中，知道服务器端的公网IP和端口，但不知道客户端的公网IP，可以通过一些技巧来实现UDP打洞。以下是一个可能的方案：

1. 服务器端：服务器端监听来自客户端的连接请求，并记录客户端的公网IP和端口。
2. 客户端：客户端向服务器发送一个初始消息，服务器记录该消息的来源IP和端口。
3. 服务器：服务器将记录的客户端IP和端口返回给客户端。
4. 双方打洞：客户端和服务器通过发送UDP包到对方的IP和端口来打洞。

代码实现

编译命令：cc udp_client_NAT.c -o udp_client_NAT.out -pthread

udp_client_NAT.c

/**
 * @file name : udp_client_NAT.c
 * @brief     : 用于实现基本的UDP客户端和服务器端打洞
 * @author    : [email protected]
 * @date      : 2024/04/07
 * @version   : 1.0
 * @note      :
 * CopyRight (c)  2023-2024   [email protected]   All Right Reseverd
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <errno.h>

#define SERVER_PORT 50001            // 公网服务器的端口
#define SERVER_ADDR "120.79.143.250" // 公网服务器的IP地址
#define BUF_SIZE 1024                // 缓冲区大小(字节)
#define KEEP_ALIVE_INTERVAL 25       // 保活包发送间隔
// 保活包的网路信息
typedef struct
{
    int sock_fd;                    // 套接字文件描述符
    struct sockaddr_in socket_addr; // 定义套接字所需的地址信息结构体
    socklen_t addr_len;             // 目标地址的长度
    pthread_mutex_t *mutex;         // 互斥锁变量
} KeepAlivePackageArgs_t;

/**
 * @name      keep_alive
 * @brief     保活线程函数, 用于保持活路
 * @param     args 线程例程参数, 传入保活包的网络信息
 * @note
 */
void *keep_alive(void *args)
{
    // 用于传入的是void* 需要强转才能正确指向
    KeepAlivePackageArgs_t *ka_args = (KeepAlivePackageArgs_t *)args;
    char keep_alive_msg[] = "KEEP_ALIVE_CLIENT"; // 发送给服务器的保活包, 表示我是客户端, C---NET-->S
    while (1)
    {
        /**
         * 对互斥锁进行上锁，如果主线程未上锁，则此次调用会上锁成功，函数调用将立马返回；
         * 如果互斥锁此时已经被其它线程锁定了，会一直阻塞，直到该互斥锁被解锁，到那时，调用将锁定互斥锁并返回。
         */
        pthread_mutex_lock(ka_args->mutex);
        sendto(ka_args->sock_fd,
               keep_alive_msg,
               strlen(keep_alive_msg),
               MSG_CONFIRM, // 帮助你确认数据包的路径可达性。具体地，内核会尝试确认目标地址是可达的，并且路径是有效的。且避免不必要的探测.
               (const struct sockaddr *)&ka_args->socket_addr,
               ka_args->addr_len);
        pthread_mutex_unlock(ka_args->mutex); // 解锁
        printf("\n客户端已发服务器送保活包\n");
        sleep(KEEP_ALIVE_INTERVAL); // 定期保活
    }
}

int main(int argc, char const *argv[])
{

    char validbuffer[BUF_SIZE]; // 传回的有效数据
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, NULL); // 初始化套接字文件互斥锁
    /**********************第一步: 客户端发送打洞包给服务器 C---NET--->S******************************/
    /*****①创建套接字文件描述符****/
    int client_sock_fd = socket(AF_INET, SOCK_DGRAM, 0); // 创建客户端套接字文件描述符 ipv4 udp 默认协议选择
    if (0 > client_sock_fd)
    {
        fprintf(stderr, "客户端UDP套接字文件错误,errno:%d,%s\n", errno, strerror(errno));
        exit(1);
    }
    /****************END***************/

    /****************②发送信息给服务器****************/
    // 服务器的IP信息结构体
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));

    // 配置服务器IP信息结构体
    server_addr.sin_family = AF_INET;                     // ipv4协议簇
    server_addr.sin_addr.s_addr = inet_addr(SERVER_ADDR); // 服务器公网IP
    server_addr.sin_port = htons(SERVER_PORT);            // 服务器端口

    // 向服务器发送打洞包
    char buffer[BUF_SIZE] = "HELLO_SERVER";                            // 发送给服务器的打洞包 内容无所谓
    socklen_t addr_len = sizeof(struct sockaddr_in);                   // 信息结构体长度
    ssize_t sent_bytes = sendto(client_sock_fd,                        // 客户端套接字文件描述符
                                buffer,                                // 要发送的数据缓冲区
                                strlen(buffer),                        // 要发送的字符串长度
                                MSG_CONFIRM,                           // 确认数据包有效性标志位
                                (const struct sockaddr *)&server_addr, // 指向包含目标地址的 sockaddr 结构体
                                addr_len);                             // 目标地址的长度
    if (sent_bytes == -1)
    {
        fprintf(stderr, "发送数据失败, errno:%d, %s\n", errno, strerror(errno));
        close(client_sock_fd);
        exit(1);
    }
    memset(buffer, 0x0, sizeof(buffer)); // 清空buffer

    /****************END***************/
    /************************************END*****************************************/

    // 第二步由服务器完成

    /**********************第三步: 服务器发送确认信息给客户端: C<---NET---S******************************/
    // 接收来自服务器的确认消息
    int n = recvfrom(client_sock_fd,                  // 套接字文件描述符
                     buffer,                          // 接收数据的缓冲区
                     BUF_SIZE,                        // 缓冲区的长度
                     0,                               // MSG_WAITALL 严格等待完整的数据,会一直阻塞，直到接收到指定数量的字节（即 BUF_SIZE）或者发生错误为止。它确保接收到的数据量满足请求的大小。
                     (struct sockaddr *)&server_addr, // 指向存储源地址的 sockaddr 结构体
                     &addr_len);                      // 指向源地址长度的指针
    buffer[n] = '\0';                                 // 将接收到的数据转换为字符串
    printf("打洞中, 从服务器收到: %s\n", buffer);
    /************************************END*****************************************/

    /**********************第四步: 保存映射:C<---NET--->S *******************************************/
    // 新线程的TID
    pthread_t keep_alive_thread;
    // 定义线程保活包的网络信息
    KeepAlivePackageArgs_t ka_args;
    // 设置保活线程参数
    ka_args.sock_fd = client_sock_fd;
    ka_args.socket_addr = server_addr;
    ka_args.addr_len = addr_len;
    ka_args.mutex = &mutex;
    // 创建保活线程  并将保活包的网络信息传入线程
    if (pthread_create(&keep_alive_thread, NULL, keep_alive, (void *)&ka_args) != 0)
    {
        fprintf(stderr, "创建保活线程错误, errno:%d,%s\n", errno, strerror(errno));
        close(client_sock_fd);
        exit(1);
    }
    /************************************END*****************************************/

    /************************************正常收发数据部分*******************************************/
    // // 发送消息给服务器端
    // const char *message = "我是客户端!";
    // size_t message_len = strlen(message);
    // 主循环：接收和处理服务器消息
    while (1)
    {
        // 发送消息给服务器端

        // 从键盘输入字符串
        char message[BUF_SIZE];
        printf("请输入要发送给服务器的消息: ");
        if (fgets(message, BUF_SIZE, stdin) == NULL)
        {
            perror("fgets error");
            continue;
        }

        // 移除换行符
        size_t message_len = strlen(message);
        if (message[message_len - 1] == '\n')
        {
            message[message_len - 1] = '\0';
            message_len--;
        }

        // 向服务器发送数据
        pthread_mutex_lock(&mutex); // 对套接字文件上锁
        sendto(client_sock_fd, message, message_len, MSG_CONFIRM, (const struct sockaddr *)&server_addr, addr_len);
        pthread_mutex_unlock(&mutex); // 对套接字文件解锁

        // 接收来自服务器的消息
        pthread_mutex_lock(&mutex); // 对套接字文件上锁
        n = recvfrom(client_sock_fd, buffer, BUF_SIZE, 0, (struct sockaddr *)&server_addr, &addr_len);
        pthread_mutex_unlock(&mutex); // 对套接字文件解锁
        if (n < 0)
        {
            perror("recvfrom error");
            continue;
        }
        buffer[n] = '\0';

        // 判断是否是保活信息
        if (strcmp(buffer, "KEEP_ALIVE_SERVER") != 0) // 若收到的不是保活信息, 则为有效信息
        {
            // 有效信息, 不是保活信息，处理并存储
            printf("★收到有效信息: %s\n", buffer);
            memcpy(validbuffer, buffer, n + 1); // 使用 memcpy 代替 strncpy
        }
        else
        {
            printf("\n从服务器收到保活信息: %s\n", buffer);
        }

        // 清空 buffer
        memset(buffer, 0, BUF_SIZE);
    }
    /************************************END*****************************************/

    close(client_sock_fd); // 关闭套接字文件
    return 0;
}
/**
 * 前提: 服务器具有公网ip, 客户端和服务端已经协商好端口号
 *
 * 第一步: 客户端发送打洞包给服务器 C---NET--->S (此时客户端看得见服务器, 服务器看不见客户端)
 *         客户端向服务器发送一个UDP包。NAT设备会为这个连接分配一个公网IP和端口，并将包转发给服务器。
 *
 * 第二步: 服务器接收并记录客户端信息  (服务器记录客户端的网路信息, 但不知道万恶的运营商有没有关掉这条网路)
 *         服务器接收到包后，记录下客户端的公网IP和端口。
 *
 * 第三步: 服务器发送确认信息给客户端: C<---NET---S (服务器沿着原来的网路回传信息, 客户端若收到后维持网路)
 *         服务器向客户端发送确认消息，确保NAT设备为这对IP和端口建立了映射。
 *
 * 第四步: 保存映射:C<---NET--->S 需要不断发送保活包, 建议为1/2超时时间 (这条路可通, 不断维持这条路)
 *          客户端和服务器通过发送UDP包来保持这个映射。只要映射存在，后续的UDP包可以直接穿过NAT设备。
 *          NAT设备会在一段时间内没有检测到任何活动后关闭映射。这段时间通常被称为“空闲超时时间”或“会话超时时间”。
 *          UDP超时时间：常见的默认值是30秒、60秒或120秒。
 *          TCP超时时间: 通常在数分钟到数小时之间。
 */

udp_server_NAT.c

/**
 * @file name : udp_server_NAT.c
 * @brief     : 用于实现基本的UDP客户端和服务器端打洞
 * @author    : [email protected]
 * @date      : 2024/04/07
 * @version   : 1.0
 * @note      :
 * CopyRight (c)  2023-2024   [email protected]   All Right Reseverd
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <errno.h>

#define CLIENT_PORT 50001      // 客户端的端口
#define BUF_SIZE 1024          // 缓冲区大小(字节)
#define KEEP_ALIVE_INTERVAL 25 // 保活包发送间隔

// 保活包的网路信息
typedef struct
{
    int sock_fd;                    // 套接字文件描述符
    struct sockaddr_in socket_addr; // 定义套接字所需的地址信息结构体
    socklen_t addr_len;             // 目标地址的长度
    pthread_mutex_t *mutex;         // 互斥锁变量
} KeepAlivePackageArgs_t;

/**
 * @name      keep_alive
 * @brief     保活线程函数, 用于保持活路
 * @param     args 线程例程参数, 传入保活包的网络信息
 * @note
 */
void *keep_alive(void *args)
{
    // 用于传入的是void* 需要强转才能正确指向
    KeepAlivePackageArgs_t *ka_args = (KeepAlivePackageArgs_t *)args;
    char keep_alive_msg[] = "KEEP_ALIVE_SERVER"; // 发送给客户端的保活包, 表示我是服务器, C<---NET--S

    for (;;)
    {
        /**
         * 对互斥锁进行上锁，如果主线程未上锁，则此次调用会上锁成功，函数调用将立马返回；
         * 如果互斥锁此时已经被其它线程锁定了，会一直阻塞，直到该互斥锁被解锁，到那时，调用将锁定互斥锁并返回。
         */
        pthread_mutex_lock(ka_args->mutex);
        sendto(ka_args->sock_fd,
               keep_alive_msg,
               strlen(keep_alive_msg),
               MSG_CONFIRM, // 帮助你确认数据包的路径可达性。具体地，内核会尝试确认目标地址是可达的，并且路径是有效的。且避免不必要的探测.
               (const struct sockaddr *)&ka_args->socket_addr,
               ka_args->addr_len);
        pthread_mutex_unlock(ka_args->mutex); // 解锁
        printf("\n服务器已向客户端发送保活包\n");
        sleep(KEEP_ALIVE_INTERVAL);
    }
}
int main(int argc, char const *argv[])
{
    char validbuffer[BUF_SIZE]; // 传回的有效数据
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, NULL); // 初始化套接字文件互斥锁
    /**********************第二步: 服务器接收并记录客户端信息 C---NET--->S******************************/

    /*****①创建套接字文件描述符并绑定接收****/
    int server_sock_fd = socket(AF_INET, SOCK_DGRAM, 0); // 创建客户端套接字文件描述符 ipv4 udp 默认协议选择
    if (0 > server_sock_fd)
    {
        fprintf(stderr, "服务器端创建UDP套接字文件错误,errno:%d,%s\n", errno, strerror(errno));
        exit(1);
    }

    // 服务器端的IP信息结构体
    struct sockaddr_in server_addr;

    // 配置服务器地址信息 接受来自任何地方的数据 包有效 但只解析50001端口的包
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(CLIENT_PORT);

    // 绑定socket到指定端口
    if (bind(server_sock_fd, (const struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
    {
        fprintf(stderr, "将服务器套接字文件描述符绑定IP失败, errno:%d,%s\n", errno, strerror(errno));
        close(server_sock_fd);
        exit(1);
    }

    printf("服务器已经运行, 等待客户端响应中...\n");

    /****************END***************/

    /****************②接收客户端的打洞包****************/
    char buffer[BUF_SIZE];               // 存放接收到的数据缓冲区
    memset(buffer, 0x0, sizeof(buffer)); // 清空buffer

    struct sockaddr_in client_addr;
    socklen_t addr_len = sizeof(struct sockaddr_in);

    int n = recvfrom(server_sock_fd, buffer, BUF_SIZE, 0, (struct sockaddr *)&client_addr, &addr_len);
    buffer[n] = '\0';

    printf("解除阻塞, 从客户端收到信息: %s\n", buffer);
    printf("客户端NAT地址: %s:%d\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

    /****************END***************/
    /************************************END*****************************************/
    /**********************第三步: 服务器发送确认信息给客户端: C<---NET---S******************************/
    // 向客户端发送确认消息
    char ack_msg[BUF_SIZE];
    snprintf(ack_msg, BUF_SIZE, "ACK %s %d", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    sendto(server_sock_fd, ack_msg, strlen(ack_msg), MSG_CONFIRM, (const struct sockaddr *)&client_addr, addr_len);
    memset(buffer, 0x0, sizeof(buffer)); // 清空buffer
    printf("打洞完成, 进入交互\n");
    /************************************END*****************************************/
    /**********************第四步: 保存映射:C<---NET--->S *******************************************/
    // 新线程的TID
    pthread_t keep_alive_thread;
    // 定义线程保活包的网络信息
    KeepAlivePackageArgs_t ka_args;
    // 设置保活线程参数
    ka_args.sock_fd = server_sock_fd;
    ka_args.socket_addr = client_addr;
    ka_args.addr_len = addr_len;
    ka_args.mutex = &mutex;
    // 创建保活线程  并将保活包的网络信息传入线程
    if (pthread_create(&keep_alive_thread, NULL, keep_alive, (void *)&ka_args) != 0)
    {
        fprintf(stderr, "创建保活线程错误, errno:%d,%s\n", errno, strerror(errno));
        close(server_sock_fd);
        exit(1);
    }
    /************************************END*****************************************/
    // 发送消息给客户端
    const char *message = "我是服务器, 收到请回答!";
    size_t message_len = strlen(message);
    // 主循环：接收和响应客户端消息
    while (1)
    {
        // 发送消息给客户端
        pthread_mutex_lock(&mutex); // 对套接字文件上锁
        sendto(server_sock_fd, message, message_len, MSG_CONFIRM, (const struct sockaddr *)&client_addr, addr_len);
        pthread_mutex_unlock(&mutex); // 对套接字文件解锁

        // 接收来自客户端的消息
        pthread_mutex_lock(&mutex); // 对套接字文件上锁
        n = recvfrom(server_sock_fd, buffer, BUF_SIZE, 0, (struct sockaddr *)&client_addr, &addr_len);
        pthread_mutex_unlock(&mutex); // 对套接字文件解锁
        if (n < 0)
        {
            perror("recvfrom error");
            continue;
        }
        buffer[n] = '\0';

        // 判断是否是保活信息
        if (strcmp(buffer, "KEEP_ALIVE_CLIENT") != 0) // 若收到的不是保活信息, 则为有效信息
        {
            // 有效信息, 不是保活信息，处理并存储
            printf("★收到有效信息: %s\n", buffer);
            memcpy(validbuffer, buffer, n + 1); // 使用 memcpy 代替 strncpy
        }
        else
        {
            printf("\n从客户端收到保活信息: %s\n", buffer);
        }

        // 清空 buffer
        memset(buffer, 0, BUF_SIZE);
    }

    close(server_sock_fd);
    return 0;
}
/**
 * 前提: 服务器具有公网ip, 客户端和服务端已经协商好端口号
 *
 * 第一步: 客户端发送打洞包给服务器 C---NET--->S (此时客户端看得见服务器, 服务器看不见客户端)
 *         客户端向服务器发送一个UDP包。NAT设备会为这个连接分配一个公网IP和端口，并将包转发给服务器。
 *
 * 第二步: 服务器接收并记录客户端信息  (服务器记录客户端的网路信息, 但不知道万恶的运营商有没有关掉这条网路)
 *         服务器接收到包后，记录下客户端的公网IP和端口。
 *
 * 第三步: 服务器发送确认信息给客户端: C<---NET---S (服务器沿着原来的网路回传信息, 客户端若收到后维持网路)
 *         服务器向客户端发送确认消息，确保NAT设备为这对IP和端口建立了映射。
 *
 * 第四步: 保存映射:C<---NET--->S 需要不断发送保活包, 建议为1/2超时时间 (这条路可通, 不断维持这条路)
 *          客户端和服务器通过发送UDP包来保持这个映射。只要映射存在，后续的UDP包可以直接穿过NAT设备。
 *          NAT设备会在一段时间内没有检测到任何活动后关闭映射。这段时间通常被称为“空闲超时时间”或“会话超时时间”。
 *          UDP超时时间：常见的默认值是30秒、60秒或120秒。
 *          TCP超时时间: 通常在数分钟到数小时之间。
 */

结果

打洞模块编写成功, 可实现内网客户端与服务器相互UDP通信

参考链接

• P2P通信原理与实现（C语言） - 知乎 (zhihu.com)
• UDP内网穿透和打洞原理与代码实现 - 知乎 (zhihu.com)