1 /*
2  * Copyright (c) 2023-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 #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 #ifdef WIFI_EDM_ENABLE
107     napi_value nNone;
108     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::NONE), &nNone));
109     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_NONE", nNone));
110     napi_value nPap;
111     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::PAP), &nPap));
112     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_PAP", nPap));
113     napi_value nMSChap;
114     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::MSCHAP), &nMSChap));
115     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_MSCHAP", nMSChap));
116     napi_value nMSChapV2;
117     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::MSCHAPV2), &nMSChapV2));
118     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_MSCHAPV2", nMSChapV2));
119     napi_value nGtc;
120     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::GTC), &nGtc));
121     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_GTC", nGtc));
122     napi_value nSim;
123     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::SIM), &nSim));
124     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_SIM", nSim));
125     napi_value nAka;
126     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::AKA), &nAka));
127     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_AKA", nAka));
128     napi_value nAkaPrime;
129     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(Wifi::Phase2Method::AKA_PRIME), &nAkaPrime));
130     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "PHASE2_AKA_PRIME", nAkaPrime));
131 #endif
132 }
133 
Init(napi_env env,napi_value exports)134 napi_value WifiManagerAddon::Init(napi_env env, napi_value exports)
135 {
136     napi_value nWifiSecurityType = nullptr;
137     NAPI_CALL(env, napi_create_object(env, &nWifiSecurityType));
138     CreateWifiSecurityTypeObject(env, nWifiSecurityType);
139 
140     napi_value nIpType = nullptr;
141     NAPI_CALL(env, napi_create_object(env, &nIpType));
142     CreateIpTypeObject(env, nIpType);
143 
144     napi_value nEapMethod = nullptr;
145     NAPI_CALL(env, napi_create_object(env, &nEapMethod));
146     CreateEapMethodObject(env, nEapMethod);
147 
148     napi_value nPhase2Method = nullptr;
149     NAPI_CALL(env, napi_create_object(env, &nPhase2Method));
150     CreatePhase2MethodObject(env, nPhase2Method);
151 
152     napi_property_descriptor property[] = {
153         DECLARE_NAPI_FUNCTION("isWifiActive", IsWifiActive),
154         DECLARE_NAPI_FUNCTION("setWifiProfile", SetWifiProfile),
155         DECLARE_NAPI_FUNCTION("setWifiDisabled", SetWifiDisabled),
156         DECLARE_NAPI_FUNCTION("isWifiDisabled", IsWifiDisabled),
157         DECLARE_NAPI_FUNCTION("isWifiActiveSync", IsWifiActiveSync),
158         DECLARE_NAPI_FUNCTION("setWifiProfileSync", SetWifiProfileSync),
159 
160         DECLARE_NAPI_PROPERTY("WifiSecurityType", nWifiSecurityType),
161         DECLARE_NAPI_PROPERTY("IpType", nIpType),
162         DECLARE_NAPI_PROPERTY("EapMethod", nEapMethod),
163         DECLARE_NAPI_PROPERTY("Phase2Method", nPhase2Method)
164     };
165     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
166     return exports;
167 }
168 
IsWifiActive(napi_env env,napi_callback_info info)169 napi_value WifiManagerAddon::IsWifiActive(napi_env env, napi_callback_info info)
170 {
171     EDMLOGI("WifiManagerAddon::IsWifiActive called");
172     size_t argc = ARGS_SIZE_TWO;
173     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
174     napi_value thisArg = nullptr;
175     void *data = nullptr;
176     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
177     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
178     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
179     if (argc > ARGS_SIZE_ONE) {
180         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
181     }
182     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
183     auto asyncCallbackInfo = new (std::nothrow) AsyncIsWifiActiveCallbackInfo();
184     if (asyncCallbackInfo == nullptr) {
185         return nullptr;
186     }
187     std::unique_ptr<AsyncIsWifiActiveCallbackInfo> callbackPtr {asyncCallbackInfo};
188     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
189     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
190     EDMLOGD("IsWifiActive: asyncCallbackInfo->elementName.bundlename %{public}s, "
191         "asyncCallbackInfo->abilityname:%{public}s",
192         asyncCallbackInfo->elementName.GetBundleName().c_str(),
193         asyncCallbackInfo->elementName.GetAbilityName().c_str());
194     if (argc > ARGS_SIZE_ONE) {
195         EDMLOGD("NAPI_IsWifiActive argc == ARGS_SIZE_TWO");
196         napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
197     }
198     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "IsWifiActive",
199         NativeIsWifiActive, NativeBoolCallbackComplete);
200     callbackPtr.release();
201     return asyncWorkReturn;
202 }
203 
SetWifiDisabled(napi_env env,napi_callback_info info)204 napi_value WifiManagerAddon::SetWifiDisabled(napi_env env, napi_callback_info info)
205 {
206     EDMLOGI("WifiManagerAddon::SetWifiDisabled called");
207     size_t argc = ARGS_SIZE_TWO;
208     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
209     napi_value thisArg = nullptr;
210     void *data = nullptr;
211     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
212     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
213     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
214     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean), "parameter bool error");
215     OHOS::AppExecFwk::ElementName elementName;
216     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
217         "element name param error");
218     EDMLOGD(
219         "SetWifiDisabled: elementName.bundlename: %{public}s, "
220         "elementName.abilityname: %{public}s",
221         elementName.GetBundleName().c_str(),
222         elementName.GetAbilityName().c_str());
223     bool isDisabled = false;
224     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, isDisabled, argv[ARR_INDEX_ONE]),
225         "parameter isDisabled error");
226     int32_t ret = WifiManagerProxy::GetWifiManagerProxy()->SetWifiDisabled(elementName, isDisabled);
227     if (FAILED(ret)) {
228         napi_throw(env, CreateError(env, ret));
229     }
230     return nullptr;
231 }
232 
IsWifiDisabled(napi_env env,napi_callback_info info)233 napi_value WifiManagerAddon::IsWifiDisabled(napi_env env, napi_callback_info info)
234 {
235     EDMLOGI("WifiManagerAddon::IsWifiDisabled called");
236     size_t argc = ARGS_SIZE_TWO;
237     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
238     napi_value thisArg = nullptr;
239     void *data = nullptr;
240     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
241     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
242     bool hasAdmin = false;
243     OHOS::AppExecFwk::ElementName elementName;
244     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
245         "param admin need be null or want");
246     bool isDisabled = false;
247     int32_t ret = ERR_OK;
248     if (hasAdmin) {
249         ret = WifiManagerProxy::GetWifiManagerProxy()->IsWifiDisabled(&elementName, isDisabled);
250     } else {
251         ret = WifiManagerProxy::GetWifiManagerProxy()->IsWifiDisabled(nullptr, isDisabled);
252     }
253     if (FAILED(ret)) {
254         napi_throw(env, CreateError(env, ret));
255         return nullptr;
256     }
257     napi_value result = nullptr;
258     napi_get_boolean(env, isDisabled, &result);
259     return result;
260 }
261 
SetWifiProfile(napi_env env,napi_callback_info info)262 napi_value WifiManagerAddon::SetWifiProfile(napi_env env, napi_callback_info info)
263 {
264 #ifdef WIFI_EDM_ENABLE
265     EDMLOGI("WifiManagerAddon::SetWifiProfile called");
266     size_t argc = ARGS_SIZE_THREE;
267     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
268     napi_value thisArg = nullptr;
269     void *data = nullptr;
270     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
271     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
272     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
273     matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
274     if (argc > ARGS_SIZE_TWO) {
275         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
276     }
277     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
278     auto asyncCallbackInfo = new (std::nothrow) AsyncSetWifiProfileCallbackInfo();
279     if (asyncCallbackInfo == nullptr) {
280         return nullptr;
281     }
282     std::unique_ptr<AsyncSetWifiProfileCallbackInfo> callbackPtr {asyncCallbackInfo};
283     ASSERT_AND_THROW_PARAM_ERROR(env,
284         ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]), "element name param error");
285     EDMLOGD("SetWifiProfile: asyncCallbackInfo->elementName.bundlename %{public}s, "
286         "asyncCallbackInfo->abilityname:%{public}s",
287         asyncCallbackInfo->elementName.GetBundleName().c_str(),
288         asyncCallbackInfo->elementName.GetAbilityName().c_str());
289     bool parseRet = JsObjToDeviceConfig(env, argv[ARR_INDEX_ONE], asyncCallbackInfo->wifiDeviceConfig,
290         asyncCallbackInfo->pwd);
291     if (!parseRet) {
292         napi_throw(env, CreateError(env, EdmReturnErrCode::PARAM_ERROR, "parameter profile parse error"));
293         return nullptr;
294     }
295 
296     if (argc > ARGS_SIZE_TWO) {
297         EDMLOGD("NAPI_SetWifiProfile argc == ARGS_SIZE_THREE");
298         napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
299     }
300     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetWifiProfile",
301         NativeSetWifiProfile, NativeVoidCallbackComplete);
302     callbackPtr.release();
303     return asyncWorkReturn;
304 #else
305     EDMLOGW("WifiManagerAddon::SetWifiProfile Unsupported Capabilities.");
306     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
307     return nullptr;
308 #endif
309 }
310 
311 #ifdef WIFI_EDM_ENABLE
NativeSetWifiProfile(napi_env env,void * data)312 void WifiManagerAddon::NativeSetWifiProfile(napi_env env, void *data)
313 {
314     EDMLOGI("NAPI_NativeSetWifiProfile called");
315     if (data == nullptr) {
316         EDMLOGE("data is nullptr");
317         return;
318     }
319     AsyncSetWifiProfileCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetWifiProfileCallbackInfo *>(data);
320     auto wifiManagerProxy = WifiManagerProxy::GetWifiManagerProxy();
321     if (wifiManagerProxy == nullptr) {
322         EDMLOGE("can not get WifiManagerProxy");
323         return;
324     }
325     asyncCallbackInfo->ret = wifiManagerProxy->SetWifiProfile(asyncCallbackInfo->elementName,
326         asyncCallbackInfo->wifiDeviceConfig, asyncCallbackInfo->pwd);
327 }
328 #endif
329 
NativeIsWifiActive(napi_env env,void * data)330 void WifiManagerAddon::NativeIsWifiActive(napi_env env, void *data)
331 {
332     EDMLOGI("NAPI_NativeIsWifiActive called");
333     if (data == nullptr) {
334         EDMLOGE("data is nullptr");
335         return;
336     }
337     AsyncIsWifiActiveCallbackInfo *asyncCallbackInfo = static_cast<AsyncIsWifiActiveCallbackInfo *>(data);
338     auto wifiManagerProxy = WifiManagerProxy::GetWifiManagerProxy();
339     if (wifiManagerProxy == nullptr) {
340         EDMLOGE("can not get WifiManagerProxy");
341         return;
342     }
343     asyncCallbackInfo->ret = wifiManagerProxy->IsWifiActive(asyncCallbackInfo->elementName,
344         asyncCallbackInfo->boolRet);
345 }
346 #ifdef WIFI_EDM_ENABLE
JsObjToDeviceConfig(napi_env env,napi_value object,Wifi::WifiDeviceConfig & config,WifiPassword & pwd)347 bool WifiManagerAddon::JsObjToDeviceConfig(napi_env env, napi_value object, Wifi::WifiDeviceConfig &config,
348     WifiPassword &pwd)
349 {
350     int32_t type = static_cast<int32_t>(SecurityType::SEC_TYPE_INVALID);
351     int32_t ipType = static_cast<int32_t>(IpType::UNKNOWN);
352     /* "creatorUid" "disableReason" "randomMacType" "randomMacAddr" is not supported currently */
353     std::tuple<int, bool> charArrayProp = {WIFI_PASSWORD_LEN, true};
354     std::vector<char> ret;
355     if (!JsObjectToString(env, object, "ssid", true, config.ssid) ||
356         !JsObjectToString(env, object, "bssid", false, config.bssid) ||
357         !JsObjectToCharArray(env, object, "preSharedKey", charArrayProp, ret) ||
358         !JsObjectToBool(env, object, "isHiddenSsid", false, config.hiddenSSID) ||
359         !JsObjectToInt(env, object, "securityType", true, type) ||
360         !JsObjectToInt(env, object, "netId", false, config.networkId) ||
361         !JsObjectToInt(env, object, "ipType", false, ipType) ||
362         !ProcessIpType(ipType, env, object, config.wifiIpConfig)) {
363         return false;
364     }
365     if (ret.size() != 0) {
366         pwd.preSharedKey = (char*) malloc(ret.size());
367         if (pwd.preSharedKey == nullptr) {
368             memset_s(ret.data(), ret.size(), '\0', ret.size());
369             return false;
370         }
371         if (strncpy_s(pwd.preSharedKey, ret.size(), ret.data(), ret.size()) != ERR_OK) {
372             memset_s(ret.data(), ret.size(), '\0', ret.size());
373             return false;
374         }
375         memset_s(ret.data(), ret.size(), '\0', ret.size());
376         pwd.preSharedKeySize = ret.size();
377     }
378     if (!ConvertEncryptionMode(type, config, pwd)) {
379         return false;
380     }
381     if (type == static_cast<int32_t>(SecurityType::SEC_TYPE_EAP)) {
382         return ProcessEapConfig(env, object, config.wifiEapConfig, pwd);
383     }
384     return true;
385 }
386 
ConvertEncryptionMode(int32_t securityType,Wifi::WifiDeviceConfig & config,WifiPassword & pwd)387 bool WifiManagerAddon::ConvertEncryptionMode(int32_t securityType, Wifi::WifiDeviceConfig &config, WifiPassword &pwd)
388 {
389     switch (securityType) {
390         case static_cast<int32_t>(SecurityType::SEC_TYPE_OPEN):
391             config.keyMgmt = Wifi::KEY_MGMT_NONE;
392             break;
393         case static_cast<int32_t>(SecurityType::SEC_TYPE_WEP):
394             config.keyMgmt = Wifi::KEY_MGMT_WEP;
395             pwd.wepKey = (char*) malloc((pwd.preSharedKeySize + NAPI_RETURN_ONE) * sizeof(char));
396             if (pwd.wepKey == nullptr) {
397                 return false;
398             }
399             if (strncpy_s(pwd.wepKey, pwd.preSharedKeySize + NAPI_RETURN_ONE,
400                 pwd.preSharedKey, pwd.preSharedKeySize) != ERR_OK) {
401                 return false;
402             }
403             pwd.wepKeySize = pwd.preSharedKeySize;
404             EdmUtils::ClearCharArray(pwd.preSharedKey, pwd.preSharedKeySize);
405             pwd.preSharedKeySize = 0;
406             config.wepTxKeyIndex = 0;
407             break;
408         case static_cast<int32_t>(SecurityType::SEC_TYPE_PSK):
409             config.keyMgmt = Wifi::KEY_MGMT_WPA_PSK;
410             break;
411         case static_cast<int32_t>(SecurityType::SEC_TYPE_SAE):
412             config.keyMgmt = Wifi::KEY_MGMT_SAE;
413             break;
414         case static_cast<int32_t>(SecurityType::SEC_TYPE_EAP):
415             config.keyMgmt = Wifi::KEY_MGMT_EAP;
416             break;
417         default:
418             config.keyMgmt = Wifi::KEY_MGMT_NONE;
419             break;
420     }
421     return true;
422 }
423 
ProcessIpType(int32_t ipType,napi_env env,napi_value object,Wifi::WifiIpConfig & ipConfig)424 bool WifiManagerAddon::ProcessIpType(int32_t ipType, napi_env env, napi_value object, Wifi::WifiIpConfig &ipConfig)
425 {
426     switch (ipType) {
427         case static_cast<int32_t>(IpType::DHCP):
428             ipConfig.assignMethod = Wifi::AssignIpMethod::DHCP;
429             break;
430         case static_cast<int32_t>(IpType::STATIC):
431             ipConfig.assignMethod = Wifi::AssignIpMethod::STATIC;
432             break;
433         default:
434             ipConfig.assignMethod = Wifi::AssignIpMethod::UNASSIGNED;
435             break;
436     }
437     if (ipType == static_cast<int32_t>(IpType::STATIC) && !ConfigStaticIp(env, object, ipConfig)) {
438         return false;
439     }
440     return true;
441 }
442 
ConfigStaticIp(napi_env env,napi_value object,Wifi::WifiIpConfig & ipConfig)443 bool WifiManagerAddon::ConfigStaticIp(napi_env env, napi_value object, Wifi::WifiIpConfig &ipConfig)
444 {
445     napi_value staticIp;
446     napi_value dnsServers;
447     napi_value primaryDns;
448     napi_value secondDns;
449     if (!GetJsProperty(env, object, "staticIp", staticIp) ||
450         !JsObjectToUint(env, staticIp, "ipAddress", true,
451         ipConfig.staticIpAddress.ipAddress.address.addressIpv4) ||
452         !JsObjectToUint(env, staticIp, "gateway", true,
453         ipConfig.staticIpAddress.gateway.addressIpv4) ||
454         !JsObjectToInt(env, staticIp, "prefixLength", true,
455         ipConfig.staticIpAddress.ipAddress.prefixLength) ||
456         !GetJsProperty(env, staticIp, "dnsServers", dnsServers)) {
457         return false;
458     }
459     ipConfig.staticIpAddress.ipAddress.address.family = 0;
460     uint32_t arrayLength = 0;
461     const uint32_t DNS_NUM = 2;
462     napi_get_array_length(env, dnsServers, &arrayLength);
463     if (arrayLength != DNS_NUM) {
464         EDMLOGI("ConfigStaticIp, It needs two dns servers.");
465         return false;
466     }
467     napi_get_element(env, dnsServers, 0, &primaryDns);
468     napi_get_element(env, dnsServers, 1, &secondDns);
469     napi_get_value_uint32(env, primaryDns, &ipConfig.staticIpAddress.dnsServer1.addressIpv4);
470     napi_get_value_uint32(env, secondDns, &ipConfig.staticIpAddress.dnsServer2.addressIpv4);
471     return true;
472 }
473 
ProcessEapConfig(napi_env env,napi_value object,Wifi::WifiEapConfig & eapConfig,WifiPassword & pwd)474 bool WifiManagerAddon::ProcessEapConfig(napi_env env, napi_value object, Wifi::WifiEapConfig &eapConfig,
475     WifiPassword &pwd)
476 {
477     napi_value napiEap;
478     int32_t eapMethod = static_cast<int32_t>(EapMethod::EAP_NONE);
479     if (!GetJsProperty(env, object, "eapProfile", napiEap) ||
480         !JsObjectToInt(env, napiEap, "eapMethod", true, eapMethod)) {
481         return false;
482     }
483     switch (eapMethod) {
484         case static_cast<int32_t>(EapMethod::EAP_PEAP):
485             ProcessEapPeapConfig(env, napiEap, eapConfig, pwd);
486             break;
487         case static_cast<int32_t>(EapMethod::EAP_TLS):
488             ProcessEapTlsConfig(env, napiEap, eapConfig);
489             break;
490         default:
491             EDMLOGI("EapMethod: %{public}d unsupported", eapMethod);
492             return false;
493     }
494     return true;
495 }
496 
ProcessEapPeapConfig(napi_env env,napi_value object,Wifi::WifiEapConfig & eapConfig,WifiPassword & pwd)497 bool WifiManagerAddon::ProcessEapPeapConfig(napi_env env, napi_value object, Wifi::WifiEapConfig &eapConfig,
498     WifiPassword &pwd)
499 {
500     eapConfig.eap = Wifi::EAP_METHOD_PEAP;
501     int32_t phase2 = static_cast<int32_t>(Wifi::Phase2Method::NONE);
502     std::tuple<int, bool> charArrayProp = {WIFI_PASSWORD_LEN, true};
503     std::vector<char> ret;
504     if (!JsObjectToString(env, object, "identity", true, eapConfig.identity) ||
505         !JsObjectToCharArray(env, object, "password", charArrayProp, ret) ||
506         !JsObjectToInt(env, object, "phase2Method", true, phase2)) {
507         return false;
508     }
509     if (ret.size() != 0) {
510         pwd.password = (char*) malloc(ret.size());
511         if (pwd.password == nullptr) {
512             memset_s(ret.data(), ret.size(), '\0', ret.size());
513             return false;
514         }
515         if (strncpy_s(pwd.password, ret.size(), ret.data(), ret.size()) != ERR_OK) {
516             memset_s(ret.data(), ret.size(), '\0', ret.size());
517             return false;
518         }
519         memset_s(ret.data(), ret.size(), '\0', ret.size());
520         pwd.preSharedKeySize = ret.size();
521     }
522     MessageParcelUtils::ProcessPhase2Method(phase2, eapConfig);
523     return true;
524 }
525 
ProcessEapTlsConfig(napi_env env,napi_value object,Wifi::WifiEapConfig & eapConfig)526 bool WifiManagerAddon::ProcessEapTlsConfig(napi_env env, napi_value object, Wifi::WifiEapConfig &eapConfig)
527 {
528     eapConfig.eap = Wifi::EAP_METHOD_TLS;
529     std::tuple<int, bool> charArrayProp = {WIFI_PASSWORD_LEN, true};
530     std::vector<char> ret;
531     if (!JsObjectToString(env, object, "identity", true, eapConfig.identity) ||
532         !JsObjectToCharArray(env, object, "certPassword", charArrayProp, ret) ||
533         !JsObjectToU8Vector(env, object, "certEntry", eapConfig.certEntry)) {
534         return false;
535     }
536     if (ret.size() != 0) {
537         if (strncpy_s(eapConfig.certPassword, ret.size(), ret.data(), ret.size()) != ERR_OK) {
538             memset_s(ret.data(), ret.size(), '\0', ret.size());
539             return false;
540         }
541         memset_s(ret.data(), ret.size(), '\0', ret.size());
542     }
543     return true;
544 }
545 #endif
546 
IsWifiActiveSync(napi_env env,napi_callback_info info)547 napi_value WifiManagerAddon::IsWifiActiveSync(napi_env env, napi_callback_info info)
548 {
549     EDMLOGI("WifiManagerAddon::IsWifiActiveSync called");
550     size_t argc = ARGS_SIZE_ONE;
551     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
552     napi_value thisArg = nullptr;
553     void *data = nullptr;
554     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
555 
556     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
557     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
558     OHOS::AppExecFwk::ElementName elementName;
559     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
560         "parameter admin parse error");
561     EDMLOGD("IsWifiActiveSync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
562         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
563 
564     auto wifiManagerProxy = WifiManagerProxy::GetWifiManagerProxy();
565     if (wifiManagerProxy == nullptr) {
566         EDMLOGE("can not get WifiManagerProxy");
567         return nullptr;
568     }
569     bool isActive = false;
570     int32_t ret = wifiManagerProxy->IsWifiActive(elementName, isActive, true);
571     if (FAILED(ret)) {
572         napi_throw(env, CreateError(env, ret));
573         return nullptr;
574     }
575     napi_value result = nullptr;
576     napi_get_boolean(env, isActive, &result);
577     return result;
578 }
579 
SetWifiProfileSync(napi_env env,napi_callback_info info)580 napi_value WifiManagerAddon::SetWifiProfileSync(napi_env env, napi_callback_info info)
581 {
582 #ifdef WIFI_EDM_ENABLE
583     EDMLOGI("WifiManagerAddon::SetWifiProfileSync called");
584     size_t argc = ARGS_SIZE_TWO;
585     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
586     napi_value thisArg = nullptr;
587     void *data = nullptr;
588     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
589 
590     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
591     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
592     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object), "parameter profile error");
593     OHOS::AppExecFwk::ElementName elementName;
594     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
595         "parameter admin parse error");
596     EDMLOGD("SetWifiProfileSync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
597         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
598     Wifi::WifiDeviceConfig config;
599     WifiPassword pwd;
600     bool parseRet = JsObjToDeviceConfig(env, argv[ARR_INDEX_ONE], config, pwd);
601     if (!parseRet) {
602         napi_throw(env, CreateError(env, EdmReturnErrCode::PARAM_ERROR, "parameter profile parse error"));
603         return nullptr;
604     }
605 
606     auto wifiManagerProxy = WifiManagerProxy::GetWifiManagerProxy();
607     if (wifiManagerProxy == nullptr) {
608         EDMLOGE("can not get WifiManagerProxy");
609         return nullptr;
610     }
611     int32_t ret = wifiManagerProxy->SetWifiProfile(elementName, config, pwd, true);
612     if (FAILED(ret)) {
613         napi_throw(env, CreateError(env, ret));
614     }
615     return nullptr;
616 #else
617     EDMLOGW("WifiManagerAddon::SetWifiProfileSync Unsupported Capabilities.");
618     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
619     return nullptr;
620 #endif
621 }
622 
623 static napi_module g_wifiManagerModule = {
624     .nm_version = 1,
625     .nm_flags = 0,
626     .nm_filename = nullptr,
627     .nm_register_func = WifiManagerAddon::Init,
628     .nm_modname = "enterprise.wifiManager",
629     .nm_priv = ((void *)0),
630     .reserved = { 0 },
631 };
632 
WifiManagerRegister()633 extern "C" __attribute__((constructor)) void WifiManagerRegister()
634 {
635     napi_module_register(&g_wifiManagerModule);
636 }