1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "vpn_config_utils.h"
17
18 #include "napi_utils.h"
19 #include "inet_addr.h"
20 #include "net_manager_constants.h"
21 #include "netmanager_base_common_utils.h"
22 #include "netmgr_ext_log_wrapper.h"
23
24 namespace OHOS {
25 namespace NetManagerStandard {
26 namespace VpnConfigUtils {
ParseSysVpnConfig(napi_env env,napi_value * params,sptr<SysVpnConfig> & vpnConfig)27 bool ParseSysVpnConfig(napi_env env, napi_value *params, sptr<SysVpnConfig> &vpnConfig)
28 {
29 if (params == nullptr) {
30 NETMGR_EXT_LOG_E("ParseSysVpnConfig failed, params is null");
31 return false;
32 }
33 int vpnType = -1;
34 GetInt32FromJsOptionItem(env, params[0], CONFIG_VPN_TYPE, vpnType);
35 switch (vpnType) {
36 case VpnType::IKEV2_IPSEC_MSCHAPv2:
37 case VpnType::IKEV2_IPSEC_PSK:
38 case VpnType::IKEV2_IPSEC_RSA:
39 case VpnType::IPSEC_XAUTH_PSK:
40 case VpnType::IPSEC_XAUTH_RSA:
41 case VpnType::IPSEC_HYBRID_RSA: {
42 vpnConfig = CreateAndParseIpsecVpnConf(env, params[0]);
43 if (vpnConfig == nullptr) {
44 NETMGR_EXT_LOG_E("CreateAndParseIpsecVpnConf failed, vpnConfig is null");
45 return false;
46 }
47 break;
48 }
49 case VpnType::OPENVPN: {
50 vpnConfig = CreateAndParseOpenvpnConf(env, params[0]);
51 if (vpnConfig == nullptr) {
52 NETMGR_EXT_LOG_E("CreateAndParseOpenvpnConf failed, vpnConfig is null");
53 return false;
54 }
55 break;
56 }
57 case VpnType::L2TP:
58 case VpnType::L2TP_IPSEC_PSK:
59 case VpnType::L2TP_IPSEC_RSA: {
60 vpnConfig = CreateAndParseL2tpVpnConf(env, params[0]);
61 if (vpnConfig == nullptr) {
62 NETMGR_EXT_LOG_E("CreateAndParseL2tpVpnConf failed, vpnConfig is null");
63 return false;
64 }
65 break;
66 }
67 default:
68 NETMGR_EXT_LOG_E("sysvpn ParseSysVpnConfig failed! invalid type=%{public}d", vpnType);
69 return false;
70 }
71
72 if (!ParseAddrRouteParams(env, params[0], vpnConfig) || !ParseChoiceableParams(env, params[0], vpnConfig)) {
73 return false;
74 }
75 return true;
76 }
77
ParseAddrRouteParams(napi_env env,napi_value config,sptr<SysVpnConfig> & vpnConfig)78 bool ParseAddrRouteParams(napi_env env, napi_value config, sptr<SysVpnConfig> &vpnConfig)
79 {
80 if (vpnConfig == nullptr) {
81 NETMGR_EXT_LOG_E("vpnConfig is null");
82 return false;
83 }
84 // parse addresses.
85 if (NapiUtils::HasNamedProperty(env, config, CONFIG_ADDRESSES)) {
86 napi_value addrArray = NapiUtils::GetNamedProperty(env, config, CONFIG_ADDRESSES);
87 if (!NapiUtils::IsArray(env, addrArray)) {
88 NETMGR_EXT_LOG_E("addresses is not array");
89 return false;
90 }
91 uint32_t addrLength = NapiUtils::GetArrayLength(env, addrArray);
92 for (uint32_t i = 0; i < addrLength; ++i) { // set length limit.
93 INetAddr iNetAddr;
94 if (!ParseAddress(env, NapiUtils::GetArrayElement(env, addrArray, i), iNetAddr)) {
95 NETMGR_EXT_LOG_E("ParseAddress failed");
96 return false;
97 }
98 vpnConfig->addresses_.emplace_back(iNetAddr);
99 bool isIpv6 = CommonUtils::IsValidIPV6(iNetAddr.address_);
100 vpnConfig->isAcceptIPv4_ = !isIpv6;
101 vpnConfig->isAcceptIPv6_ = isIpv6;
102 }
103 }
104
105 // parse routes.
106 if (NapiUtils::HasNamedProperty(env, config, CONFIG_ROUTES)) {
107 napi_value routes = NapiUtils::GetNamedProperty(env, config, CONFIG_ROUTES);
108 if (!NapiUtils::IsArray(env, routes)) {
109 NETMGR_EXT_LOG_E("routes is not array");
110 return false;
111 }
112 uint32_t routesLength = NapiUtils::GetArrayLength(env, routes);
113 for (uint32_t idx = 0; idx < routesLength; ++idx) { // set length limit.
114 struct Route routeInfo;
115 if (!ParseRoute(env, NapiUtils::GetArrayElement(env, routes, idx), routeInfo)) {
116 NETMGR_EXT_LOG_E("ParseRoute failed");
117 return false;
118 }
119 vpnConfig->routes_.emplace_back(routeInfo);
120 }
121 }
122 return true;
123 }
124
ParseChoiceableParams(napi_env env,napi_value config,sptr<SysVpnConfig> & vpnConfig)125 bool ParseChoiceableParams(napi_env env, napi_value config, sptr<SysVpnConfig> &vpnConfig)
126 {
127 if (vpnConfig == nullptr) {
128 NETMGR_EXT_LOG_E("sysVpnConfig is null");
129 return false;
130 }
131 ParseOptionArrayString(env, config, CONFIG_DNSADDRESSES, vpnConfig->dnsAddresses_);
132 ParseOptionArrayString(env, config, CONFIG_SEARCHDOMAINS, vpnConfig->searchDomains_);
133 GetInt32FromJsOptionItem(env, config, CONFIG_MTU, vpnConfig->mtu_);
134 GetBoolFromJsOptionItem(env, config, CONFIG_ISIPV4ACCEPTED, vpnConfig->isAcceptIPv4_);
135 GetBoolFromJsOptionItem(env, config, CONFIG_ISIPV6ACCEPTED, vpnConfig->isAcceptIPv6_);
136 GetBoolFromJsOptionItem(env, config, CONFIG_ISLEGACY, vpnConfig->isLegacy_);
137 GetBoolFromJsOptionItem(env, config, CONFIG_ISMETERED, vpnConfig->isMetered_);
138 GetBoolFromJsOptionItem(env, config, CONFIG_ISBLOCKING, vpnConfig->isBlocking_);
139 ParseOptionArrayString(env, config, CONFIG_TRUSTEDAPPLICATIONS, vpnConfig->acceptedApplications_);
140 ParseOptionArrayString(env, config, CONFIG_BLOCKEDAPPLICATIONS, vpnConfig->refusedApplications_);
141 return true;
142 }
143
ParseSystemVpnParams(napi_env env,napi_value config,sptr<SysVpnConfig> sysVpnConfig)144 bool ParseSystemVpnParams(napi_env env, napi_value config, sptr<SysVpnConfig> sysVpnConfig)
145 {
146 if (sysVpnConfig == nullptr) {
147 NETMGR_EXT_LOG_E("sysVpnConfig is null");
148 return false;
149 }
150 GetStringFromJsOptionItem(env, config, CONFIG_VPN_ID, sysVpnConfig->vpnId_);
151 GetStringFromJsOptionItem(env, config, CONFIG_VPN_NAME, sysVpnConfig->vpnName_);
152 GetInt32FromJsOptionItem(env, config, CONFIG_VPN_TYPE, sysVpnConfig->vpnType_);
153 GetStringFromJsOptionItem(env, config, CONFIG_USER_NAME, sysVpnConfig->userName_);
154 GetStringFromJsOptionItem(env, config, CONFIG_PASSWORD, sysVpnConfig->password_);
155 GetStringFromJsOptionItem(env, config, CONFIG_FORWARDED_ROUTES, sysVpnConfig->forwardingRoutes_);
156 GetBoolFromJsOptionItem(env, config, CONFIG_SAVE_LOGIN, sysVpnConfig->saveLogin_);
157 return true;
158 }
159
CreateAndParseIpsecVpnConf(napi_env env,napi_value config)160 sptr<IpsecVpnConfig> CreateAndParseIpsecVpnConf(napi_env env, napi_value config)
161 {
162 sptr<IpsecVpnConfig> ipsecVpnConfig = new (std::nothrow) IpsecVpnConfig();
163 if (ipsecVpnConfig == nullptr) {
164 NETMGR_EXT_LOG_E("create ipsecVpnConfig failed, is null");
165 return nullptr;
166 }
167 if (!ParseSystemVpnParams(env, config, ipsecVpnConfig)) {
168 NETMGR_EXT_LOG_E("ParseSystemVpnParams failed");
169 return nullptr;
170 }
171 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRE_SHARE_KEY, ipsecVpnConfig->ipsecPreSharedKey_);
172 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_IDENTIFIER, ipsecVpnConfig->ipsecIdentifier_);
173 GetStringFromJsOptionItem(env, config, CONFIG_SWANCTL_CONF, ipsecVpnConfig->swanctlConf_);
174 GetStringFromJsOptionItem(env, config, CONFIG_STRONGSWAN_CONF, ipsecVpnConfig->strongswanConf_);
175 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_CA_CERT_CONF, ipsecVpnConfig->ipsecCaCertConf_);
176 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRIVATE_USER_CERT_CONF,
177 ipsecVpnConfig->ipsecPrivateUserCertConf_);
178 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PUBLIC_USER_CERT_CONF,
179 ipsecVpnConfig->ipsecPublicUserCertConf_);
180 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRIVATE_SERVER_CERT_CONF,
181 ipsecVpnConfig->ipsecPrivateServerCertConf_);
182 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PUBLIC_SERVER_CERT_CONF,
183 ipsecVpnConfig->ipsecPublicServerCertConf_);
184 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_CA_CERT_FILE_PATH, ipsecVpnConfig->ipsecCaCertFilePath_);
185 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRIVATE_USER_CERT_FILE_PATH,
186 ipsecVpnConfig->ipsecPrivateUserCertFilePath_);
187 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PUBLIC_USER_CERT_FILE_PATH,
188 ipsecVpnConfig->ipsecPublicUserCertFilePath_);
189 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRIVATE_SERVER_CERT_FILE_PATH,
190 ipsecVpnConfig->ipsecPrivateServerCertFilePath_);
191 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PUBLIC_SERVER_CERT_FILE_PATH,
192 ipsecVpnConfig->ipsecPublicServerCertFilePath_);
193 return ipsecVpnConfig;
194 }
195
CreateAndParseL2tpVpnConf(napi_env env,napi_value config)196 sptr<L2tpVpnConfig> CreateAndParseL2tpVpnConf(napi_env env, napi_value config)
197 {
198 sptr<L2tpVpnConfig> l2tpVpnConfig = new (std::nothrow) L2tpVpnConfig();
199 if (l2tpVpnConfig == nullptr) {
200 NETMGR_EXT_LOG_E("l2tpVpnConfig is null");
201 return nullptr;
202 }
203 if (!ParseSystemVpnParams(env, config, l2tpVpnConfig)) {
204 NETMGR_EXT_LOG_E("ParseSystemVpnParams failed");
205 return nullptr;
206 }
207
208 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRE_SHARE_KEY, l2tpVpnConfig->ipsecPreSharedKey_);
209 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_IDENTIFIER, l2tpVpnConfig->ipsecIdentifier_);
210 GetStringFromJsOptionItem(env, config, CONFIG_STRONGSWAN_CONF, l2tpVpnConfig->strongswanConf_);
211 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_CA_CERT_CONF, l2tpVpnConfig->ipsecCaCertConf_);
212 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRIVATE_USER_CERT_CONF,
213 l2tpVpnConfig->ipsecPrivateUserCertConf_);
214 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PUBLIC_USER_CERT_CONF,
215 l2tpVpnConfig->ipsecPublicUserCertConf_);
216 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRIVATE_SERVER_CERT_CONF,
217 l2tpVpnConfig->ipsecPrivateServerCertConf_);
218 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PUBLIC_SERVER_CERT_CONF,
219 l2tpVpnConfig->ipsecPublicServerCertConf_);
220 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_CA_CERT_FILE_PATH,
221 l2tpVpnConfig->ipsecCaCertFilePath_);
222 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRIVATE_USER_CERT_FILE_PATH,
223 l2tpVpnConfig->ipsecPrivateUserCertFilePath_);
224 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PUBLIC_USER_CERT_FILE_PATH,
225 l2tpVpnConfig->ipsecPublicUserCertFilePath_);
226 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PRIVATE_SERVER_CERT_FILE_PATH,
227 l2tpVpnConfig->ipsecPrivateServerCertFilePath_);
228 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_PUBLIC_SERVER_CERT_FILE_PATH,
229 l2tpVpnConfig->ipsecPublicServerCertFilePath_);
230 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_CONF, l2tpVpnConfig->ipsecConf_);
231 GetStringFromJsOptionItem(env, config, CONFIG_IPSEC_SECRETS, l2tpVpnConfig->ipsecSecrets_);
232 GetStringFromJsOptionItem(env, config, CONFIG_OPTIONS_L2TPD_CLIENT, l2tpVpnConfig->optionsL2tpdClient_);
233 GetStringFromJsOptionItem(env, config, CONFIG_XL2TPD_CONF, l2tpVpnConfig->xl2tpdConf_);
234 GetStringFromJsOptionItem(env, config, CONFIG_L2TP_SHARED_KEY, l2tpVpnConfig->l2tpSharedKey_);
235 return l2tpVpnConfig;
236 }
237
CreateAndParseOpenvpnConf(napi_env env,napi_value config)238 sptr<OpenvpnConfig> CreateAndParseOpenvpnConf(napi_env env, napi_value config)
239 {
240 sptr<OpenvpnConfig> openvpnConfig = new (std::nothrow) OpenvpnConfig();
241 if (openvpnConfig == nullptr) {
242 NETMGR_EXT_LOG_E("openvpnConfig is null");
243 return nullptr;
244 }
245 if (!ParseSystemVpnParams(env, config, openvpnConfig)) {
246 NETMGR_EXT_LOG_E("ParseSystemVpnParams failed");
247 return nullptr;
248 }
249 GetStringFromJsOptionItem(env, config, CONFIG_OVPN_PORT, openvpnConfig->ovpnPort_);
250 GetInt32FromJsOptionItem(env, config, CONFIG_OPENVPN_PROTOCOL, openvpnConfig->ovpnProtocol_);
251 GetStringFromJsOptionItem(env, config, CONFIG_OPENVPN_CFG, openvpnConfig->ovpnConfig_);
252 GetInt32FromJsOptionItem(env, config, CONFIG_OPENVPN_AUTH_TYPE, openvpnConfig->ovpnAuthType_);
253 GetStringFromJsOptionItem(env, config, CONFIG_ASKPASS, openvpnConfig->askpass_);
254 GetStringFromJsOptionItem(env, config, CONFIG_OPENVPN_CFG_FILE_PATH, openvpnConfig->ovpnConfigFilePath_);
255 GetStringFromJsOptionItem(env, config, CONFIG_OPENVPN_CA_CERT_FILE_PATH, openvpnConfig->ovpnCaCertFilePath_);
256 GetStringFromJsOptionItem(env, config, CONFIG_OPENVPN_USER_CERT_FILE_PATH, openvpnConfig->ovpnUserCertFilePath_);
257 GetStringFromJsOptionItem(env, config, CONFIG_OPENVPN_PRIVATE_KEY_FILE_PATH,
258 openvpnConfig->ovpnPrivateKeyFilePath_);
259 return openvpnConfig;
260 }
261
ParseAddress(napi_env env,napi_value address,struct INetAddr & iNetAddr)262 bool ParseAddress(napi_env env, napi_value address, struct INetAddr &iNetAddr)
263 {
264 napi_value netAddress = NapiUtils::GetNamedProperty(env, address, NET_ADDRESS);
265 if (NapiUtils::GetValueType(env, netAddress) != napi_object) {
266 NETMGR_EXT_LOG_E("param address type is mismatch");
267 return false;
268 }
269
270 if (!GetStringFromJsMandatoryItem(env, netAddress, NET_ADDRESS, iNetAddr.address_)) {
271 NETMGR_EXT_LOG_E("get address-address failed");
272 return false;
273 }
274
275 bool isIpv6 = CommonUtils::IsValidIPV6(iNetAddr.address_);
276 if (!isIpv6) {
277 if (!CommonUtils::IsValidIPV4(iNetAddr.address_)) {
278 NETMGR_EXT_LOG_W("invalid ip address, might be a domain");
279 GetUint8FromJsOptionItem(env, netAddress, NET_PORT, iNetAddr.port_);
280 return true;
281 }
282 }
283
284 GetUint8FromJsOptionItem(env, netAddress, NET_FAMILY, iNetAddr.family_);
285 GetUint8FromJsOptionItem(env, netAddress, NET_PORT, iNetAddr.port_);
286
287 if (NapiUtils::GetValueType(env, NapiUtils::GetNamedProperty(env, address, NET_PREFIXLENGTH)) != napi_number) {
288 NETMGR_EXT_LOG_E("param NET_PREFIXLENGTH type is mismatch");
289 return false;
290 }
291 if (!isIpv6) {
292 iNetAddr.prefixlen_ = static_cast<uint8_t>(NapiUtils::GetUint32Property(env, address, NET_PREFIXLENGTH));
293 } else {
294 iNetAddr.prefixlen_ = CommonUtils::Ipv6PrefixLen(iNetAddr.address_);
295 }
296
297 uint32_t prefix = iNetAddr.prefixlen_;
298 if (prefix == 0 || prefix >= (isIpv6 ? IPV6_NET_PREFIX_MAX_LENGTH : NET_MASK_MAX_LENGTH)) {
299 NETMGR_EXT_LOG_E("prefixlen_ error");
300 return false;
301 }
302 if (!isIpv6) {
303 uint32_t maskUint = (0xFFFFFFFF << (NET_MASK_MAX_LENGTH - prefix));
304 uint32_t ipAddrUint = CommonUtils::ConvertIpv4Address(iNetAddr.address_);
305 uint32_t subNetAddress = ipAddrUint & maskUint;
306 uint32_t boardcastAddress = subNetAddress | (~maskUint);
307 if ((ipAddrUint == subNetAddress) || (ipAddrUint == boardcastAddress)) {
308 NETMGR_EXT_LOG_E("invalid ip address");
309 return false;
310 }
311 }
312 return true;
313 }
314
ParseDestination(napi_env env,napi_value jsRoute,struct INetAddr & iNetAddr)315 bool ParseDestination(napi_env env, napi_value jsRoute, struct INetAddr &iNetAddr)
316 {
317 napi_value destination = NapiUtils::GetNamedProperty(env, jsRoute, NET_DESTINATION);
318 if (NapiUtils::GetValueType(env, destination) != napi_object) {
319 NETMGR_EXT_LOG_E("param destination type is mismatch");
320 return false;
321 }
322
323 napi_value netAddress = NapiUtils::GetNamedProperty(env, destination, NET_ADDRESS);
324 if (NapiUtils::GetValueType(env, netAddress) != napi_object) {
325 NETMGR_EXT_LOG_E("param address type is mismatch");
326 return false;
327 }
328
329 if (!GetStringFromJsMandatoryItem(env, netAddress, NET_ADDRESS, iNetAddr.address_)) {
330 NETMGR_EXT_LOG_E("get destination-address failed");
331 return false;
332 }
333
334 if (!CommonUtils::IsValidIPV4(iNetAddr.address_) && !CommonUtils::IsValidIPV6(iNetAddr.address_)) {
335 NETMGR_EXT_LOG_E("invalid ip address");
336 return false;
337 }
338
339 GetUint8FromJsOptionItem(env, netAddress, NET_FAMILY, iNetAddr.family_);
340 GetUint8FromJsOptionItem(env, netAddress, NET_PORT, iNetAddr.port_);
341 GetUint8FromJsOptionItem(env, destination, NET_PREFIXLENGTH, iNetAddr.prefixlen_);
342 return true;
343 }
344
ParseGateway(napi_env env,napi_value jsRoute,struct INetAddr & iNetAddr)345 bool ParseGateway(napi_env env, napi_value jsRoute, struct INetAddr &iNetAddr)
346 {
347 napi_value gateway = NapiUtils::GetNamedProperty(env, jsRoute, NET_GATEWAY);
348 if (NapiUtils::GetValueType(env, gateway) != napi_object) {
349 NETMGR_EXT_LOG_E("param gateway type is mismatch");
350 return false;
351 }
352
353 if (!GetStringFromJsMandatoryItem(env, gateway, NET_ADDRESS, iNetAddr.address_)) {
354 NETMGR_EXT_LOG_E("get gateway-address failed");
355 return false;
356 }
357
358 GetUint8FromJsOptionItem(env, gateway, NET_FAMILY, iNetAddr.family_);
359 GetUint8FromJsOptionItem(env, gateway, NET_PORT, iNetAddr.port_);
360 return true;
361 }
362
ParseRoute(napi_env env,napi_value jsRoute,Route & route)363 bool ParseRoute(napi_env env, napi_value jsRoute, Route &route)
364 {
365 GetStringFromJsOptionItem(env, jsRoute, NET_INTERFACE, route.iface_);
366
367 if (!ParseDestination(env, jsRoute, route.destination_)) {
368 NETMGR_EXT_LOG_E("ParseDestination failed");
369 return false;
370 }
371 if (!ParseGateway(env, jsRoute, route.gateway_)) {
372 NETMGR_EXT_LOG_E("ParseGateway failed");
373 return false;
374 }
375
376 GetBoolFromJsOptionItem(env, jsRoute, NET_HAS_GATEWAY, route.hasGateway_);
377 GetBoolFromJsOptionItem(env, jsRoute, NET_ISDEFAULTROUTE, route.isDefaultRoute_);
378 return true;
379 }
380
ParseOptionArrayString(napi_env env,napi_value config,const std::string & key,std::vector<std::string> & vector)381 bool ParseOptionArrayString(napi_env env, napi_value config, const std::string &key,
382 std::vector<std::string> &vector)
383 {
384 if (NapiUtils::HasNamedProperty(env, config, key)) {
385 napi_value array = NapiUtils::GetNamedProperty(env, config, key);
386 if (!NapiUtils::IsArray(env, array)) {
387 NETMGR_EXT_LOG_E("param [%{public}s] is not array", key.c_str());
388 return false;
389 }
390 uint32_t arrayLength = NapiUtils::GetArrayLength(env, array);
391 for (uint32_t i = 0; i < arrayLength; ++i) {
392 std::string item = NapiUtils::GetStringFromValueUtf8(env, NapiUtils::GetArrayElement(env, array, i));
393 vector.push_back(item);
394 }
395 }
396 return true;
397 }
398
GetStringFromJsMandatoryItem(napi_env env,napi_value object,const std::string & key,std::string & value)399 bool GetStringFromJsMandatoryItem(napi_env env, napi_value object, const std::string &key, std::string &value)
400 {
401 if (NapiUtils::GetValueType(env, NapiUtils::GetNamedProperty(env, object, key)) != napi_string) {
402 NETMGR_EXT_LOG_E("param [%{public}s] type is mismatch", key.c_str());
403 return false;
404 }
405 value = NapiUtils::GetStringPropertyUtf8(env, object, key);
406 return (value.empty()) ? false : true;
407 }
408
GetStringFromJsOptionItem(napi_env env,napi_value object,const std::string & key,std::string & value)409 void GetStringFromJsOptionItem(napi_env env, napi_value object, const std::string &key, std::string &value)
410 {
411 if (NapiUtils::HasNamedProperty(env, object, key)) {
412 if (NapiUtils::GetValueType(env, NapiUtils::GetNamedProperty(env, object, key)) == napi_string) {
413 value = NapiUtils::GetStringPropertyUtf8(env, object, key);
414 } else {
415 NETMGR_EXT_LOG_E("param [%{public}s] type is mismatch", key.c_str());
416 }
417 }
418 }
419
GetUint8FromJsOptionItem(napi_env env,napi_value object,const std::string & key,uint8_t & value)420 void GetUint8FromJsOptionItem(napi_env env, napi_value object, const std::string &key, uint8_t &value)
421 {
422 if (NapiUtils::HasNamedProperty(env, object, key)) {
423 if (NapiUtils::GetValueType(env, NapiUtils::GetNamedProperty(env, object, key)) == napi_number) {
424 value = static_cast<uint8_t>(NapiUtils::GetUint32Property(env, object, key));
425 } else {
426 NETMGR_EXT_LOG_E("param [%{public}s] type is mismatch", key.c_str());
427 }
428 }
429 }
430
GetBoolFromJsOptionItem(napi_env env,napi_value object,const std::string & key,bool & value)431 void GetBoolFromJsOptionItem(napi_env env, napi_value object, const std::string &key, bool &value)
432 {
433 if (NapiUtils::HasNamedProperty(env, object, key)) {
434 if (NapiUtils::GetValueType(env, NapiUtils::GetNamedProperty(env, object, key)) == napi_boolean) {
435 value = NapiUtils::GetBooleanProperty(env, object, key);
436 } else {
437 NETMGR_EXT_LOG_E("param [%{public}s] type is mismatch", key.c_str());
438 }
439 }
440 }
441
GetInt32FromJsOptionItem(napi_env env,napi_value object,const std::string & key,int32_t & value)442 void GetInt32FromJsOptionItem(napi_env env, napi_value object, const std::string &key, int32_t &value)
443 {
444 if (NapiUtils::HasNamedProperty(env, object, key)) {
445 if (NapiUtils::GetValueType(env, NapiUtils::GetNamedProperty(env, object, key)) == napi_number) {
446 value = NapiUtils::GetInt32Property(env, object, key);
447 } else {
448 NETMGR_EXT_LOG_E("param [%{public}s] type is mismatch", key.c_str());
449 }
450 }
451 }
452
CreateNapiVpnConfig(napi_env env,sptr<SysVpnConfig> & sysVpnConfig)453 napi_value CreateNapiVpnConfig(napi_env env, sptr<SysVpnConfig> &sysVpnConfig)
454 {
455 if (sysVpnConfig == nullptr) {
456 NETMGR_EXT_LOG_E("CreateNapiVpnConfig failed, param is null");
457 return NapiUtils::GetUndefined(env);
458 }
459 switch (sysVpnConfig->vpnType_) {
460 case VpnType::IKEV2_IPSEC_MSCHAPv2:
461 case VpnType::IKEV2_IPSEC_PSK:
462 case VpnType::IKEV2_IPSEC_RSA:
463 case VpnType::IPSEC_XAUTH_PSK:
464 case VpnType::IPSEC_XAUTH_RSA:
465 case VpnType::IPSEC_HYBRID_RSA:
466 return CreateNapiIpsecVpnConfig(env, sysVpnConfig);
467 case VpnType::OPENVPN:
468 return CreateNapiOpenvpnConfig(env, sysVpnConfig);
469 case VpnType::L2TP:
470 case VpnType::L2TP_IPSEC_PSK:
471 case VpnType::L2TP_IPSEC_RSA:
472 return CreateNapiL2tpVpnConfig(env, sysVpnConfig);
473 default:
474 NETMGR_EXT_LOG_E("CreateNapiVpnConfig failed, invalid type %{public}d", sysVpnConfig->vpnType_);
475 return NapiUtils::GetUndefined(env);
476 }
477 }
478
CreateNapiSysVpnConfig(napi_env env,sptr<SysVpnConfig> & sysVpnConfig)479 napi_value CreateNapiSysVpnConfig(napi_env env, sptr<SysVpnConfig> &sysVpnConfig)
480 {
481 if (sysVpnConfig == nullptr) {
482 NETMGR_EXT_LOG_E("CreateNapiSysVpnConfig failed, param is null");
483 return NapiUtils::GetUndefined(env);
484 }
485 napi_value config = NapiUtils::CreateObject(env);
486 std::vector<INetAddr> addresses = sysVpnConfig->addresses_;
487 if (!addresses.empty()) {
488 napi_value linkAddresses = NapiUtils::CreateArray(env, 1);
489 napi_value netAddr = NapiUtils::CreateObject(env);
490 NapiUtils::SetStringPropertyUtf8(env, netAddr, NET_ADDRESS, addresses[0].address_);
491 napi_value linkAddr = NapiUtils::CreateObject(env);
492 NapiUtils::SetNamedProperty(env, linkAddr, NET_ADDRESS, netAddr);
493 NapiUtils::SetUint32Property(env, linkAddr, NET_PREFIXLENGTH, 1);
494 NapiUtils::SetArrayElement(env, linkAddresses, 0, linkAddr);
495 NapiUtils::SetNamedProperty(env, config, CONFIG_ADDRESSES, linkAddresses);
496 }
497 std::vector<std::string> dnsAddresses = sysVpnConfig->dnsAddresses_;
498 if (!dnsAddresses.empty()) {
499 napi_value dnsArray = NapiUtils::CreateArray(env, 1);
500 NapiUtils::SetArrayElement(env, dnsArray, 0, NapiUtils::CreateStringUtf8(env, dnsAddresses[0]));
501 NapiUtils::SetNamedProperty(env, config, CONFIG_DNSADDRESSES, dnsArray);
502 }
503 std::vector<std::string> searchDomains = sysVpnConfig->searchDomains_;
504 if (!searchDomains.empty()) {
505 napi_value domainsArray = NapiUtils::CreateArray(env, 1);
506 NapiUtils::SetArrayElement(env, domainsArray, 0, NapiUtils::CreateStringUtf8(env, searchDomains[0]));
507 NapiUtils::SetNamedProperty(env, config, CONFIG_SEARCHDOMAINS, domainsArray);
508 }
509 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_VPN_ID, sysVpnConfig->vpnId_);
510 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_VPN_NAME, sysVpnConfig->vpnName_);
511 NapiUtils::SetInt32Property(env, config, CONFIG_VPN_TYPE, sysVpnConfig->vpnType_);
512 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_USER_NAME, sysVpnConfig->userName_);
513 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_PASSWORD, sysVpnConfig->password_);
514 NapiUtils::SetBooleanProperty(env, config, CONFIG_SAVE_LOGIN, sysVpnConfig->saveLogin_ == 0 ? false : true);
515 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_FORWARDED_ROUTES, sysVpnConfig->forwardingRoutes_);
516 return config;
517 }
518
CreateNapiIpsecVpnConfig(napi_env env,sptr<SysVpnConfig> & sysVpnConfig)519 napi_value CreateNapiIpsecVpnConfig(napi_env env, sptr<SysVpnConfig> &sysVpnConfig)
520 {
521 if (sysVpnConfig == nullptr) {
522 NETMGR_EXT_LOG_E("CreateNapiIpsecVpnConfig failed, param is null");
523 return NapiUtils::GetUndefined(env);
524 }
525 napi_value config = CreateNapiSysVpnConfig(env, sysVpnConfig);
526
527 IpsecVpnConfig *ipsecVpnConfig = static_cast<IpsecVpnConfig *>(sysVpnConfig.GetRefPtr());
528 if (ipsecVpnConfig == nullptr) {
529 NETMGR_EXT_LOG_E("CreateNapiIpsecVpnConfig failed, ipsecVpnConfig is null");
530 return NapiUtils::GetUndefined(env);
531 }
532 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRE_SHARE_KEY, ipsecVpnConfig->ipsecPreSharedKey_);
533 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_IDENTIFIER, ipsecVpnConfig->ipsecIdentifier_);
534 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_SWANCTL_CONF, ipsecVpnConfig->swanctlConf_);
535 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_STRONGSWAN_CONF, ipsecVpnConfig->strongswanConf_);
536 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_CA_CERT_CONF, ipsecVpnConfig->ipsecCaCertConf_);
537 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRIVATE_USER_CERT_CONF,
538 ipsecVpnConfig->ipsecPrivateUserCertConf_);
539 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PUBLIC_USER_CERT_CONF,
540 ipsecVpnConfig->ipsecPublicUserCertConf_);
541 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRIVATE_SERVER_CERT_CONF,
542 ipsecVpnConfig->ipsecPrivateServerCertConf_);
543 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PUBLIC_SERVER_CERT_CONF,
544 ipsecVpnConfig->ipsecPublicServerCertConf_);
545 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_CA_CERT_FILE_PATH,
546 ipsecVpnConfig->ipsecCaCertFilePath_);
547 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRIVATE_USER_CERT_FILE_PATH,
548 ipsecVpnConfig->ipsecPrivateUserCertFilePath_);
549 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PUBLIC_USER_CERT_FILE_PATH,
550 ipsecVpnConfig->ipsecPublicUserCertFilePath_);
551 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRIVATE_SERVER_CERT_FILE_PATH,
552 ipsecVpnConfig->ipsecPrivateServerCertFilePath_);
553 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PUBLIC_SERVER_CERT_FILE_PATH,
554 ipsecVpnConfig->ipsecPublicServerCertFilePath_);
555 ipsecVpnConfig = nullptr;
556 return config;
557 }
558
CreateNapiL2tpVpnConfig(napi_env env,sptr<SysVpnConfig> & sysVpnConfig)559 napi_value CreateNapiL2tpVpnConfig(napi_env env, sptr<SysVpnConfig> &sysVpnConfig)
560 {
561 if (sysVpnConfig == nullptr) {
562 NETMGR_EXT_LOG_E("CreateNapiL2tpVpnConfig failed, param is null");
563 return NapiUtils::GetUndefined(env);
564 }
565 napi_value config = CreateNapiSysVpnConfig(env, sysVpnConfig);
566
567 L2tpVpnConfig *l2tpVpnConfig = static_cast<L2tpVpnConfig *>(sysVpnConfig.GetRefPtr());
568 if (l2tpVpnConfig == nullptr) {
569 NETMGR_EXT_LOG_E("CreateNapiL2tpVpnConfig failed, l2tpVpnConfig is null");
570 return NapiUtils::GetUndefined(env);
571 }
572 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRE_SHARE_KEY, l2tpVpnConfig->ipsecPreSharedKey_);
573 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_IDENTIFIER, l2tpVpnConfig->ipsecIdentifier_);
574 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_STRONGSWAN_CONF, l2tpVpnConfig->strongswanConf_);
575 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_CA_CERT_CONF, l2tpVpnConfig->ipsecCaCertConf_);
576 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRIVATE_USER_CERT_CONF,
577 l2tpVpnConfig->ipsecPrivateUserCertConf_);
578 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PUBLIC_USER_CERT_CONF,
579 l2tpVpnConfig->ipsecPublicUserCertConf_);
580 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRIVATE_SERVER_CERT_CONF,
581 l2tpVpnConfig->ipsecPrivateServerCertConf_);
582 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PUBLIC_SERVER_CERT_CONF,
583 l2tpVpnConfig->ipsecPublicServerCertConf_);
584 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_CA_CERT_FILE_PATH,
585 l2tpVpnConfig->ipsecCaCertFilePath_);
586 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRIVATE_USER_CERT_FILE_PATH,
587 l2tpVpnConfig->ipsecPrivateUserCertFilePath_);
588 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PUBLIC_USER_CERT_FILE_PATH,
589 l2tpVpnConfig->ipsecPublicUserCertFilePath_);
590 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PRIVATE_SERVER_CERT_FILE_PATH,
591 l2tpVpnConfig->ipsecPrivateServerCertFilePath_);
592 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_PUBLIC_SERVER_CERT_FILE_PATH,
593 l2tpVpnConfig->ipsecPublicServerCertFilePath_);
594 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_CONF, l2tpVpnConfig->ipsecConf_);
595 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_IPSEC_SECRETS, l2tpVpnConfig->ipsecSecrets_);
596 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_OPTIONS_L2TPD_CLIENT, l2tpVpnConfig->optionsL2tpdClient_);
597 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_XL2TPD_CONF, l2tpVpnConfig->xl2tpdConf_);
598 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_L2TP_SHARED_KEY, l2tpVpnConfig->l2tpSharedKey_);
599 l2tpVpnConfig = nullptr;
600 return config;
601 }
602
CreateNapiOpenvpnConfig(napi_env env,sptr<SysVpnConfig> sysVpnConfig)603 napi_value CreateNapiOpenvpnConfig(napi_env env, sptr<SysVpnConfig> sysVpnConfig)
604 {
605 if (sysVpnConfig == nullptr) {
606 NETMGR_EXT_LOG_E("CreateNapiOpenvpnConfig failed, param is null");
607 return NapiUtils::GetUndefined(env);
608 }
609 napi_value config = CreateNapiSysVpnConfig(env, sysVpnConfig);
610
611 OpenvpnConfig *openvpnConfig = static_cast<OpenvpnConfig *>(sysVpnConfig.GetRefPtr());
612 if (openvpnConfig == nullptr) {
613 NETMGR_EXT_LOG_E("CreateNapiOpenvpnConfig failed, openvpnConfig is null");
614 return NapiUtils::GetUndefined(env);
615 }
616 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_OVPN_PORT, openvpnConfig->ovpnPort_);
617 NapiUtils::SetInt32Property(env, config, CONFIG_OPENVPN_PROTOCOL, openvpnConfig->ovpnProtocol_);
618 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_OPENVPN_CFG, openvpnConfig->ovpnConfig_);
619 NapiUtils::SetInt32Property(env, config, CONFIG_OPENVPN_AUTH_TYPE, openvpnConfig->ovpnAuthType_);
620 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_ASKPASS, openvpnConfig->askpass_);
621 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_OPENVPN_CFG_FILE_PATH, openvpnConfig->ovpnConfigFilePath_);
622 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_OPENVPN_CA_CERT_FILE_PATH,
623 openvpnConfig->ovpnCaCertFilePath_);
624 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_OPENVPN_USER_CERT_FILE_PATH,
625 openvpnConfig->ovpnUserCertFilePath_);
626 NapiUtils::SetStringPropertyUtf8(env, config, CONFIG_OPENVPN_PRIVATE_KEY_FILE_PATH,
627 openvpnConfig->ovpnPrivateKeyFilePath_);
628 openvpnConfig = nullptr;
629 return config;
630 }
631 }
632 } // namespace NetManagerStandard
633 } // namespace OHOS
634