鸿蒙开发进阶（HarmonyOS）VPN虚拟专网管理（仅对体系应用开放） ...

 鸿蒙NEXT开发实战往期必看文章：
一分钟相识”纯血版！鸿蒙HarmonyOS Next应用开发！
“非常详细的” 鸿蒙HarmonyOS Next应用开发学习蹊径！（从零基础入门到精通）
HarmonyOS NEXT应用开发案例实践总联合（持续更新......）
HarmonyOS NEXT应用开发性能优化实践总结（持续更新......）

---

简介

VPN 即虚拟专网（VPN-Virtual Private Network）在公用网络上建立专用网络的技术。整个 VPN 网络的任意两个节点之间的毗连并没有传统专网所需的端到端的物理链路，而是架构在公用网络服务商所提供的网络平台（如 Internet）之上的逻辑网络，用户数据在逻辑链路中传输。
   说明： 为了包管应用的运行效率，大部分 API 调用都是异步的，对于异步调用的 API 均提供了 callback 和 Promise 两种方式，以下示例均接纳 promise 函数，更多方式可以查阅API 参考。
  以下分别先容具体开发方式。
接口说明

完整的 JS API 说明以及实例代码请参考：VPN API 参考。
接口名描述setUp(config: VpnConfig, callback: AsyncCallback<number>): void建立一个 VPN 网络，利用 callback 方式作为异步方法。protect(socketFd: number, callback: AsyncCallback<void>): void掩护 VPN 的隧道，利用 callback 方式作为异步方法。destroy(callback: AsyncCallback<void>): void烧毁一个 VPN 网络，利用 callback 方式作为异步方法。 启动 VPN 的流程

• 建立一个 VPN 的网络隧道，下面以 UDP 隧道为例。
  
• 掩护前一步建立的 UDP 隧道。
  
• 建立一个 VPN 网络。
  
• 处置处罚虚拟网卡的数据，如：读写操纵。
  
• 烧毁 VPN 网络。
  

本示例通过 Native C++ 的方式开发应用程序，Native C++ 可参考: 简易 Native C++ 示例（ArkTS）（API9）
示例程序主要包含两个部分：js 功能代码和 C++功能代码
VPN 示例源码(js 部分)

主要功能：实现业务逻辑，如：创建隧道、建立 VPN 网络、掩护 VPN 网络、烧毁 VPN 网络

1. import { vpn } from '@kit.NetworkKit';
2. import { common } from '@kit.AbilityKit';
3. import vpn_client from "libvpn_client.so";
4. import { BusinessError } from '@kit.BasicServicesKit';
6. let TunnelFd: number = -1;
8. @Entry
9. @Component
10. struct Index {
11.   @State message: string = 'Test VPN';
13.   private context = getContext(this) as common.UIAbilityContext;
14.   private VpnConnection: vpn.VpnConnection = vpn.createVpnConnection(this.context);
16.   //1. 建立一个VPN的网络隧道，下面以UDP隧道为例。
17.   CreateTunnel() {
18.     TunnelFd = vpn_client.udpConnect("192.168.43.208", 8888);
19.   }
21.   //2. 保护前一步建立的UDP隧道。
22.   Protect() {
23.     this.VpnConnection.protect(TunnelFd).then(() => {
24.       console.info("vpn Protect Success.");
25.     }).catch((err: BusinessError) => {
26.       console.info("vpn Protect Failed " + JSON.stringify(err));
27.     })
28.   }
30.   SetupVpn() {
31.     let tunAddr : vpn.LinkAddress = {} as vpn.LinkAddress;
32.     tunAddr.address.address = "10.0.0.5";
33.     tunAddr.address.family = 1;
35.     let config : vpn.VpnConfig = {} as vpn.VpnConfig;
36.     config.addresses.push(tunAddr);
37.     config.mtu = 1400;
38.     config.dnsAddresses = ["114.114.114.114"];
40.     //3. 建立一个VPN网络。
41.     this.VpnConnection.setUp(config).then((data: number) => {
42.       console.info("tunfd: " + JSON.stringify(data));
43.       //4. 处理虚拟网卡的数据，如：读写操作。
44.       vpn_client.startVpn(data, TunnelFd)
45.     }).catch((err: BusinessError) => {
46.       console.info("setUp fail" + JSON.stringify(err));
47.     });
48.   }
50.   //5.销毁VPN网络。
51.   Destroy() {
52.     vpn_client.stopVpn(TunnelFd);
53.     this.VpnConnection.destroy().then(() => {
54.       console.info("vpn Destroy Success.");
55.     }).catch((err: BusinessError) => {
56.       console.info("vpn Destroy Failed " + JSON.stringify(err));
57.     })
58.   }
60.   build() {
61.     Row() {
62.       Column() {
63.         Text(this.message)
64.           .fontSize(50)
65.           .fontWeight(FontWeight.Bold)
66.           .onClick(() => {
67.             console.info("vpn Client")
68.           })
69.         Button('CreateTunnel').onClick(() => {
70.           this.CreateTunnel()
71.         }).fontSize(50)
72.         Button('Protect').onClick(() => {
73.           this.Protect()
74.         }).fontSize(50)
75.         Button('SetupVpn').onClick(() => {
76.           this.SetupVpn()
77.         }).fontSize(50)
78.         Button('Destroy').onClick(() => {
79.           this.Destroy()
80.         }).fontSize(50)
81.       }
82.       .width('100%')
83.     }
84.     .height('100%')
85.   }
86. }
87. <strong>js</strong>

复制代码

VPN 示例源码(c++部分)

主要功能：具体业务的底层实现，如：UDP 隧道 Client 端的实现、虚拟网卡读写数据的实现

1. #include "napi/native_api.h"
2. #include "hilog/log.h"
4. #include <cstring>
5. #include <thread>
6. #include <js_native_api.h>
7. #include <js_native_api_types.h>
8. #include <unistd.h>
9. #include <netinet/in.h>
10. #include <sys/socket.h>
11. #include <thread>
12. #include <sys/time.h>
14. #include <sys/socket.h>
15. #include <netinet/in.h>
16. #include <arpa/inet.h>
18. #define BUFFER_SIZE 2048
20. #define VPN_LOG_TAG "NetMgrVpn"
21. #define VPN_LOG_DOMAIN 0x15b0
22. #define MAKE_FILE_NAME (strrchr(__FILE__, '/') + 1)
24. #define NETMANAGER_VPN_LOGE(fmt, ...)                                                                                  \
25.     OH_LOG_Print(LOG_APP, LOG_ERROR, VPN_LOG_DOMAIN, VPN_LOG_TAG, "vpn [%{public}s %{public}d] " fmt, MAKE_FILE_NAME,  \
26.                  __LINE__, ##__VA_ARGS__)
28. #define NETMANAGER_VPN_LOGI(fmt, ...)                                                                                  \
29.     OH_LOG_Print(LOG_APP, LOG_INFO, VPN_LOG_DOMAIN, VPN_LOG_TAG, "vpn [%{public}s %{public}d] " fmt, MAKE_FILE_NAME,   \
30.                  __LINE__, ##__VA_ARGS__)
32. #define NETMANAGER_VPN_LOGD(fmt, ...)                                                                                  \
33.     OH_LOG_Print(LOG_APP, LOG_DEBUG, VPN_LOG_DOMAIN, VPN_LOG_TAG, "vpn [%{public}s %{public}d] " fmt, MAKE_FILE_NAME,   \
34.                  __LINE__, ##__VA_ARGS__)
36. struct FdInfo {
37.     int32_t tunFd = 0;
38.     int32_t tunnelFd = 0;
39.     struct sockaddr_in serverAddr;
40. };
42. static FdInfo fdInfo;
43. static bool threadRunF = false;
44. static std::thread threadt1;
45. static std::thread threadt2;
47. //获取对应字符串数据, 用于获取udp server 的IP地址
48. static constexpr const int MAX_STRING_LENGTH = 1024;
49. std::string GetStringFromValueUtf8(napi_env env, napi_value value) {
50.     std::string result;
51.     char str[MAX_STRING_LENGTH] = {0};
52.     size_t length = 0;
53.     napi_get_value_string_utf8(env, value, str, MAX_STRING_LENGTH, &length);
54.     if (length > 0) {
55.         return result.append(str, length);
56.     }
57.     return result;
58. }
60. void HandleReadTunfd(FdInfo fdInfo) {
61.     uint8_t buffer[BUFFER_SIZE] = {0};
62.     while (threadRunF) {
63.         int ret = read(fdInfo.tunFd, buffer, sizeof(buffer));
64.         if (ret <= 0) {
65.             if (errno != 11) {
66.                 NETMANAGER_VPN_LOGE("read tun device error: %{public}d, tunfd: %{public}d", errno, fdInfo.tunFd);
67.             }
68.             continue;
69.         }
71.         // 读取到虚拟网卡的数据，通过udp隧道，发送给服务器
72.         NETMANAGER_VPN_LOGD("buffer: %{public}s, len: %{public}d", buffer, ret);
73.         ret = sendto(fdInfo.tunnelFd, buffer, ret, 0, (struct sockaddr *)&fdInfo.serverAddr, sizeof(fdInfo.serverAddr));
74.         if (ret <= 0) {
75.             NETMANAGER_VPN_LOGE("send to server[%{public}s:%{public}d] failed, ret: %{public}d, error: %{public}s",
76.                                 inet_ntoa(fdInfo.serverAddr.sin_addr), ntohs(fdInfo.serverAddr.sin_port), ret,
77.                                 strerror(errno));
78.             continue;
79.         }
80.     }
81. }
83. void HandleTcpReceived(FdInfo fdInfo) {
84.     int addrlen = sizeof(struct sockaddr_in);
85.     uint8_t buffer[BUFFER_SIZE] = {0};
86.     while (threadRunF) {
87.         int length = recvfrom(fdInfo.tunnelFd, buffer, sizeof(buffer), 0, (struct sockaddr *)&fdInfo.serverAddr,
88.                               (socklen_t *)&addrlen);
89.         if (length < 0) {
90.             if (errno != 11) {
91.                 NETMANAGER_VPN_LOGE("read tun device error: %{public}d，tunnelfd: %{public}d", errno, fdInfo.tunnelFd);
92.             }
93.             continue;
94.         }
96.         // 接收到udp server的数据，写入到虚拟网卡中
97.         NETMANAGER_VPN_LOGD("from [%{public}s:%{public}d] data: %{public}s, len: %{public}d",
98.                             inet_ntoa(fdInfo.serverAddr.sin_addr), ntohs(fdInfo.serverAddr.sin_port), buffer, length);
99.         int ret = write(fdInfo.tunFd, buffer, length);
100.         if (ret <= 0) {
101.             NETMANAGER_VPN_LOGE("error Write To Tunfd, errno: %{public}d", errno);
102.         }
103.     }
104. }
106. static napi_value UdpConnect(napi_env env, napi_callback_info info) {
107.     size_t argc = 2;
108.     napi_value args[2] = {nullptr};
109.     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
111.     int32_t port = 0;
112.     napi_get_value_int32(env, args[1], &port);
113.     std::string ipAddr = GetStringFromValueUtf8(env, args[0]);
115.     NETMANAGER_VPN_LOGI("ip: %{public}s port: %{public}d", ipAddr.c_str(), port);
117.     // 建立udp隧道
118.     int32_t sockFd = socket(AF_INET, SOCK_DGRAM, 0);
119.     if (sockFd == -1) {
120.         NETMANAGER_VPN_LOGE("socket() error");
121.         return 0;
122.     }
124.     struct timeval timeout = {1, 0};
125.     setsockopt(sockFd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(struct timeval));
127.     memset(&fdInfo.serverAddr, 0, sizeof(fdInfo.serverAddr));
128.     fdInfo.serverAddr.sin_family = AF_INET;
129.     fdInfo.serverAddr.sin_addr.s_addr = inet_addr(ipAddr.c_str()); // server's IP addr
130.     fdInfo.serverAddr.sin_port = htons(port);                      // port
132.     NETMANAGER_VPN_LOGI("Connection successful");
134.     napi_value tunnelFd;
135.     napi_create_int32(env, sockFd, &tunnelFd);
136.     return tunnelFd;
137. }
139. static napi_value StartVpn(napi_env env, napi_callback_info info) {
140.     size_t argc = 2;
141.     napi_value args[2] = {nullptr};
142.     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
144.     napi_get_value_int32(env, args[0], &fdInfo.tunFd);
145.     napi_get_value_int32(env, args[1], &fdInfo.tunnelFd);
147.     if (threadRunF) {
148.         threadRunF = false;
149.         threadt1.join();
150.         threadt2.join();
151.     }
153.     // 启动两个线程, 一个处理读取虚拟网卡的数据，另一个接收服务端的数据
154.     threadRunF = true;
155.     std::thread tt1(HandleReadTunfd, fdInfo);
156.     std::thread tt2(HandleTcpReceived, fdInfo);
158.     threadt1 = std::move(tt1);
159.     threadt2 = std::move(tt2);
161.     NETMANAGER_VPN_LOGI("StartVpn successful");
163.     napi_value retValue;
164.     napi_create_int32(env, 0, &retValue);
165.     return retValue;
166. }
168. static napi_value StopVpn(napi_env env, napi_callback_info info) {
169.     size_t argc = 1;
170.     napi_value args[1] = {nullptr};
171.     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
173.     int32_t tunnelFd;
174.     napi_get_value_int32(env, args[0], &tunnelFd);
175.     if (tunnelFd) {
176.         close(tunnelFd);
177.         tunnelFd = 0;
178.     }
180.     // 停止两个线程
181.     if (threadRunF) {
182.         threadRunF = false;
183.         threadt1.join();
184.         threadt2.join();
185.     }
187.     NETMANAGER_VPN_LOGI("StopVpn successful");
189.     napi_value retValue;
190.     napi_create_int32(env, 0, &retValue);
191.     return retValue;
192. }
194. EXTERN_C_START
195. static napi_value Init(napi_env env, napi_value exports) {
196.     napi_property_descriptor desc[] = {
197.         {"udpConnect", nullptr, UdpConnect, nullptr, nullptr, nullptr, napi_default, nullptr},
198.         {"startVpn", nullptr, StartVpn, nullptr, nullptr, nullptr, napi_default, nullptr},
199.         {"stopVpn", nullptr, StopVpn, nullptr, nullptr, nullptr, napi_default, nullptr},
200.     };
201.     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
202.     return exports;
203. }
204. EXTERN_C_END
206. static napi_module demoModule = {
207.     .nm_version = 1,
208.     .nm_flags = 0,
209.     .nm_filename = nullptr,
210.     .nm_register_func = Init,
211.     .nm_modname = "entry",
212.     .nm_priv = ((void *)0),
213.     .reserved = {0},
214. };
216. extern "C" __attribute__((constructor)) void RegisterEntryModule(void) {
217.     napi_module_register(&demoModule);
218. }

复制代码

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。