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