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