1 /*
2 * Copyright (c) 2023 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 #include "wifi_manager_addon.h"
16 #include "edm_log.h"
17 #include "message_parcel_utils.h"
18 #include "securec.h"
19
20 using namespace OHOS::EDM;
21
CreateWifiSecurityTypeObject(napi_env env,napi_value value)22 void WifiManagerAddon::CreateWifiSecurityTypeObject(napi_env env, napi_value value)
23 {
24 napi_value nInvalid;
25 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(SecurityType::SEC_TYPE_INVALID), &nInvalid));
26 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_INVALID", nInvalid));
27 napi_value nOpen;
28 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(SecurityType::SEC_TYPE_OPEN), &nOpen));
29 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_OPEN", nOpen));
30 napi_value nWep;
31 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(SecurityType::SEC_TYPE_WEP), &nWep));
32 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_WEP", nWep));
33 napi_value nPsk;
34 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(SecurityType::SEC_TYPE_PSK), &nPsk));
35 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_PSK", nPsk));
36 napi_value nSae;
37 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(SecurityType::SEC_TYPE_SAE), &nSae));
38 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_SAE", nSae));
39 napi_value nEap;
40 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(SecurityType::SEC_TYPE_EAP), &nEap));
41 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_EAP", nEap));
42 napi_value nEapSuiteB;
43 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
44 static_cast<int32_t>(SecurityType::SEC_TYPE_EAP_SUITE_B), &nEapSuiteB));
45 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_EAP_SUITE_B", nEapSuiteB));
46 napi_value nOwe;
47 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(SecurityType::SEC_TYPE_OWE), &nOwe));
48 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_OWE", nOwe));
49 napi_value nWapiCert;
50 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
51 static_cast<int32_t>(SecurityType::SEC_TYPE_WAPI_CERT), &nWapiCert));
52 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_WAPI_CERT", nWapiCert));
53 napi_value nWapiPsk;
54 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
55 static_cast<int32_t>(SecurityType::SEC_TYPE_WAPI_PSK), &nWapiPsk));
56 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "WIFI_SEC_TYPE_WAPI_PSK", nWapiPsk));
57 }
58
CreateIpTypeObject(napi_env env,napi_value value)59 void WifiManagerAddon::CreateIpTypeObject(napi_env env, napi_value value)
60 {
61 napi_value nStatic;
62 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IpType::STATIC), &nStatic));
63 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATIC", nStatic));
64 napi_value nDhcp;
65 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IpType::DHCP), &nDhcp));
66 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DHCP", nDhcp));
67 napi_value nUnknown;
68 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
69 static_cast<int32_t>(IpType::UNKNOWN), &nUnknown));
70 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UNKNOWN", nUnknown));
71 }
72
CreateEapMethodObject(napi_env env,napi_value value)73 void WifiManagerAddon::CreateEapMethodObject(napi_env env, napi_value value)
74 {
75 napi_value nNone;
76 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_NONE), &nNone));
77 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_NONE", nNone));
78 napi_value nPeap;
79 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_PEAP), &nPeap));
80 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_PEAP", nPeap));
81 napi_value nTls;
82 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_TLS), &nTls));
83 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_TLS", nTls));
84 napi_value nTtls;
85 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_TTLS), &nTtls));
86 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_TTLS", nTtls));
87 napi_value nPwd;
88 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_PWD), &nPwd));
89 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_PWD", nPwd));
90 napi_value nSim;
91 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_SIM), &nSim));
92 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_SIM", nSim));
93 napi_value nAka;
94 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_AKA), &nAka));
95 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_AKA", nAka));
96 napi_value nAkaPrime;
97 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_AKA_PRIME), &nAkaPrime));
98 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_AKA_PRIME", nAkaPrime));
99 napi_value nUnauthTls;
100 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(EapMethod::EAP_UNAUTH_TLS), &nUnauthTls));
101 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "EAP_UNAUTH_TLS", nUnauthTls));
102 }
103
CreatePhase2MethodObject(napi_env env,napi_value value)104 void WifiManagerAddon::CreatePhase2MethodObject(napi_env env, napi_value value)
105 {
106 napi_value nNone;
107 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::NONE), &nNone));
108 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_NONE", nNone));
109 napi_value nPap;
110 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::PAP), &nPap));
111 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_PAP", nPap));
112 napi_value nMSChap;
113 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::MSCHAP), &nMSChap));
114 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_MSCHAP", nMSChap));
115 napi_value nMSChapV2;
116 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::MSCHAPV2), &nMSChapV2));
117 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_MSCHAPV2", nMSChapV2));
118 napi_value nGtc;
119 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::GTC), &nGtc));
120 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_GTC", nGtc));
121 napi_value nSim;
122 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::SIM), &nSim));
123 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_SIM", nSim));
124 napi_value nAka;
125 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::AKA), &nAka));
126 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_AKA", nAka));
127 napi_value nAkaPrime;
128 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::AKA_PRIME), &nAkaPrime));
129 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_AKA_PRIME", nAkaPrime));
130 }
131
Init(napi_env env,napi_value exports)132 napi_value WifiManagerAddon::Init(napi_env env, napi_value exports)
133 {
134 napi_value nWifiSecurityType = nullptr;
135 NAPI_CALL(env, napi_create_object(env, &nWifiSecurityType));
136 CreateWifiSecurityTypeObject(env, nWifiSecurityType);
137
138 napi_value nIpType = nullptr;
139 NAPI_CALL(env, napi_create_object(env, &nIpType));
140 CreateIpTypeObject(env, nIpType);
141
142 napi_value nEapMethod = nullptr;
143 NAPI_CALL(env, napi_create_object(env, &nEapMethod));
144 CreateEapMethodObject(env, nEapMethod);
145
146 napi_value nPhase2Method = nullptr;
147 NAPI_CALL(env, napi_create_object(env, &nPhase2Method));
148 CreatePhase2MethodObject(env, nPhase2Method);
149
150 napi_property_descriptor property[] = {
151 DECLARE_NAPI_FUNCTION("isWifiActive", IsWifiActive),
152 DECLARE_NAPI_FUNCTION("setWifiProfile", SetWifiProfile),
153 DECLARE_NAPI_FUNCTION("setWifiDisabled", SetWifiDisabled),
154 DECLARE_NAPI_FUNCTION("isWifiDisabled", IsWifiDisabled),
155
156 DECLARE_NAPI_PROPERTY("WifiSecurityType", nWifiSecurityType),
157 DECLARE_NAPI_PROPERTY("IpType", nIpType),
158 DECLARE_NAPI_PROPERTY("EapMethod", nEapMethod),
159 DECLARE_NAPI_PROPERTY("Phase2Method", nPhase2Method)
160 };
161 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
162 return exports;
163 }
164
IsWifiActive(napi_env env,napi_callback_info info)165 napi_value WifiManagerAddon::IsWifiActive(napi_env env, napi_callback_info info)
166 {
167 EDMLOGI("WifiManagerAddon::IsWifiActive called");
168 size_t argc = ARGS_SIZE_TWO;
169 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
170 napi_value thisArg = nullptr;
171 void *data = nullptr;
172 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
173 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
174 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
175 if (argc > ARGS_SIZE_ONE) {
176 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
177 }
178 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
179 auto asyncCallbackInfo = new (std::nothrow) AsyncIsWifiActiveCallbackInfo();
180 if (asyncCallbackInfo == nullptr) {
181 return nullptr;
182 }
183 std::unique_ptr<AsyncIsWifiActiveCallbackInfo> callbackPtr {asyncCallbackInfo};
184 bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
185 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
186 EDMLOGD("IsWifiActive: asyncCallbackInfo->elementName.bundlename %{public}s, "
187 "asyncCallbackInfo->abilityname:%{public}s",
188 asyncCallbackInfo->elementName.GetBundleName().c_str(),
189 asyncCallbackInfo->elementName.GetAbilityName().c_str());
190 if (argc > ARGS_SIZE_ONE) {
191 EDMLOGD("NAPI_IsWifiActive argc == ARGS_SIZE_TWO");
192 napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
193 }
194 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "IsWifiActive",
195 NativeIsWifiActive, NativeBoolCallbackComplete);
196 callbackPtr.release();
197 return asyncWorkReturn;
198 }
199
SetWifiDisabled(napi_env env,napi_callback_info info)200 napi_value WifiManagerAddon::SetWifiDisabled(napi_env env, napi_callback_info info)
201 {
202 EDMLOGI("WifiManagerAddon::SetWifiDisabled called");
203 size_t argc = ARGS_SIZE_TWO;
204 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
205 napi_value thisArg = nullptr;
206 void *data = nullptr;
207 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
208 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
209 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
210 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean), "parameter bool error");
211 OHOS::AppExecFwk::ElementName elementName;
212 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
213 "element name param error");
214 EDMLOGD(
215 "SetWifiDisabled: elementName.bundlename: %{public}s, "
216 "elementName.abilityname: %{public}s",
217 elementName.GetBundleName().c_str(),
218 elementName.GetAbilityName().c_str());
219 bool isDisabled = false;
220 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, isDisabled, argv[ARR_INDEX_ONE]),
221 "parameter isDisabled error");
222 int32_t ret = WifiManagerProxy::GetWifiManagerProxy()->SetWifiDisabled(elementName, isDisabled);
223 if (FAILED(ret)) {
224 napi_throw(env, CreateError(env, ret));
225 }
226 return nullptr;
227 }
228
IsWifiDisabled(napi_env env,napi_callback_info info)229 napi_value WifiManagerAddon::IsWifiDisabled(napi_env env, napi_callback_info info)
230 {
231 EDMLOGI("WifiManagerAddon::IsWifiDisabled called");
232 size_t argc = ARGS_SIZE_TWO;
233 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
234 napi_value thisArg = nullptr;
235 void *data = nullptr;
236 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
237 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
238 bool hasAdmin = false;
239 OHOS::AppExecFwk::ElementName elementName;
240 ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
241 "param admin need be null or want");
242 bool isDisabled = false;
243 int32_t ret = ERR_OK;
244 if (hasAdmin) {
245 ret = WifiManagerProxy::GetWifiManagerProxy()->IsWifiDisabled(&elementName, isDisabled);
246 } else {
247 ret = WifiManagerProxy::GetWifiManagerProxy()->IsWifiDisabled(nullptr, isDisabled);
248 }
249 if (FAILED(ret)) {
250 napi_throw(env, CreateError(env, ret));
251 return nullptr;
252 }
253 napi_value result = nullptr;
254 napi_get_boolean(env, isDisabled, &result);
255 return result;
256 }
257
SetWifiProfile(napi_env env,napi_callback_info info)258 napi_value WifiManagerAddon::SetWifiProfile(napi_env env, napi_callback_info info)
259 {
260 EDMLOGI("WifiManagerAddon::SetWifiProfile called");
261 size_t argc = ARGS_SIZE_THREE;
262 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
263 napi_value thisArg = nullptr;
264 void *data = nullptr;
265 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
266 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
267 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
268 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
269 if (argc > ARGS_SIZE_TWO) {
270 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
271 }
272 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
273 auto asyncCallbackInfo = new (std::nothrow) AsyncSetWifiProfileCallbackInfo();
274 if (asyncCallbackInfo == nullptr) {
275 return nullptr;
276 }
277 std::unique_ptr<AsyncSetWifiProfileCallbackInfo> callbackPtr {asyncCallbackInfo};
278 ASSERT_AND_THROW_PARAM_ERROR(env,
279 ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]), "element name param error");
280 EDMLOGD("SetWifiProfile: asyncCallbackInfo->elementName.bundlename %{public}s, "
281 "asyncCallbackInfo->abilityname:%{public}s",
282 asyncCallbackInfo->elementName.GetBundleName().c_str(),
283 asyncCallbackInfo->elementName.GetAbilityName().c_str());
284 ASSERT_AND_THROW_PARAM_ERROR(env,
285 JsObjToDeviceConfig(env, argv[ARR_INDEX_ONE], asyncCallbackInfo->wifiDeviceConfig), "wifiProfile param error");
286 if (argc > ARGS_SIZE_TWO) {
287 EDMLOGD("NAPI_SetWifiProfile argc == ARGS_SIZE_THREE");
288 napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
289 }
290 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetWifiProfile",
291 NativeSetWifiProfile, NativeVoidCallbackComplete);
292 callbackPtr.release();
293 return asyncWorkReturn;
294 }
295
NativeSetWifiProfile(napi_env env,void * data)296 void WifiManagerAddon::NativeSetWifiProfile(napi_env env, void *data)
297 {
298 EDMLOGI("NAPI_NativeSetWifiProfile called");
299 if (data == nullptr) {
300 EDMLOGE("data is nullptr");
301 return;
302 }
303 AsyncSetWifiProfileCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetWifiProfileCallbackInfo *>(data);
304 auto wifiManagerProxy = WifiManagerProxy::GetWifiManagerProxy();
305 if (wifiManagerProxy == nullptr) {
306 EDMLOGE("can not get WifiManagerProxy");
307 return;
308 }
309 asyncCallbackInfo->ret = wifiManagerProxy->SetWifiProfile(asyncCallbackInfo->elementName,
310 asyncCallbackInfo->wifiDeviceConfig);
311 }
312
NativeIsWifiActive(napi_env env,void * data)313 void WifiManagerAddon::NativeIsWifiActive(napi_env env, void *data)
314 {
315 EDMLOGI("NAPI_NativeIsWifiActive called");
316 if (data == nullptr) {
317 EDMLOGE("data is nullptr");
318 return;
319 }
320 AsyncIsWifiActiveCallbackInfo *asyncCallbackInfo = static_cast<AsyncIsWifiActiveCallbackInfo *>(data);
321 auto wifiManagerProxy = WifiManagerProxy::GetWifiManagerProxy();
322 if (wifiManagerProxy == nullptr) {
323 EDMLOGE("can not get WifiManagerProxy");
324 return;
325 }
326 asyncCallbackInfo->ret = wifiManagerProxy->IsWifiActive(asyncCallbackInfo->elementName,
327 asyncCallbackInfo->boolRet);
328 }
329
JsObjToDeviceConfig(napi_env env,napi_value object,Wifi::WifiDeviceConfig & config)330 bool WifiManagerAddon::JsObjToDeviceConfig(napi_env env, napi_value object, Wifi::WifiDeviceConfig &config)
331 {
332 int32_t type = static_cast<int32_t>(SecurityType::SEC_TYPE_INVALID);
333 int32_t ipType = static_cast<int32_t>(IpType::UNKNOWN);
334 /* "creatorUid" "disableReason" "randomMacType" "randomMacAddr" is not supported currently */
335 if (!JsObjectToString(env, object, "ssid", true, config.ssid) ||
336 !JsObjectToString(env, object, "bssid", false, config.bssid) ||
337 !JsObjectToString(env, object, "preSharedKey", true, config.preSharedKey) ||
338 !JsObjectToBool(env, object, "isHiddenSsid", false, config.hiddenSSID) ||
339 !JsObjectToInt(env, object, "securityType", true, type) ||
340 !JsObjectToInt(env, object, "netId", false, config.networkId) ||
341 !JsObjectToInt(env, object, "ipType", false, ipType) ||
342 !ProcessIpType(ipType, env, object, config.wifiIpConfig)) {
343 return false;
344 }
345 ConvertEncryptionMode(type, config);
346 if (type == static_cast<int32_t>(SecurityType::SEC_TYPE_EAP)) {
347 return ProcessEapConfig(env, object, config.wifiEapConfig);
348 }
349 return true;
350 }
351
ConvertEncryptionMode(int32_t securityType,Wifi::WifiDeviceConfig & config)352 void WifiManagerAddon::ConvertEncryptionMode(int32_t securityType, Wifi::WifiDeviceConfig &config)
353 {
354 switch (securityType) {
355 case static_cast<int32_t>(SecurityType::SEC_TYPE_OPEN):
356 config.keyMgmt = Wifi::KEY_MGMT_NONE;
357 break;
358 case static_cast<int32_t>(SecurityType::SEC_TYPE_WEP):
359 config.keyMgmt = Wifi::KEY_MGMT_WEP;
360 config.wepKeys[0] = config.preSharedKey;
361 config.wepTxKeyIndex = 0;
362 config.preSharedKey = "";
363 break;
364 case static_cast<int32_t>(SecurityType::SEC_TYPE_PSK):
365 config.keyMgmt = Wifi::KEY_MGMT_WPA_PSK;
366 break;
367 case static_cast<int32_t>(SecurityType::SEC_TYPE_SAE):
368 config.keyMgmt = Wifi::KEY_MGMT_SAE;
369 break;
370 case static_cast<int32_t>(SecurityType::SEC_TYPE_EAP):
371 config.keyMgmt = Wifi::KEY_MGMT_EAP;
372 break;
373 default:
374 config.keyMgmt = Wifi::KEY_MGMT_NONE;
375 break;
376 }
377 }
378
ProcessIpType(int32_t ipType,napi_env env,napi_value object,Wifi::WifiIpConfig & ipConfig)379 bool WifiManagerAddon::ProcessIpType(int32_t ipType, napi_env env, napi_value object, Wifi::WifiIpConfig &ipConfig)
380 {
381 switch (ipType) {
382 case static_cast<int32_t>(IpType::DHCP):
383 ipConfig.assignMethod = Wifi::AssignIpMethod::DHCP;
384 break;
385 case static_cast<int32_t>(IpType::STATIC):
386 ipConfig.assignMethod = Wifi::AssignIpMethod::STATIC;
387 break;
388 default:
389 ipConfig.assignMethod = Wifi::AssignIpMethod::UNASSIGNED;
390 break;
391 }
392 if (ipType == static_cast<int32_t>(IpType::STATIC) && !ConfigStaticIp(env, object, ipConfig)) {
393 return false;
394 }
395 return true;
396 }
397
ConfigStaticIp(napi_env env,napi_value object,Wifi::WifiIpConfig & ipConfig)398 bool WifiManagerAddon::ConfigStaticIp(napi_env env, napi_value object, Wifi::WifiIpConfig &ipConfig)
399 {
400 napi_value staticIp;
401 napi_value dnsServers;
402 napi_value primaryDns;
403 napi_value secondDns;
404 if (!GetJsProperty(env, object, "staticIp", staticIp) ||
405 !JsObjectToUint(env, staticIp, "ipAddress", true,
406 ipConfig.staticIpAddress.ipAddress.address.addressIpv4) ||
407 !JsObjectToUint(env, staticIp, "gateway", true,
408 ipConfig.staticIpAddress.gateway.addressIpv4) ||
409 !JsObjectToInt(env, staticIp, "prefixLength", true,
410 ipConfig.staticIpAddress.ipAddress.prefixLength) ||
411 !GetJsProperty(env, staticIp, "dnsServers", dnsServers)) {
412 return false;
413 }
414 ipConfig.staticIpAddress.ipAddress.address.family = 0;
415 uint32_t arrayLength = 0;
416 const uint32_t DNS_NUM = 2;
417 napi_get_array_length(env, dnsServers, &arrayLength);
418 if (arrayLength != DNS_NUM) {
419 EDMLOGI("ConfigStaticIp, It needs two dns servers.");
420 return false;
421 }
422 napi_get_element(env, dnsServers, 0, &primaryDns);
423 napi_get_element(env, dnsServers, 1, &secondDns);
424 napi_get_value_uint32(env, primaryDns, &ipConfig.staticIpAddress.dnsServer1.addressIpv4);
425 napi_get_value_uint32(env, secondDns, &ipConfig.staticIpAddress.dnsServer2.addressIpv4);
426 return true;
427 }
428
ProcessEapConfig(napi_env env,napi_value object,Wifi::WifiEapConfig & eapConfig)429 bool WifiManagerAddon::ProcessEapConfig(napi_env env, napi_value object, Wifi::WifiEapConfig &eapConfig)
430 {
431 napi_value napiEap;
432 int32_t eapMethod = static_cast<int32_t>(EapMethod::EAP_NONE);
433 if (!GetJsProperty(env, object, "eapProfile", napiEap) ||
434 !JsObjectToInt(env, napiEap, "eapMethod", true, eapMethod)) {
435 return false;
436 }
437 switch (eapMethod) {
438 case static_cast<int32_t>(EapMethod::EAP_PEAP):
439 ProcessEapPeapConfig(env, napiEap, eapConfig);
440 break;
441 case static_cast<int32_t>(EapMethod::EAP_TLS):
442 ProcessEapTlsConfig(env, napiEap, eapConfig);
443 break;
444 default:
445 EDMLOGI("EapMethod: %{public}d unsupported", eapMethod);
446 return false;
447 }
448 return true;
449 }
450
ProcessEapPeapConfig(napi_env env,napi_value object,Wifi::WifiEapConfig & eapConfig)451 bool WifiManagerAddon::ProcessEapPeapConfig(napi_env env, napi_value object, Wifi::WifiEapConfig &eapConfig)
452 {
453 eapConfig.eap = Wifi::EAP_METHOD_PEAP;
454 int32_t phase2 = static_cast<int32_t>(Wifi::Phase2Method::NONE);
455 if (!JsObjectToString(env, object, "identity", true, eapConfig.identity) ||
456 !JsObjectToString(env, object, "password", true, eapConfig.password) ||
457 !JsObjectToInt(env, object, "phase2Method", true, phase2)) {
458 return false;
459 }
460 MessageParcelUtils::ProcessPhase2Method(phase2, eapConfig);
461 return true;
462 }
463
ProcessEapTlsConfig(napi_env env,napi_value object,Wifi::WifiEapConfig & eapConfig)464 bool WifiManagerAddon::ProcessEapTlsConfig(napi_env env, napi_value object, Wifi::WifiEapConfig &eapConfig)
465 {
466 eapConfig.eap = Wifi::EAP_METHOD_TLS;
467 std::tuple<int, bool> charArrayProp = {WIFI_PASSWORD_LEN, true};
468 if (!JsObjectToString(env, object, "identity", true, eapConfig.identity) ||
469 !JsObjectToCharArray(env, object, "certPassword", charArrayProp, eapConfig.certPassword) ||
470 !JsObjectToU8Vector(env, object, "certEntry", eapConfig.certEntry)) {
471 return false;
472 }
473 return true;
474 }
475
476 static napi_module g_wifiManagerModule = {
477 .nm_version = 1,
478 .nm_flags = 0,
479 .nm_filename = nullptr,
480 .nm_register_func = WifiManagerAddon::Init,
481 .nm_modname = "enterprise.wifiManager",
482 .nm_priv = ((void *)0),
483 .reserved = { 0 },
484 };
485
WifiManagerRegister()486 extern "C" __attribute__((constructor)) void WifiManagerRegister()
487 {
488 napi_module_register(&g_wifiManagerModule);
489 }