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_CAMERA, EdmInterfaceCode::DISABLE_CAMERA},
41 };
42 
43 std::vector<uint32_t> RestrictionsAddon::multiPermCodes = {
44     EdmInterfaceCode::DISABLE_BLUETOOTH,
45     EdmInterfaceCode::DISALLOW_MODIFY_DATETIME,
46     EdmInterfaceCode::DISABLED_PRINTER,
47     EdmInterfaceCode::DISABLED_HDC,
48     EdmInterfaceCode::DISABLE_USB,
49     EdmInterfaceCode::DISABLE_WIFI,
50 };
51 
Init(napi_env env,napi_value exports)52 napi_value RestrictionsAddon::Init(napi_env env, napi_value exports)
53 {
54     napi_property_descriptor property[] = {
55         DECLARE_NAPI_FUNCTION("setPrinterDisabled", SetPrinterDisabled),
56         DECLARE_NAPI_FUNCTION("isPrinterDisabled", IsPrinterDisabled),
57         DECLARE_NAPI_FUNCTION("setHdcDisabled", SetHdcDisabled),
58         DECLARE_NAPI_FUNCTION("isHdcDisabled", IsHdcDisabled),
59         DECLARE_NAPI_FUNCTION("disableMicrophone", DisableMicrophone),
60         DECLARE_NAPI_FUNCTION("isMicrophoneDisabled", IsMicrophoneDisabled),
61         DECLARE_NAPI_FUNCTION("setFingerprintAuthDisabled", SetFingerprintAuthDisabled),
62         DECLARE_NAPI_FUNCTION("isFingerprintAuthDisabled", IsFingerprintAuthDisabled),
63         DECLARE_NAPI_FUNCTION("setDisallowedPolicy", SetDisallowedPolicy),
64         DECLARE_NAPI_FUNCTION("getDisallowedPolicy", GetDisallowedPolicy),
65         DECLARE_NAPI_FUNCTION("setDisallowedPolicyForAccount", SetDisallowedPolicyForAccount),
66         DECLARE_NAPI_FUNCTION("getDisallowedPolicyForAccount", GetDisallowedPolicyForAccount),
67         DECLARE_NAPI_FUNCTION("addDisallowedListForAccount", AddDisallowedListForAccount),
68         DECLARE_NAPI_FUNCTION("removeDisallowedListForAccount", RemoveDisallowedListForAccount),
69         DECLARE_NAPI_FUNCTION("getDisallowedListForAccount", GetDisallowedListForAccount),
70     };
71     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
72     return exports;
73 }
74 
SetPrinterDisabled(napi_env env,napi_callback_info info)75 napi_value RestrictionsAddon::SetPrinterDisabled(napi_env env, napi_callback_info info)
76 {
77     return SetPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_PRINTER);
78 }
79 
SetHdcDisabled(napi_env env,napi_callback_info info)80 napi_value RestrictionsAddon::SetHdcDisabled(napi_env env, napi_callback_info info)
81 {
82     return SetPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_HDC);
83 }
84 
SetPolicyDisabled(napi_env env,napi_callback_info info,int policyCode)85 napi_value RestrictionsAddon::SetPolicyDisabled(napi_env env, napi_callback_info info, int policyCode)
86 {
87     EDMLOGI("NAPI_SetPolicyDisabled called");
88     size_t argc = ARGS_SIZE_THREE;
89     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
90     napi_value thisArg = nullptr;
91     void *data = nullptr;
92     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
93     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
94     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
95     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
96     bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean);
97     ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be bool.");
98     if (argc > ARGS_SIZE_TWO) {
99         bool hasCallback = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
100         ASSERT_AND_THROW_PARAM_ERROR(env, hasCallback, "The third parameter must be function");
101     }
102     auto asyncCallbackInfo = new (std::nothrow) AsyncRestrictionsCallbackInfo();
103     if (asyncCallbackInfo == nullptr) {
104         return nullptr;
105     }
106     std::unique_ptr<AsyncRestrictionsCallbackInfo> callbackPtr{asyncCallbackInfo};
107     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
108     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
109     EDMLOGD(
110         "SetPolicyDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
111         "asyncCallbackInfo->abilityname:%{public}s",
112         asyncCallbackInfo->elementName.GetBundleName().c_str(),
113         asyncCallbackInfo->elementName.GetAbilityName().c_str());
114     ret = ParseBool(env, asyncCallbackInfo->isDisabled, argv[ARR_INDEX_ONE]);
115     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "isDisabled param error");
116     if (argc > ARGS_SIZE_TWO) {
117         EDMLOGD("NAPI_SetPolicyDisabled argc == ARGS_SIZE_THREE");
118         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
119     }
120     asyncCallbackInfo->policyCode = policyCode;
121     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetPolicyDisabled", NativeSetPolicyDisabled,
122         NativeVoidCallbackComplete);
123     callbackPtr.release();
124     return asyncWorkReturn;
125 }
126 
NativeSetPolicyDisabled(napi_env env,void * data)127 void RestrictionsAddon::NativeSetPolicyDisabled(napi_env env, void *data)
128 {
129     EDMLOGI("NativeSetPolicyDisabled called");
130     if (data == nullptr) {
131         EDMLOGE("data is nullptr");
132         return;
133     }
134     AsyncRestrictionsCallbackInfo *asyncCallbackInfo = static_cast<AsyncRestrictionsCallbackInfo *>(data);
135     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
136         asyncCallbackInfo->policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG :
137         EdmConstants::PERMISSION_TAG_VERSION_11;
138     asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->SetDisallowedPolicy(
139         asyncCallbackInfo->elementName, asyncCallbackInfo->isDisabled, asyncCallbackInfo->policyCode, permissionTag);
140 }
141 
IsPrinterDisabled(napi_env env,napi_callback_info info)142 napi_value RestrictionsAddon::IsPrinterDisabled(napi_env env, napi_callback_info info)
143 {
144     return IsPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_PRINTER);
145 }
146 
IsHdcDisabled(napi_env env,napi_callback_info info)147 napi_value RestrictionsAddon::IsHdcDisabled(napi_env env, napi_callback_info info)
148 {
149     return IsPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_HDC);
150 }
151 
IsPolicyDisabled(napi_env env,napi_callback_info info,int policyCode)152 napi_value RestrictionsAddon::IsPolicyDisabled(napi_env env, napi_callback_info info, int policyCode)
153 {
154     EDMLOGI("NAPI_IsPolicyDisabled called");
155     size_t argc = ARGS_SIZE_TWO;
156     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
157     napi_value thisArg = nullptr;
158     void *data = nullptr;
159     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
160     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
161     auto asyncCallbackInfo = new (std::nothrow) AsyncRestrictionsCallbackInfo();
162     if (asyncCallbackInfo == nullptr) {
163         return nullptr;
164     }
165     std::unique_ptr<AsyncRestrictionsCallbackInfo> callbackPtr{asyncCallbackInfo};
166     bool matchFlag = false;
167     if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_null)) {
168         asyncCallbackInfo->hasAdmin = false;
169         matchFlag = true;
170     } else if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object)) {
171         matchFlag = true;
172         asyncCallbackInfo->hasAdmin = true;
173         bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
174         ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
175         EDMLOGD(
176             "IsPolicyDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
177             "asyncCallbackInfo->abilityname:%{public}s",
178             asyncCallbackInfo->elementName.GetBundleName().c_str(),
179             asyncCallbackInfo->elementName.GetAbilityName().c_str());
180     }
181     if (argc > ARGS_SIZE_ONE) {
182         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
183     }
184     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
185     if (argc > ARGS_SIZE_ONE) {
186         EDMLOGD("NAPI_IsPolicyDisabled argc == ARGS_SIZE_TWO");
187         napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
188     }
189     asyncCallbackInfo->policyCode = policyCode;
190     napi_value asyncWorkReturn =
191         HandleAsyncWork(env, asyncCallbackInfo, "IsPolicyDisabled", NativeIsPolicyDisabled, NativeBoolCallbackComplete);
192     callbackPtr.release();
193     return asyncWorkReturn;
194 }
195 
NativeIsPolicyDisabled(napi_env env,void * data)196 void RestrictionsAddon::NativeIsPolicyDisabled(napi_env env, void *data)
197 {
198     EDMLOGI("NativeIsPolicyDisabled called");
199     if (data == nullptr) {
200         EDMLOGE("data is nullptr");
201         return;
202     }
203     AsyncRestrictionsCallbackInfo *asyncCallbackInfo = static_cast<AsyncRestrictionsCallbackInfo *>(data);
204     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
205         asyncCallbackInfo->policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG :
206         EdmConstants::PERMISSION_TAG_VERSION_11;
207     if (asyncCallbackInfo->hasAdmin) {
208         asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(
209             &(asyncCallbackInfo->elementName), asyncCallbackInfo->policyCode, asyncCallbackInfo->boolRet,
210             permissionTag);
211     } else {
212         asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(
213             nullptr, asyncCallbackInfo->policyCode, asyncCallbackInfo->boolRet, permissionTag);
214     }
215 }
216 
DisableMicrophone(napi_env env,napi_callback_info info)217 napi_value RestrictionsAddon::DisableMicrophone(napi_env env, napi_callback_info info)
218 {
219     return SetPolicyDisabledSync(env, info, EdmInterfaceCode::DISABLE_MICROPHONE);
220 }
221 
IsMicrophoneDisabled(napi_env env,napi_callback_info info)222 napi_value RestrictionsAddon::IsMicrophoneDisabled(napi_env env, napi_callback_info info)
223 {
224     return IsPolicyDisabledSync(env, info, EdmInterfaceCode::DISABLE_MICROPHONE);
225 }
226 
SetFingerprintAuthDisabled(napi_env env,napi_callback_info info)227 napi_value RestrictionsAddon::SetFingerprintAuthDisabled(napi_env env, napi_callback_info info)
228 {
229     return SetPolicyDisabledSync(env, info, EdmInterfaceCode::FINGERPRINT_AUTH);
230 }
231 
IsFingerprintAuthDisabled(napi_env env,napi_callback_info info)232 napi_value RestrictionsAddon::IsFingerprintAuthDisabled(napi_env env, napi_callback_info info)
233 {
234     return IsPolicyDisabledSync(env, info, EdmInterfaceCode::FINGERPRINT_AUTH);
235 }
236 
SetPolicyDisabledSync(napi_env env,napi_callback_info info,int policyCode)237 napi_value RestrictionsAddon::SetPolicyDisabledSync(napi_env env, napi_callback_info info, int policyCode)
238 {
239     EDMLOGI("NAPI_SetPolicyDisabledSync called");
240     size_t argc = ARGS_SIZE_TWO;
241     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
242     napi_value thisArg = nullptr;
243     void *data = nullptr;
244     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
245     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
246     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
247     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean), "parameter bool error");
248     OHOS::AppExecFwk::ElementName elementName;
249     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
250         "element name param error");
251     bool isDisallow = false;
252     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, isDisallow, argv[ARR_INDEX_ONE]), "bool name param error");
253 
254     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
255         policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_11;
256     ErrCode ret = RestrictionsProxy::GetRestrictionsProxy()->SetDisallowedPolicy(elementName, isDisallow, policyCode,
257         permissionTag);
258     if (FAILED(ret)) {
259         napi_throw(env, CreateError(env, ret));
260     }
261     return nullptr;
262 }
263 
IsPolicyDisabledSync(napi_env env,napi_callback_info info,int policyCode)264 napi_value RestrictionsAddon::IsPolicyDisabledSync(napi_env env, napi_callback_info info, int policyCode)
265 {
266     EDMLOGI("NAPI_IsPolicyDisabled called");
267     size_t argc = ARGS_SIZE_ONE;
268     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
269     napi_value thisArg = nullptr;
270     void *data = nullptr;
271     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
272     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
273     bool hasAdmin = false;
274     OHOS::AppExecFwk::ElementName elementName;
275     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
276         "param admin need be null or want");
277     ErrCode ret = ERR_OK;
278     bool boolRet = false;
279     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
280         policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_11;
281     if (hasAdmin) {
282         ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(&elementName, policyCode, boolRet,
283             permissionTag);
284     } else {
285         ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(nullptr, policyCode, boolRet,
286             permissionTag);
287     }
288     if (FAILED(ret)) {
289         napi_throw(env, CreateError(env, ret));
290         EDMLOGE("SetPolicyDisabledSync failed!");
291         return nullptr;
292     }
293     napi_value result = nullptr;
294     napi_get_boolean(env, boolRet, &result);
295     return result;
296 }
297 
SetDisallowedPolicy(napi_env env,napi_callback_info info)298 napi_value RestrictionsAddon::SetDisallowedPolicy(napi_env env, napi_callback_info info)
299 {
300     EDMLOGI("NAPI_SetDisallowedPolicy called");
301     size_t argc = ARGS_SIZE_THREE;
302     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
303     napi_value thisArg = nullptr;
304     void *data = nullptr;
305     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
306     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
307     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
308     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
309     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean),
310         "parameter disallow error");
311     OHOS::AppExecFwk::ElementName elementName;
312     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
313         "element name param error");
314     EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
315         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
316     std::string feature;
317     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
318     bool disallow = false;
319     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_TWO]), "parameter disallow parse error");
320 
321     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
322     if (proxy == nullptr) {
323         EDMLOGE("can not get RestrictionsProxy");
324         return nullptr;
325     }
326     auto labelCode = labelCodeMap.find(feature);
327     if (labelCode == labelCodeMap.end()) {
328         napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
329         return nullptr;
330     }
331     std::uint32_t ipcCode = labelCode->second;
332     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
333         ipcCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_12;
334     ErrCode ret = proxy->SetDisallowedPolicy(elementName, disallow, ipcCode, permissionTag);
335     if (FAILED(ret)) {
336         napi_throw(env, CreateError(env, ret));
337     }
338     return nullptr;
339 }
340 
GetDisallowedPolicy(napi_env env,napi_callback_info info)341 napi_value RestrictionsAddon::GetDisallowedPolicy(napi_env env, napi_callback_info info)
342 {
343     EDMLOGI("NAPI_GetDisallowedPolicy called");
344     size_t argc = ARGS_SIZE_TWO;
345     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
346     napi_value thisArg = nullptr;
347     void *data = nullptr;
348     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
349     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
350     bool hasAdmin = false;
351     OHOS::AppExecFwk::ElementName elementName;
352     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
353         "param admin need be null or want");
354     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
355     std::string feature;
356     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
357     if (hasAdmin) {
358         EDMLOGD("GetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
359             elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
360     } else {
361         EDMLOGD("GetDisallowedPolicy: elementName is null");
362     }
363 
364     bool disallow = false;
365     auto proxy = RestrictionsProxy::GetRestrictionsProxy();
366     if (proxy == nullptr) {
367         EDMLOGE("can not get RestrictionsProxy");
368         return nullptr;
369     }
370     auto labelCode = labelCodeMap.find(feature);
371     if (labelCode == labelCodeMap.end()) {
372         napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
373         return nullptr;
374     }
375     std::uint32_t ipcCode = labelCode->second;
376     std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
377         ipcCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_12;
378     ErrCode ret = ERR_OK;
379     if (hasAdmin) {
380         ret = proxy->GetDisallowedPolicy(&elementName, ipcCode, disallow, permissionTag);
381     } else {
382         ret = proxy->GetDisallowedPolicy(nullptr, ipcCode, disallow, permissionTag);
383     }
384     if (FAILED(ret)) {
385         napi_throw(env, CreateError(env, ret));
386         return nullptr;
387     }
388     napi_value result = nullptr;
389     napi_get_boolean(env, disallow, &result);
390     return result;
391 }
392 
SetDisallowedPolicyForAccount(napi_env env,napi_callback_info info)393 napi_value RestrictionsAddon::SetDisallowedPolicyForAccount(napi_env env, napi_callback_info info)
394 {
395     EDMLOGI("NAPI_SetDisallowedPolicyForAccount called");
396     size_t argc = ARGS_SIZE_FOUR;
397     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
398     napi_value thisArg = nullptr;
399     void *data = nullptr;
400     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
401     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_FOUR, "parameter count error");
402     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
403     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
404     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean),
405         "parameter disallow error");
406     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_THREE], napi_number),
407         "parameter accountId error");
408     OHOS::AppExecFwk::ElementName elementName;
409     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
410         "element name param error");
411     EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
412         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
413     std::string feature;
414     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
415     bool disallow = false;
416     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_TWO]), "parameter disallow parse error");
417     int32_t accountId = -1;
418     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_THREE]),
419         "parameter accountId parse error");
420 
421     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
422     return nullptr;
423 }
424 
GetDisallowedPolicyForAccount(napi_env env,napi_callback_info info)425 napi_value RestrictionsAddon::GetDisallowedPolicyForAccount(napi_env env, napi_callback_info info)
426 {
427     EDMLOGI("NAPI_GetDisallowedPolicyForAccount called");
428     size_t argc = ARGS_SIZE_THREE;
429     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
430     napi_value thisArg = nullptr;
431     void *data = nullptr;
432     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
433     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
434     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
435     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
436     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
437         "parameter accountId error");
438     OHOS::AppExecFwk::ElementName elementName;
439     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
440         "element name param error");
441     EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
442         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
443     std::string feature;
444     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
445     int32_t accountId = -1;
446     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]), "parameter accountId parse error");
447 
448     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
449     napi_value result = nullptr;
450     return result;
451 }
452 
AddDisallowedListForAccount(napi_env env,napi_callback_info info)453 napi_value RestrictionsAddon::AddDisallowedListForAccount(napi_env env, napi_callback_info info)
454 {
455     return AddOrRemoveDisallowedListForAccount(env, info, true);
456 }
457 
RemoveDisallowedListForAccount(napi_env env,napi_callback_info info)458 napi_value RestrictionsAddon::RemoveDisallowedListForAccount(napi_env env, napi_callback_info info)
459 {
460     return AddOrRemoveDisallowedListForAccount(env, info, false);
461 }
462 
GetDisallowedListForAccount(napi_env env,napi_callback_info info)463 napi_value RestrictionsAddon::GetDisallowedListForAccount(napi_env env, napi_callback_info info)
464 {
465     EDMLOGI("NAPI_GetDisallowedListForAccount called");
466     size_t argc = ARGS_SIZE_THREE;
467     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
468     napi_value thisArg = nullptr;
469     void *data = nullptr;
470     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
471     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
472     OHOS::AppExecFwk::ElementName elementName;
473     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
474         "param admin need be want");
475     std::string feature;
476     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
477 
478     int32_t accountId = -1;
479     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]), "parameter accountId parse error");
480 
481     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
482     napi_value result = nullptr;
483     napi_create_array(env, &result);
484     return result;
485 }
486 
AddOrRemoveDisallowedListForAccount(napi_env env,napi_callback_info info,bool isAdd)487 napi_value RestrictionsAddon::AddOrRemoveDisallowedListForAccount(napi_env env, napi_callback_info info,
488     bool isAdd)
489 {
490     EDMLOGI("NAPI_AddOrRemoveDisallowedListForAccount called");
491     size_t argc = ARGS_SIZE_FOUR;
492     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
493     napi_value thisArg = nullptr;
494     void *data = nullptr;
495     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
496     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_FOUR, "parameter count error");
497     OHOS::AppExecFwk::ElementName elementName;
498     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
499         "element name param error");
500     EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
501         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
502     std::string feature;
503     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
504     std::vector<std::string> bundleNameArray;
505     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, bundleNameArray, argv[ARR_INDEX_TWO]),
506         "parameter bundle name error");
507     int32_t accountId = 0;
508     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_THREE]),
509         "parameter accountId parse error");
510 
511     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
512     return nullptr;
513 }
514 
515 
516 static napi_module g_restrictionsModule = {
517     .nm_version = 1,
518     .nm_flags = 0,
519     .nm_filename = nullptr,
520     .nm_register_func = RestrictionsAddon::Init,
521     .nm_modname = "enterprise.restrictions",
522     .nm_priv = ((void *)0),
523     .reserved = {0},
524 };
525 
RestrictionsRegister()526 extern "C" __attribute__((constructor)) void RestrictionsRegister()
527 {
528     napi_module_register(&g_restrictionsModule);
529 }
530