原文地址: https://blog.csdn.net/lyztyycode/article/details/80865617
以前自己写的代码都只是在本地进行c/s通信，今天想写一个可以跨越外网的c/s通信，这里我就用udp实现一个点对点的不同外网的通信。用到的技术就是nat穿透技术，这里最直接使用的就是udp打洞技术。文中如有表述不清楚，欢迎提问。
如果你需要nat穿透技术的详解点这里：nat穿透浅析
需要的设备：
一个已知的外网服务器S（ip+port），两个位于不同外网的客户端A， B
首先要知道udp打洞的流程：
1.A客户端发消息给S，B客户端发消息给服务器S。
2.S转发A的ip+port（这里是A的外网ip+port，位于nat转发器上）给客户端B，S转发B的ip+port给客户端A。
这样A，B都知道了对端的ip+port。
3.A发消息给B，这里，B会屏蔽掉这条消息，但是在A的nat映射上加上了一条映射，允许A接收来自B的消息。在A上打洞
B-->A。
4.B发消息给A，这里，由于流程3A能接收到这条消息，同时在B的nat映射上加了一条映射，允许B接收来自A的消息。在B上
打洞，A-->B。
5.到此，A，B打洞成功。
我在学习这块知识的时候看网上的案例和解释大多是相互转发，而且表达不清楚，代码实例拿来用也是问题百出，解决不了实际问题，所以自己也是严格要求自己，有问题的代码不敢贴出来。
下面是代码，实现的是A回射B的消息。
服务器S的代码：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <string.h>
#include <arpa/inet.h>
#include <errno.h>
#include <error.h>
//中间枢纽获得A客户端的外网ip和port发送给客户端B，获得客户端B的外网ip和port发送给A
//B通过A打的洞发数据给A，这时候A拒收B的消息，因为A的nat映射中没有B的信息，但是这次通
//信却在B的网管中添加了映射可以接受A的
//消息，同理A通过B打的洞发数据给B，这时候由于B可以接受A的消息，所以数据接收成功且在A
//的映射中加入了B的信息，从而A与B可以跨服务器通信。实现p2p
/* 由于已知的外网服务器S可能并没有AB客户端的映射关系，所以要先建立A与S 还有 B与S之间的映射，这样才能进行udp穿透。 */
#define ERR_EXIT(m)\
do{\
perror(m);\
exit(1);\
}while(0)
/* 用来记录客户端发送过来的外网ip+port */
typedef struct{
struct in_addr ip;
int port;
}clientInfo;
int main()
{
/* 一个客户端信息结构体数组，分别存放两个客户端的外网ip+port */
clientInfo info[2];
/* 作为心跳包需要接收的一个字节 */
/* char ch; */
char str[10] = {0};
/* udp socket描述符 */
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sockfd == -1)
ERR_EXIT("SOCKET");
struct sockaddr_in serveraddr;
memset(&serveraddr, 0, sizeof(serveraddr));
serveraddr.sin_addr.s_addr = inet_addr("0.0.0.0");
serveraddr.sin_port = htons(8888);
serveraddr.sin_family = AF_INET;
int ret = bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
if(ret == -1)
ERR_EXIT("BIND");
/* 服务器接收客户端发来的消息并转发 */
while(1)
{
bzero(info, sizeof(clientInfo)*2);
/* 接收两个心跳包并记录其与此链接的ip+port */
socklen_t addrlen = sizeof(struct sockaddr_in);
/* recvfrom(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, &addrlen); */
recvfrom(sockfd, str, sizeof(str), 0, (struct sockaddr *)&serveraddr, &addrlen);
memcpy(&info[0].ip, &serveraddr.sin_addr, sizeof(struct in_addr));
info[0].port = serveraddr.sin_port;
printf("A client IP:%s \tPort:%d creat link OK!\n", inet_ntoa(info[0].ip), ntohs(info[0].port));
/* recvfrom(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, &addrlen); */
recvfrom(sockfd, str, sizeof(str), 0, (struct sockaddr *)&serveraddr, &addrlen);
memcpy(&info[1].ip, &serveraddr.sin_addr, sizeof(struct in_addr));
info[1].port = serveraddr.sin_port;
printf("B client IP:%s \tPort:%d creat link OK!\n", inet_ntoa(info[1].ip), ntohs(info[1].port));
/* 分别向两个客户端发送对方的外网ip+port */
printf("start informations translation...\n");
serveraddr.sin_addr = info[0].ip;
serveraddr.sin_port = info[0].port;
sendto(sockfd, &info[1], sizeof(clientInfo), 0, (struct sockaddr *)&serveraddr, addrlen);
serveraddr.sin_addr = info[1].ip;
serveraddr.sin_port = info[1].port;
sendto(sockfd, &info[0], sizeof(clientInfo), 0, (struct sockaddr *)&serveraddr, addrlen);
printf("send informations successful!\n");
}
return 0;
}
客户端A的代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
/* 原理见服务器源程序 */
#define ERR_EXIT(m)\
do{\
perror(m); \
exit(1);\
}while(0)
typedef struct{
struct in_addr ip;
int port;
}clientInfo;
/* 用于udp打洞成功后两个客户端跨服务器通信 */
void echo_ser(int sockfd, struct sockaddr* addr, socklen_t *len)
{
printf("start recv B data...\n");
char buf[1024];
while(1)
{
bzero(buf, sizeof(buf));
//接收B发来的数据
recvfrom(sockfd, buf, sizeof(buf)-1, 0, addr, len);
printf("%s \n", buf);
//向B发送数据
printf("send data to B ...\n");
sendto(sockfd, buf, sizeof(buf)-1, 0, addr, sizeof(struct sockaddr_in));
buf[strlen(buf)] = '\0';
if(strcmp(buf, "exit") == 0)
break;
}
}
int main()
{
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sockfd == -1)
ERR_EXIT("SOCKET");
//向服务器发送心跳包的一个字节的数据
char ch = 'a';
clientInfo info;
socklen_t addrlen = sizeof(struct sockaddr_in);
bzero(&info, sizeof(info));
struct sockaddr_in clientaddr;
memset(&clientaddr, 0, sizeof(clientaddr));
//实际情况下这里用一个已知的外网的服务器的端口号
clientaddr.sin_port = htons(8888);
//实际情况下这里用一个已知的外网的服务器的ip地址，这里保护我的云服务器ip所以没有写出来，自己换一下ip地址。
clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
clientaddr.sin_family = AF_INET;
/* 向服务器S发送数据包 */
sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&clientaddr, sizeof(struct sockaddr_in));
/* 接收B的ip+port */
printf("send success\n");
recvfrom(sockfd, &info, sizeof(clientInfo), 0, (struct sockaddr *)&clientaddr, &addrlen);
printf("IP: %s\tPort: %d\n", inet_ntoa(info.ip), ntohs(info.port));
clientaddr.sin_addr = info.ip;
clientaddr.sin_port = info.port;
sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&clientaddr, sizeof(struct sockaddr_in));
echo_ser(sockfd, (struct sockaddr *)&clientaddr, &addrlen);
close(sockfd);
return 0;
}
客户端B代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
/* 原理见服务器源程序 */
#define ERR_EXIT(m)\
do{\
perror(m); \
exit(1);\
}while(0)
typedef struct{
struct in_addr ip;
int port;
}clientInfo;
/* 用于udp打洞成功后两个客户端跨服务器通信 */
void echo_ser(int sockfd, struct sockaddr* addr, socklen_t *len)
{
char buf[1024];
while(1)
{
bzero(buf, sizeof(buf));
printf(">> ");
fflush(stdout);
fgets(buf, sizeof(buf)-1, stdin);
//向A发送数据
sendto(sockfd, buf, strlen(buf), 0, addr, sizeof(struct sockaddr_in));
//接收A发来的数据
bzero(buf, sizeof(buf));
printf("start recv A data...\n");
recvfrom(sockfd, buf, sizeof(buf)-1, 0, addr, len);
printf("%s \n", buf);
buf[strlen(buf)] = '\0';
if(strcmp(buf, "exit") == 0)
break;
}
}
int main()
{
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sockfd == -1)
ERR_EXIT("SOCKET");
//向服务器发送心跳包的一个字节的数据
char ch = 'a';
/* char str[] = "abcdefgh"; */
clientInfo info;
socklen_t addrlen = sizeof(struct sockaddr_in);
bzero(&info, sizeof(info));
struct sockaddr_in clientaddr, serveraddr;
/* 客户端自身的ip+port */
/* memset(&clientaddr, 0, sizeof(clientaddr)); */
/* clientaddr.sin_port = htons(8888); */
/* clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */
/* clientaddr.sin_family = AF_INET; */
/* 服务器的信息 */
memset(&clientaddr, 0, sizeof(clientaddr));
//实际情况下为一个已知的外网的服务器port
serveraddr.sin_port = htons(4399);
//实际情况下为一个已知的外网的服务器ip,这里仅用本地ip填充，下面这行的ip自己换成已知的外网服务器的ip
serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
/* clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); */
serveraddr.sin_family = AF_INET;
/* 向服务器S发送数据包 */
sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
/* sendto(sockfd, str, sizeof(str), 0, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in)); */
/* 接收B的ip+port */
printf("send success\n");
recvfrom(sockfd, &info, sizeof(clientInfo), 0, (struct sockaddr *)&serveraddr, &addrlen);
printf("IP: %s\tPort: %d\n", inet_ntoa(info.ip), ntohs(info.port));
serveraddr.sin_addr = info.ip;
serveraddr.sin_port = info.port;
sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
echo_ser(sockfd, (struct sockaddr *)&serveraddr, &addrlen);
close(sockfd);
return 0;
}
以上代码经过本人调试测验过的，可以实现跨外网通信，没有任何问题。
在写这个项目的时候遇到的问题：
1.起初，我本地的客户端一直连不上服务器S，即使代码我在本地测试成功的情况下，后来发现是因为我云服务器指定的监听端口8888没有开，不接收外来的消息。把端口开放，成功解决。
2.服务器S能接收AB的连接消息，也可以转发AB的ip和port给对端，AB也能获得对端的ip+port但是，当B发消息给A的时候A阻塞在while（1）循环中的第一个recvfrom上，为什么呢？
原因是打洞过程我少了流程3、4，因为B发送消息给A，A会屏蔽B的消息。此时A应该也给B发送一条消息。
所以我在原来A、B的代码
echo_ser(sockfd, (struct sockaddr *)&serveraddr, &addrlen);
前面都加了一句：
sendto(sockfd, &ch, sizeof(ch), 0, (struct sockaddr *)&serveraddr, sizeof(struct sockaddr_in));
这样无论A还是B先执行这条语句都能打洞成功，如果你在这条语句前面加一句sleep（5）你就能感知到打洞的过程。
到此，问题解决，实现了预期的功能，希望我的文章对你有帮助。如果有表述不清楚，欢迎提问。
