NET技术详解

最新推荐文章于 2023-07-13 06:21:33 发布

little_ox

最新推荐文章于 2023-07-13 06:21:33 发布

阅读量908

点赞数

分类专栏：物联网学习

原文链接：https://blog.csdn.net/lyztyycode/article/details/80865617

版权

物联网学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

以前自己写的代码都只是在本地进行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代码：

/* 原理见服务器源程序 */
#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）你就能感知到打洞的过程。

到此，问题解决，实现了预期的功能，希望我的文章对你有帮助。如果有表述不清楚，欢迎提问

版权声明：本文为CSDN博主「吃个椰子压压惊」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/lyztyycode/article/details/80865617

little_ox

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
NET技术详解

以前自己写的代码都只是在本地进行c/s通信，今天想写一个可以跨越外网的c/s通信，这里我就用udp实现一个点对点的不同外网的通信。用到的技术就是nat穿透技术，这里最直接使用的就是udp打洞技术。文中如有表述不清楚，欢迎提问。如果你需要nat穿透技术的详解点这里：nat穿透浅析需要的设备：一个已知的外网服务器S（ip+port），两个位于不同外网的客户端A， B首先要知道udp打洞的流程：...
复制链接

扫一扫