UDP内网穿透和打洞原理的C语言代码实现
v1.0 2024年6月5日 发布于博客园
序言
UDP打洞（UDP Hole Punching）是一种用于在NAT（网络地址转换）设备后面建立直接P2P（点对点）连接的技术。NAT设备通常会阻止外部设备直接与内部设备通信，因为它们隐藏了内部网络的IP地址。UDP打洞通过利用NAT设备的行为特性来绕过这些限制，从而实现直接通信。
UDP打洞的原理
-
初始连接：两个希望进行P2P通信的设备（称为A和B）首先都与一个公共服务器（称为中继服务器）建立连接。中继服务器记录下它们的公共IP地址和端口号。
-
交换信息：中继服务器将A的公共IP地址和端口号发送给B，同时将B的公共IP地址和端口号发送给A。
-
打洞尝试：A和B使用从中继服务器获得的对方的公共IP地址和端口号，尝试直接向对方发送UDP数据包。由于NAT设备通常会允许内部设备发起的连接通过，因此这些数据包会在NAT设备上打开一个临时的“洞”。
-
建立连接：如果A和B的NAT设备都允许这种临时的“洞”，那么A和B就可以通过这些洞进行直接的P2P通信，而不再需要通过中继服务器。
应用场景
UDP打洞技术在许多应用中非常有用，尤其是在需要高效、低延迟的P2P通信时。以下是一些常见的应用场景：
-
实时通信应用：如VoIP（网络电话）、视频聊天和在线游戏等。这些应用需要低延迟的通信，而通过中继服务器转发数据会增加延迟。
-
文件共享：P2P文件共享网络（如BitTorrent）可以利用UDP打洞技术来建立直接连接，从而提高传输速度和效率。
-
远程控制和协作：如远程桌面、在线协作工具等，通过直接P2P连接可以提供更流畅的用户体验。
-
物联网（IoT）设备：许多IoT设备位于NAT设备后面，UDP打洞可以使它们更容易与外部服务器或其他设备直接通信。
-
游戏主机和客户端：在线游戏通常需要快速的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打洞。以下是一个可能的方案：
- 服务器端：服务器端监听来自客户端的连接请求，并记录客户端的公网IP和端口。
- 客户端：客户端向服务器发送一个初始消息，服务器记录该消息的来源IP和端口。
- 服务器：服务器将记录的客户端IP和端口返回给客户端。
- 双方打洞：客户端和服务器通过发送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 : RISE_AND_GRIND@163.com
* @date : 2024/04/07
* @version : 1.0
* @note :
* CopyRight (c) 2023-2024 RISE_AND_GRIND@163.com 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 : RISE_AND_GRIND@163.com
* @date : 2024/04/07
* @version : 1.0
* @note :
* CopyRight (c) 2023-2024 RISE_AND_GRIND@163.com 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通信
参考链接
本文来自博客园，作者：舟清颺，转载请注明原文链接：https://www.cnblogs.com/zqingyang/p/18232244