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 
16 #include "restrictions_addon.h"
17 
18 #include <algorithm>
19 #include <vector>
20 
21 #include "edm_constants.h"
22 #include "edm_ipc_interface_code.h"
23 #include "edm_log.h"
24 
25 using namespace OHOS::EDM;
26 
27 std::unordered_map<std::string, uint32_t> RestrictionsAddon::labelCodeMap = {
28     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_BLUETOOTH, EdmInterfaceCode::DISABLE_BLUETOOTH},
29     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_MODIFY_DATETIME, EdmInterfaceCode::DISALLOW_MODIFY_DATETIME},
30     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_PRINTER, EdmInterfaceCode::DISABLED_PRINTER},
31     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_HDC, EdmInterfaceCode::DISABLED_HDC},
32     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_MIC, EdmInterfaceCode::DISABLE_MICROPHONE},
33     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_FINGER_PRINT, EdmInterfaceCode::FINGERPRINT_AUTH},
34     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_USB, EdmInterfaceCode::DISABLE_USB},
35     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_WIFI, EdmInterfaceCode::DISABLE_WIFI},
36     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_SCREENSHOT, EdmInterfaceCode::POLICY_CODE_END + 11},
37     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_SCREEN_RECORD, EdmInterfaceCode::POLICY_CODE_END + 12},
38     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_DISK_RECOVERY_KEY, EdmInterfaceCode::POLICY_CODE_END + 17},
39     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_NEAR_LINK, EdmInterfaceCode::POLICY_CODE_END + 18},
40     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_TETHERING, EdmInterfaceCode::DISALLOWED_TETHERING},
41     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_INACTIVE_USER_FREEZE, EdmInterfaceCode::INACTIVE_USER_FREEZE},
42     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_CAMERA, EdmInterfaceCode::DISABLE_CAMERA},
43 };
44 
45 std::vector<uint32_t> RestrictionsAddon::multiPermCodes = {
46     EdmInterfaceCode::DISABLE_BLUETOOTH,
47     EdmInterfaceCode::DISALLOW_MODIFY_DATETIME,
48     EdmInterfaceCode::DISABLED_PRINTER,
49     EdmInterfaceCode::DISABLED_HDC,
50     EdmInterfaceCode::DISABLE_USB,
51     EdmInterfaceCode::DISABLE_WIFI,
52 };
53 
54 std::unordered_map<std::string, uint32_t> RestrictionsAddon::labelCodeMapForAccount = {
55     {EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_FINGER_PRINT, EdmInterfaceCode::FINGERPRINT_AUTH},
56 };
57 
Init(napi_env env, napi_value exports)58 napi_value RestrictionsAddon::Init(napi_env env, napi_value exports)
59 {
60     napi_property_descriptor property[] = {
61         DECLARE_NAPI_FUNCTION("setPrinterDisabled", SetPrinterDisabled),
62         DECLARE_NAPI_FUNCTION("isPrinterDisabled", IsPrinterDisabled),
63         DECLARE_NAPI_FUNCTION("setHdcDisabled", SetHdcDisabled),
64         DECLARE_NAPI_FUNCTION("isHdcDisabled", IsHdcDisabled),
65         DECLARE_NAPI_FUNCTION("disableMicrophone", DisableMicrophone),
66         DECLARE_NAPI_FUNCTION("isMicrophoneDisabled", IsMicrophoneDisabled),
67         DECLARE_NAPI_FUNCTION("setFingerprintAuthDisabled", SetFingerprintAuthDisabled),
68         DECLARE_NAPI_FUNCTION("isFingerprintAuthDisabled", IsFingerprintAuthDisabled),
69         DECLARE_NAPI_FUNCTION("setDisallowedPolicy", SetDisallowedPolicy),
70         DECLARE_NAPI_FUNCTION("getDisallowedPolicy", GetDisallowedPolicy),
71         DECLARE_NAPI_FUNCTION("setDisallowedPolicyForAccount", SetDisallowedPolicyForAccount),
72         DECLARE_NAPI_FUNCTION("getDisallowedPolicyForAccount", GetDisallowedPolicyForAccount),
73         DECLARE_NAPI_FUNCTION("addDisallowedListForAccount", AddDisallowedListForAccount),
74         DECLARE_NAPI_FUNCTION("removeDisallowedListForAccount", RemoveDisallowedListForAccount),
75         DECLARE_NAPI_FUNCTION("getDisallowedListForAccount", GetDisallowedListForAccount),
76     };
77     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
78     return exports;
79 }
80 
SetPrinterDisabled(napi_env env, napi_callback_info info)81 napi_value RestrictionsAddon::SetPrinterDisabled(napi_env env, napi_callback_info info)
82 {
83     return SetPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_PRINTER);
84 }
85 
SetHdcDisabled(napi_env env, napi_callback_info info)86 napi_value RestrictionsAddon::SetHdcDisabled(napi_env env, napi_callback_info info)
87 {
88     return SetPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_HDC);
89 }
90 
SetPolicyDisabled(napi_env env, napi_callback_info info, int policyCode)91 napi_value RestrictionsAddon::SetPolicyDisabled(napi_env env, napi_callback_info info, int policyCode)
92 {
93     EDMLOGI("NAPI_SetPolicyDisabled called");
94     size_t argc = ARGS_SIZE_THREE;
95     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
96     napi_value thisArg = nullptr;
97     void *data = nullptr;
98     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
99     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
100     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
101     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
102     bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean);
103     ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be bool.");
104     if (argc > ARGS_SIZE_TWO) {
105         bool hasCallback = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
106         ASSERT_AND_THROW_PARAM_ERROR(env, hasCallback, "The third parameter must be function");
107     }
108     auto asyncCallbackInfo = new (std::nothrow) AsyncRestrictionsCallbackInfo();
109     if (asyncCallbackInfo == nullptr) {
110         return nullptr;
111     }
112     std::unique_ptr<AsyncRestrictionsCallbackInfo> callbackPtr{asyncCallbackInfo};
113     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
114     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
115     EDMLOGD(
116         "SetPolicyDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
117         "asyncCallbackInfo->abilityname:%{public}s",
118         asyncCallbackInfo->elementName.GetBundleName().c_str(),
119         asyncCallbackInfo->elementName.GetAbilityName().c_str());
120     ret = ParseBool(env, asyncCallbackInfo->isDisabled, argv[ARR_INDEX_ONE]);
121     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "isDisabled param error");
122     if (argc > ARGS_SIZE_TWO) {
123         EDMLOGD("NAPI_SetPolicyDisabled argc == ARGS_SIZE_THREE");
124         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
125     }
126     asyncCallbackInfo->policyCode = policyCode;
127     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetPolicyDisabled", NativeSetPolicyDisabled,
128         NativeVoidCallbackComplete);
129     callbackPtr.release();
130     return asyncWorkReturn;
131 }
132 
NativeSetPolicyDisabled(napi_env env, void *data)133 void RestrictionsAddon::NativeSetPolicyDisabled(napi_env env, void *data)
134 {
135     EDMLOGI("NativeSetPolicyDisabled called");
136     if (data == nullptr) {
137         EDMLOGE("data is nullptr");
138         return;
139     }
140     AsyncRestrictionsCallbackInfo *asyncCallbackInfo = static_cast<AsyncRestrictionsCallbackInfo *>(data);
141     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
142         asyncCallbackInfo->policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG :
143         EdmConstants::PERMISSION_TAG_VERSION_11;
144     asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->SetDisallowedPolicy(
145         asyncCallbackInfo->elementName, asyncCallbackInfo->isDisabled, asyncCallbackInfo->policyCode, permissionTag);
146 }
147 
IsPrinterDisabled(napi_env env, napi_callback_info info)148 napi_value RestrictionsAddon::IsPrinterDisabled(napi_env env, napi_callback_info info)
149 {
150     return IsPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_PRINTER);
151 }
152 
IsHdcDisabled(napi_env env, napi_callback_info info)153 napi_value RestrictionsAddon::IsHdcDisabled(napi_env env, napi_callback_info info)
154 {
155     return IsPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_HDC);
156 }
157 
IsPolicyDisabled(napi_env env, napi_callback_info info, int policyCode)158 napi_value RestrictionsAddon::IsPolicyDisabled(napi_env env, napi_callback_info info, int policyCode)
159 {
160     EDMLOGI("NAPI_IsPolicyDisabled called");
161     size_t argc = ARGS_SIZE_TWO;
162     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
163     napi_value thisArg = nullptr;
164     void *data = nullptr;
165     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
166     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
167     auto asyncCallbackInfo = new (std::nothrow) AsyncRestrictionsCallbackInfo();
168     if (asyncCallbackInfo == nullptr) {
169         return nullptr;
170     }
171     std::unique_ptr<AsyncRestrictionsCallbackInfo> callbackPtr{asyncCallbackInfo};
172     bool matchFlag = false;
173     if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_null)) {
174         asyncCallbackInfo->hasAdmin = false;
175         matchFlag = true;
176     } else if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object)) {
177         matchFlag = true;
178         asyncCallbackInfo->hasAdmin = true;
179         bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
180         ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
181         EDMLOGD(
182             "IsPolicyDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
183             "asyncCallbackInfo->abilityname:%{public}s",
184             asyncCallbackInfo->elementName.GetBundleName().c_str(),
185             asyncCallbackInfo->elementName.GetAbilityName().c_str());
186     }
187     if (argc > ARGS_SIZE_ONE) {
188         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
189     }
190     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
191     if (argc > ARGS_SIZE_ONE) {
192         EDMLOGD("NAPI_IsPolicyDisabled argc == ARGS_SIZE_TWO");
193         napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
194     }
195     asyncCallbackInfo->policyCode = policyCode;
196     napi_value asyncWorkReturn =
197         HandleAsyncWork(env, asyncCallbackInfo, "IsPolicyDisabled", NativeIsPolicyDisabled, NativeBoolCallbackComplete);
198     callbackPtr.release();
199     return asyncWorkReturn;
200 }
201 
NativeIsPolicyDisabled(napi_env env, void *data)202 void RestrictionsAddon::NativeIsPolicyDisabled(napi_env env, void *data)
203 {
204     EDMLOGI("NativeIsPolicyDisabled called");
205     if (data == nullptr) {
206         EDMLOGE("data is nullptr");
207         return;
208     }
209     AsyncRestrictionsCallbackInfo *asyncCallbackInfo = static_cast<AsyncRestrictionsCallbackInfo *>(data);
210     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
211         asyncCallbackInfo->policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG :
212         EdmConstants::PERMISSION_TAG_VERSION_11;
213     if (asyncCallbackInfo->hasAdmin) {
214         asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(
215             &(asyncCallbackInfo->elementName), asyncCallbackInfo->policyCode, asyncCallbackInfo->boolRet,
216             permissionTag);
217     } else {
218         asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(
219             nullptr, asyncCallbackInfo->policyCode, asyncCallbackInfo->boolRet, permissionTag);
220     }
221 }
222 
DisableMicrophone(napi_env env, napi_callback_info info)223 napi_value RestrictionsAddon::DisableMicrophone(napi_env env, napi_callback_info info)
224 {
225     return SetPolicyDisabledSync(env, info, EdmInterfaceCode::DISABLE_MICROPHONE);
226 }
227 
IsMicrophoneDisabled(napi_env env, napi_callback_info info)228 napi_value RestrictionsAddon::IsMicrophoneDisabled(napi_env env, napi_callback_info info)
229 {
230     return IsPolicyDisabledSync(env, info, EdmInterfaceCode::DISABLE_MICROPHONE);
231 }
232 
SetFingerprintAuthDisabled(napi_env env, napi_callback_info info)233 napi_value RestrictionsAddon::SetFingerprintAuthDisabled(napi_env env, napi_callback_info info)
234 {
235     EDMLOGI("SetFingerprintAuthDisabled 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_TWO, "parameter count error");
242     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
243     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean),
244         "parameter disallow error");
245     OHOS::AppExecFwk::ElementName elementName;
246     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
247         "element name param error");
248     EDMLOGD("SetFingerprintAuthDisabled: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
249         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
250     bool disallow = false;
251     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_ONE]), "parameter disallow parse error");
252 
253     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
254     if (proxy == nullptr) {
255         EDMLOGE("can not get RestrictionsProxy");
256         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
257         return nullptr;
258     }
259     ErrCode ret = proxy->SetFingerprintAuthDisabled(elementName, disallow);
260     if (FAILED(ret)) {
261         napi_throw(env, CreateError(env, ret));
262     }
263     return nullptr;
264 }
265 
IsFingerprintAuthDisabled(napi_env env, napi_callback_info info)266 napi_value RestrictionsAddon::IsFingerprintAuthDisabled(napi_env env, napi_callback_info info)
267 {
268     EDMLOGI("NAPI_IsFingerprintAuthDisabled called");
269     size_t argc = ARGS_SIZE_ONE;
270     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
271     napi_value thisArg = nullptr;
272     void *data = nullptr;
273     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
274     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
275     bool hasAdmin = false;
276     OHOS::AppExecFwk::ElementName elementName;
277     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
278         "param admin need be null or want");
279     EDMLOGD("IsFingerprintAuthDisabled: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
280         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
281 
282     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
283     if (proxy == nullptr) {
284         EDMLOGE("can not get RestrictionsProxy");
285         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
286         return nullptr;
287     }
288     bool disallow = false;
289     ErrCode ret;
290     if (hasAdmin) {
291         ret = proxy->IsFingerprintAuthDisabled(&elementName, disallow);
292     } else {
293         ret = proxy->IsFingerprintAuthDisabled(nullptr, disallow);
294     }
295     if (FAILED(ret)) {
296         napi_throw(env, CreateError(env, ret));
297         return nullptr;
298     }
299     napi_value result = nullptr;
300     napi_get_boolean(env, disallow, &result);
301     return result;
302 }
303 
SetPolicyDisabledSync(napi_env env, napi_callback_info info, int policyCode)304 napi_value RestrictionsAddon::SetPolicyDisabledSync(napi_env env, napi_callback_info info, int policyCode)
305 {
306     EDMLOGI("NAPI_SetPolicyDisabledSync called");
307     size_t argc = ARGS_SIZE_TWO;
308     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
309     napi_value thisArg = nullptr;
310     void *data = nullptr;
311     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
312     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
313     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
314     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean), "parameter bool error");
315     OHOS::AppExecFwk::ElementName elementName;
316     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
317         "element name param error");
318     bool isDisallow = false;
319     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, isDisallow, argv[ARR_INDEX_ONE]), "bool name param error");
320 
321     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
322         policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_11;
323     ErrCode ret = RestrictionsProxy::GetRestrictionsProxy()->SetDisallowedPolicy(elementName, isDisallow, policyCode,
324         permissionTag);
325     if (FAILED(ret)) {
326         napi_throw(env, CreateError(env, ret));
327     }
328     return nullptr;
329 }
330 
IsPolicyDisabledSync(napi_env env, napi_callback_info info, int policyCode)331 napi_value RestrictionsAddon::IsPolicyDisabledSync(napi_env env, napi_callback_info info, int policyCode)
332 {
333     EDMLOGI("NAPI_IsPolicyDisabled called");
334     size_t argc = ARGS_SIZE_ONE;
335     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
336     napi_value thisArg = nullptr;
337     void *data = nullptr;
338     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
339     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
340     bool hasAdmin = false;
341     OHOS::AppExecFwk::ElementName elementName;
342     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
343         "param admin need be null or want");
344     ErrCode ret = ERR_OK;
345     bool boolRet = false;
346     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
347         policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_11;
348     if (hasAdmin) {
349         ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(&elementName, policyCode, boolRet,
350             permissionTag);
351     } else {
352         ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(nullptr, policyCode, boolRet,
353             permissionTag);
354     }
355     if (FAILED(ret)) {
356         napi_throw(env, CreateError(env, ret));
357         EDMLOGE("SetPolicyDisabledSync failed!");
358         return nullptr;
359     }
360     napi_value result = nullptr;
361     napi_get_boolean(env, boolRet, &result);
362     return result;
363 }
364 
SetDisallowedPolicy(napi_env env, napi_callback_info info)365 napi_value RestrictionsAddon::SetDisallowedPolicy(napi_env env, napi_callback_info info)
366 {
367     EDMLOGI("NAPI_SetDisallowedPolicy called");
368     size_t argc = ARGS_SIZE_THREE;
369     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
370     napi_value thisArg = nullptr;
371     void *data = nullptr;
372     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
373     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
374     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
375     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
376     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean),
377         "parameter disallow error");
378     OHOS::AppExecFwk::ElementName elementName;
379     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
380         "element name param error");
381     EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
382         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
383     std::string feature;
384     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
385     bool disallow = false;
386     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_TWO]), "parameter disallow parse error");
387 
388     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
389     if (proxy == nullptr) {
390         EDMLOGE("can not get RestrictionsProxy");
391         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
392         return nullptr;
393     }
394     ErrCode ret = ERR_OK;
395     if (feature == EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_FINGER_PRINT) {
396         ret = proxy->SetFingerprintAuthDisabled(elementName, disallow);
397     } else {
398         auto labelCode = labelCodeMap.find(feature);
399         if (labelCode == labelCodeMap.end()) {
400             napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
401             return nullptr;
402         }
403         std::uint32_t ipcCode = labelCode->second;
404         std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
405             ipcCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_12;
406         ret = proxy->SetDisallowedPolicy(elementName, disallow, ipcCode, permissionTag);
407     }
408     if (FAILED(ret)) {
409         napi_throw(env, CreateError(env, ret));
410     }
411     return nullptr;
412 }
413 
GetDisallowedPolicy(napi_env env, napi_callback_info info)414 napi_value RestrictionsAddon::GetDisallowedPolicy(napi_env env, napi_callback_info info)
415 {
416     EDMLOGI("NAPI_GetDisallowedPolicy called");
417     size_t argc = ARGS_SIZE_TWO;
418     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
419     napi_value thisArg = nullptr;
420     void *data = nullptr;
421     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
422     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
423     bool hasAdmin = false;
424     OHOS::AppExecFwk::ElementName elementName;
425     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
426         "param admin need be null or want");
427     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
428     std::string feature;
429     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
430     if (hasAdmin) {
431         EDMLOGD("GetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
432             elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
433     } else {
434         EDMLOGD("GetDisallowedPolicy: elementName is null");
435     }
436 
437     bool disallow = false;
438     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
439     if (proxy == nullptr) {
440         EDMLOGE("can not get RestrictionsProxy");
441         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
442         return nullptr;
443     }
444     ErrCode ret = ERR_OK;
445     if (feature == EdmConstants::Restrictions::LABEL_DISALLOWED_POLICY_FINGER_PRINT) {
446         ret = proxy->IsFingerprintAuthDisabled(hasAdmin ? &elementName : nullptr, disallow);
447     } else {
448         auto labelCode = labelCodeMap.find(feature);
449         if (labelCode == labelCodeMap.end()) {
450             napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
451             return nullptr;
452         }
453         std::uint32_t ipcCode = labelCode->second;
454         std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
455             ipcCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_12;
456         ret = proxy->GetDisallowedPolicy(hasAdmin ? &elementName : nullptr, ipcCode, disallow, permissionTag);
457     }
458 
459     if (FAILED(ret)) {
460         napi_throw(env, CreateError(env, ret));
461         return nullptr;
462     }
463     napi_value result = nullptr;
464     napi_get_boolean(env, disallow, &result);
465     return result;
466 }
467 
SetDisallowedPolicyForAccount(napi_env env, napi_callback_info info)468 napi_value RestrictionsAddon::SetDisallowedPolicyForAccount(napi_env env, napi_callback_info info)
469 {
470     EDMLOGI("NAPI_SetDisallowedPolicyForAccount called");
471     size_t argc = ARGS_SIZE_FOUR;
472     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
473     napi_value thisArg = nullptr;
474     void *data = nullptr;
475     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
476     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_FOUR, "parameter count error");
477     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
478     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
479     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean),
480         "parameter disallow error");
481     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_THREE], napi_number),
482         "parameter accountId error");
483     OHOS::AppExecFwk::ElementName elementName;
484     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
485         "element name param error");
486     EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
487         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
488     std::string feature;
489     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
490     bool disallow = false;
491     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_TWO]), "parameter disallow parse error");
492     int32_t accountId = -1;
493     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_THREE]),
494         "parameter accountId parse error");
495 
496     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
497     if (proxy == nullptr) {
498         EDMLOGE("can not get RestrictionsProxy");
499         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
500         return nullptr;
501     }
502     auto labelCode = labelCodeMapForAccount.find(feature);
503     if (labelCode == labelCodeMapForAccount.end()) {
504         napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
505         return nullptr;
506     }
507     std::uint32_t ipcCode = labelCode->second;
508     std::string permissionTag = WITHOUT_PERMISSION_TAG;
509     ErrCode ret = proxy->SetDisallowedPolicyForAccount(elementName, disallow, ipcCode, permissionTag, accountId);
510     if (FAILED(ret)) {
511         napi_throw(env, CreateError(env, ret));
512     }
513     return nullptr;
514 }
515 
GetDisallowedPolicyForAccount(napi_env env, napi_callback_info info)516 napi_value RestrictionsAddon::GetDisallowedPolicyForAccount(napi_env env, napi_callback_info info)
517 {
518     EDMLOGI("NAPI_GetDisallowedPolicyForAccount called");
519     size_t argc = ARGS_SIZE_THREE;
520     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
521     napi_value thisArg = nullptr;
522     void *data = nullptr;
523     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
524     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
525     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
526     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
527     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
528         "parameter accountId error");
529     OHOS::AppExecFwk::ElementName elementName;
530     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
531         "element name param error");
532     EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
533         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
534     std::string feature;
535     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
536     int32_t accountId = -1;
537     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]), "parameter accountId parse error");
538 
539     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
540     if (proxy == nullptr) {
541         EDMLOGE("can not get RestrictionsProxy");
542         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
543         return nullptr;
544     }
545     auto labelCode = labelCodeMapForAccount.find(feature);
546     if (labelCode == labelCodeMapForAccount.end()) {
547         napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
548         return nullptr;
549     }
550     std::uint32_t ipcCode = labelCode->second;
551     std::string permissionTag = WITHOUT_PERMISSION_TAG;
552     bool disallow = false;
553     ErrCode ret = proxy->GetDisallowedPolicyForAccount(elementName, ipcCode, disallow, permissionTag, accountId);
554     if (FAILED(ret)) {
555         napi_throw(env, CreateError(env, ret));
556         return nullptr;
557     }
558     napi_value result = nullptr;
559     napi_get_boolean(env, disallow, &result);
560     return result;
561 }
562 
AddDisallowedListForAccount(napi_env env, napi_callback_info info)563 napi_value RestrictionsAddon::AddDisallowedListForAccount(napi_env env, napi_callback_info info)
564 {
565     return AddOrRemoveDisallowedListForAccount(env, info, true);
566 }
567 
RemoveDisallowedListForAccount(napi_env env, napi_callback_info info)568 napi_value RestrictionsAddon::RemoveDisallowedListForAccount(napi_env env, napi_callback_info info)
569 {
570     return AddOrRemoveDisallowedListForAccount(env, info, false);
571 }
572 
GetDisallowedListForAccount(napi_env env, napi_callback_info info)573 napi_value RestrictionsAddon::GetDisallowedListForAccount(napi_env env, napi_callback_info info)
574 {
575     EDMLOGI("NAPI_GetDisallowedListForAccount called");
576     size_t argc = ARGS_SIZE_THREE;
577     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
578     napi_value thisArg = nullptr;
579     void *data = nullptr;
580     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
581     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
582     OHOS::AppExecFwk::ElementName elementName;
583     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
584         "param admin need be want");
585     std::string feature;
586     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
587 
588     int32_t accountId = -1;
589     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]), "parameter accountId parse error");
590 
591     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
592     if (proxy == nullptr) {
593         EDMLOGE("can not get RestrictionsProxy");
594         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
595         return nullptr;
596     }
597     std::vector<std::string> resultArray;
598     ErrCode ret = proxy->GetDisallowedListForAccount(elementName, feature, accountId, resultArray);
599     if (FAILED(ret)) {
600         napi_throw(env, CreateError(env, ret));
601         return nullptr;
602     }
603     napi_value result = nullptr;
604     napi_create_array(env, &result);
605     ConvertStringVectorToJS(env, resultArray, result);
606     return result;
607 }
608 
AddOrRemoveDisallowedListForAccount(napi_env env, napi_callback_info info, bool isAdd)609 napi_value RestrictionsAddon::AddOrRemoveDisallowedListForAccount(napi_env env, napi_callback_info info,
610     bool isAdd)
611 {
612     EDMLOGI("NAPI_AddOrRemoveDisallowedListForAccount called");
613     size_t argc = ARGS_SIZE_FOUR;
614     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
615     napi_value thisArg = nullptr;
616     void *data = nullptr;
617     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
618     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_FOUR, "parameter count error");
619     OHOS::AppExecFwk::ElementName elementName;
620     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
621         "element name param error");
622     EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
623         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
624     std::string feature;
625     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
626     std::vector<std::string> bundleNameArray;
627     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, bundleNameArray, argv[ARR_INDEX_TWO]),
628         "parameter bundle name error");
629     int32_t accountId = 0;
630     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_THREE]),
631         "parameter accountId parse error");
632 
633     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
634     if (proxy == nullptr) {
635         EDMLOGE("can not get RestrictionsProxy");
636         napi_throw(env, CreateError(env, EdmReturnErrCode::SYSTEM_ABNORMALLY));
637         return nullptr;
638     }
639     ErrCode ret = proxy->AddOrRemoveDisallowedListForAccount(elementName, feature, bundleNameArray, accountId, isAdd);
640     if (FAILED(ret)) {
641         napi_throw(env, CreateError(env, ret));
642     }
643     return nullptr;
644 }
645 
646 static napi_module g_restrictionsModule = {
647     .nm_version = 1,
648     .nm_flags = 0,
649     .nm_filename = nullptr,
650     .nm_register_func = RestrictionsAddon::Init,
651     .nm_modname = "enterprise.restrictions",
652     .nm_priv = ((void *)0),
653     .reserved = {0},
654 };
655 
RestrictionsRegister()656 extern "C" __attribute__((constructor)) void RestrictionsRegister()
657 {
658     napi_module_register(&g_restrictionsModule);
659 }
660