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