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 };
41
42 std::vector<uint32_t> RestrictionsAddon::multiPermCodes = {
43 EdmInterfaceCode::DISABLE_BLUETOOTH,
44 EdmInterfaceCode::DISALLOW_MODIFY_DATETIME,
45 EdmInterfaceCode::DISABLED_PRINTER,
46 EdmInterfaceCode::DISABLED_HDC,
47 EdmInterfaceCode::DISABLE_USB,
48 EdmInterfaceCode::DISABLE_WIFI,
49 };
50
Init(napi_env env,napi_value exports)51 napi_value RestrictionsAddon::Init(napi_env env, napi_value exports)
52 {
53 napi_property_descriptor property[] = {
54 DECLARE_NAPI_FUNCTION("setPrinterDisabled", SetPrinterDisabled),
55 DECLARE_NAPI_FUNCTION("isPrinterDisabled", IsPrinterDisabled),
56 DECLARE_NAPI_FUNCTION("setHdcDisabled", SetHdcDisabled),
57 DECLARE_NAPI_FUNCTION("isHdcDisabled", IsHdcDisabled),
58 DECLARE_NAPI_FUNCTION("disableMicrophone", DisableMicrophone),
59 DECLARE_NAPI_FUNCTION("isMicrophoneDisabled", IsMicrophoneDisabled),
60 DECLARE_NAPI_FUNCTION("setFingerprintAuthDisabled", SetFingerprintAuthDisabled),
61 DECLARE_NAPI_FUNCTION("isFingerprintAuthDisabled", IsFingerprintAuthDisabled),
62 DECLARE_NAPI_FUNCTION("setDisallowedPolicy", SetDisallowedPolicy),
63 DECLARE_NAPI_FUNCTION("getDisallowedPolicy", GetDisallowedPolicy),
64 };
65 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
66 return exports;
67 }
68
SetPrinterDisabled(napi_env env,napi_callback_info info)69 napi_value RestrictionsAddon::SetPrinterDisabled(napi_env env, napi_callback_info info)
70 {
71 return SetPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_PRINTER);
72 }
73
SetHdcDisabled(napi_env env,napi_callback_info info)74 napi_value RestrictionsAddon::SetHdcDisabled(napi_env env, napi_callback_info info)
75 {
76 return SetPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_HDC);
77 }
78
SetPolicyDisabled(napi_env env,napi_callback_info info,int policyCode)79 napi_value RestrictionsAddon::SetPolicyDisabled(napi_env env, napi_callback_info info, int policyCode)
80 {
81 EDMLOGI("NAPI_SetPolicyDisabled called");
82 size_t argc = ARGS_SIZE_THREE;
83 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
84 napi_value thisArg = nullptr;
85 void *data = nullptr;
86 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
87 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
88 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
89 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
90 bool hasPolicy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean);
91 ASSERT_AND_THROW_PARAM_ERROR(env, hasPolicy, "The second parameter must be bool.");
92 if (argc > ARGS_SIZE_TWO) {
93 bool hasCallback = MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
94 ASSERT_AND_THROW_PARAM_ERROR(env, hasCallback, "The third parameter must be function");
95 }
96 auto asyncCallbackInfo = new (std::nothrow) AsyncRestrictionsCallbackInfo();
97 if (asyncCallbackInfo == nullptr) {
98 return nullptr;
99 }
100 std::unique_ptr<AsyncRestrictionsCallbackInfo> callbackPtr{asyncCallbackInfo};
101 bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
102 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
103 EDMLOGD(
104 "SetPolicyDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
105 "asyncCallbackInfo->abilityname:%{public}s",
106 asyncCallbackInfo->elementName.GetBundleName().c_str(),
107 asyncCallbackInfo->elementName.GetAbilityName().c_str());
108 ret = ParseBool(env, asyncCallbackInfo->isDisabled, argv[ARR_INDEX_ONE]);
109 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "isDisabled param error");
110 if (argc > ARGS_SIZE_TWO) {
111 EDMLOGD("NAPI_SetPolicyDisabled argc == ARGS_SIZE_THREE");
112 napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
113 }
114 asyncCallbackInfo->policyCode = policyCode;
115 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetPolicyDisabled", NativeSetPolicyDisabled,
116 NativeVoidCallbackComplete);
117 callbackPtr.release();
118 return asyncWorkReturn;
119 }
120
NativeSetPolicyDisabled(napi_env env,void * data)121 void RestrictionsAddon::NativeSetPolicyDisabled(napi_env env, void *data)
122 {
123 EDMLOGI("NativeSetPolicyDisabled called");
124 if (data == nullptr) {
125 EDMLOGE("data is nullptr");
126 return;
127 }
128 AsyncRestrictionsCallbackInfo *asyncCallbackInfo = static_cast<AsyncRestrictionsCallbackInfo *>(data);
129 std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
130 asyncCallbackInfo->policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG :
131 EdmConstants::PERMISSION_TAG_VERSION_11;
132 asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->SetDisallowedPolicy(
133 asyncCallbackInfo->elementName, asyncCallbackInfo->isDisabled, asyncCallbackInfo->policyCode, permissionTag);
134 }
135
IsPrinterDisabled(napi_env env,napi_callback_info info)136 napi_value RestrictionsAddon::IsPrinterDisabled(napi_env env, napi_callback_info info)
137 {
138 return IsPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_PRINTER);
139 }
140
IsHdcDisabled(napi_env env,napi_callback_info info)141 napi_value RestrictionsAddon::IsHdcDisabled(napi_env env, napi_callback_info info)
142 {
143 return IsPolicyDisabled(env, info, EdmInterfaceCode::DISABLED_HDC);
144 }
145
IsPolicyDisabled(napi_env env,napi_callback_info info,int policyCode)146 napi_value RestrictionsAddon::IsPolicyDisabled(napi_env env, napi_callback_info info, int policyCode)
147 {
148 EDMLOGI("NAPI_IsPolicyDisabled called");
149 size_t argc = ARGS_SIZE_TWO;
150 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
151 napi_value thisArg = nullptr;
152 void *data = nullptr;
153 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
154 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
155 auto asyncCallbackInfo = new (std::nothrow) AsyncRestrictionsCallbackInfo();
156 if (asyncCallbackInfo == nullptr) {
157 return nullptr;
158 }
159 std::unique_ptr<AsyncRestrictionsCallbackInfo> callbackPtr{asyncCallbackInfo};
160 bool matchFlag = false;
161 if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_null)) {
162 asyncCallbackInfo->hasAdmin = false;
163 matchFlag = true;
164 } else if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object)) {
165 matchFlag = true;
166 asyncCallbackInfo->hasAdmin = true;
167 bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
168 ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
169 EDMLOGD(
170 "IsPolicyDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
171 "asyncCallbackInfo->abilityname:%{public}s",
172 asyncCallbackInfo->elementName.GetBundleName().c_str(),
173 asyncCallbackInfo->elementName.GetAbilityName().c_str());
174 }
175 if (argc > ARGS_SIZE_ONE) {
176 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_function);
177 }
178 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
179 if (argc > ARGS_SIZE_ONE) {
180 EDMLOGD("NAPI_IsPolicyDisabled argc == ARGS_SIZE_TWO");
181 napi_create_reference(env, argv[ARR_INDEX_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
182 }
183 asyncCallbackInfo->policyCode = policyCode;
184 napi_value asyncWorkReturn =
185 HandleAsyncWork(env, asyncCallbackInfo, "IsPolicyDisabled", NativeIsPolicyDisabled, NativeBoolCallbackComplete);
186 callbackPtr.release();
187 return asyncWorkReturn;
188 }
189
NativeIsPolicyDisabled(napi_env env,void * data)190 void RestrictionsAddon::NativeIsPolicyDisabled(napi_env env, void *data)
191 {
192 EDMLOGI("NativeIsPolicyDisabled called");
193 if (data == nullptr) {
194 EDMLOGE("data is nullptr");
195 return;
196 }
197 AsyncRestrictionsCallbackInfo *asyncCallbackInfo = static_cast<AsyncRestrictionsCallbackInfo *>(data);
198 std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
199 asyncCallbackInfo->policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG :
200 EdmConstants::PERMISSION_TAG_VERSION_11;
201 if (asyncCallbackInfo->hasAdmin) {
202 asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(
203 &(asyncCallbackInfo->elementName), asyncCallbackInfo->policyCode, asyncCallbackInfo->boolRet,
204 permissionTag);
205 } else {
206 asyncCallbackInfo->ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(
207 nullptr, asyncCallbackInfo->policyCode, asyncCallbackInfo->boolRet, permissionTag);
208 }
209 }
210
DisableMicrophone(napi_env env,napi_callback_info info)211 napi_value RestrictionsAddon::DisableMicrophone(napi_env env, napi_callback_info info)
212 {
213 return SetPolicyDisabledSync(env, info, EdmInterfaceCode::DISABLE_MICROPHONE);
214 }
215
IsMicrophoneDisabled(napi_env env,napi_callback_info info)216 napi_value RestrictionsAddon::IsMicrophoneDisabled(napi_env env, napi_callback_info info)
217 {
218 return IsPolicyDisabledSync(env, info, EdmInterfaceCode::DISABLE_MICROPHONE);
219 }
220
SetFingerprintAuthDisabled(napi_env env,napi_callback_info info)221 napi_value RestrictionsAddon::SetFingerprintAuthDisabled(napi_env env, napi_callback_info info)
222 {
223 return SetPolicyDisabledSync(env, info, EdmInterfaceCode::FINGERPRINT_AUTH);
224 }
225
IsFingerprintAuthDisabled(napi_env env,napi_callback_info info)226 napi_value RestrictionsAddon::IsFingerprintAuthDisabled(napi_env env, napi_callback_info info)
227 {
228 return IsPolicyDisabledSync(env, info, EdmInterfaceCode::FINGERPRINT_AUTH);
229 }
230
SetPolicyDisabledSync(napi_env env,napi_callback_info info,int policyCode)231 napi_value RestrictionsAddon::SetPolicyDisabledSync(napi_env env, napi_callback_info info, int policyCode)
232 {
233 EDMLOGI("NAPI_SetPolicyDisabledSync called");
234 size_t argc = ARGS_SIZE_TWO;
235 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
236 napi_value thisArg = nullptr;
237 void *data = nullptr;
238 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
239 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
240 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
241 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean), "parameter bool error");
242 OHOS::AppExecFwk::ElementName elementName;
243 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
244 "element name param error");
245 bool isDisallow = false;
246 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, isDisallow, argv[ARR_INDEX_ONE]), "bool name param error");
247
248 std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
249 policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_11;
250 ErrCode ret = RestrictionsProxy::GetRestrictionsProxy()->SetDisallowedPolicy(elementName, isDisallow, policyCode,
251 permissionTag);
252 if (FAILED(ret)) {
253 napi_throw(env, CreateError(env, ret));
254 }
255 return nullptr;
256 }
257
IsPolicyDisabledSync(napi_env env,napi_callback_info info,int policyCode)258 napi_value RestrictionsAddon::IsPolicyDisabledSync(napi_env env, napi_callback_info info, int policyCode)
259 {
260 EDMLOGI("NAPI_IsPolicyDisabled called");
261 size_t argc = ARGS_SIZE_ONE;
262 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
263 napi_value thisArg = nullptr;
264 void *data = nullptr;
265 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
266 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
267 bool hasAdmin = false;
268 OHOS::AppExecFwk::ElementName elementName;
269 ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
270 "param admin need be null or want");
271 ErrCode ret = ERR_OK;
272 bool boolRet = false;
273 std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
274 policyCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_11;
275 if (hasAdmin) {
276 ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(&elementName, policyCode, boolRet,
277 permissionTag);
278 } else {
279 ret = RestrictionsProxy::GetRestrictionsProxy()->GetDisallowedPolicy(nullptr, policyCode, boolRet,
280 permissionTag);
281 }
282 if (FAILED(ret)) {
283 napi_throw(env, CreateError(env, ret));
284 EDMLOGE("SetPolicyDisabledSync failed!");
285 return nullptr;
286 }
287 napi_value result = nullptr;
288 napi_get_boolean(env, boolRet, &result);
289 return result;
290 }
291
SetDisallowedPolicy(napi_env env,napi_callback_info info)292 napi_value RestrictionsAddon::SetDisallowedPolicy(napi_env env, napi_callback_info info)
293 {
294 EDMLOGI("NAPI_SetDisallowedPolicy called");
295 size_t argc = ARGS_SIZE_THREE;
296 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
297 napi_value thisArg = nullptr;
298 void *data = nullptr;
299 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
300 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
301 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
302 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
303 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean),
304 "parameter disallow error");
305 OHOS::AppExecFwk::ElementName elementName;
306 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
307 "element name param error");
308 EDMLOGD("SetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
309 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
310 std::string feature;
311 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
312 bool disallow = false;
313 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_TWO]), "parameter disallow parse error");
314
315 auto proxy = RestrictionsProxy::GetRestrictionsProxy();
316 if (proxy == nullptr) {
317 EDMLOGE("can not get RestrictionsProxy");
318 return nullptr;
319 }
320 auto labelCode = labelCodeMap.find(feature);
321 if (labelCode == labelCodeMap.end()) {
322 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
323 return nullptr;
324 }
325 std::uint32_t ipcCode = labelCode->second;
326 std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
327 ipcCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_12;
328 ErrCode ret = proxy->SetDisallowedPolicy(elementName, disallow, ipcCode, permissionTag);
329 if (FAILED(ret)) {
330 napi_throw(env, CreateError(env, ret));
331 }
332 return nullptr;
333 }
334
GetDisallowedPolicy(napi_env env,napi_callback_info info)335 napi_value RestrictionsAddon::GetDisallowedPolicy(napi_env env, napi_callback_info info)
336 {
337 EDMLOGI("NAPI_GetDisallowedPolicy called");
338 size_t argc = ARGS_SIZE_TWO;
339 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
340 napi_value thisArg = nullptr;
341 void *data = nullptr;
342 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
343 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
344 bool hasAdmin = false;
345 OHOS::AppExecFwk::ElementName elementName;
346 ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
347 "param admin need be null or want");
348 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter feature error");
349 std::string feature;
350 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, feature, argv[ARR_INDEX_ONE]), "parameter feature parse error");
351 if (hasAdmin) {
352 EDMLOGD("GetDisallowedPolicy: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
353 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
354 } else {
355 EDMLOGD("GetDisallowedPolicy: elementName is null");
356 }
357
358 bool disallow = false;
359 auto proxy = RestrictionsProxy::GetRestrictionsProxy();
360 if (proxy == nullptr) {
361 EDMLOGE("can not get RestrictionsProxy");
362 return nullptr;
363 }
364 auto labelCode = labelCodeMap.find(feature);
365 if (labelCode == labelCodeMap.end()) {
366 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
367 return nullptr;
368 }
369 std::uint32_t ipcCode = labelCode->second;
370 std::string permissionTag = (std::find(multiPermCodes.begin(), multiPermCodes.end(),
371 ipcCode) == multiPermCodes.end()) ? WITHOUT_PERMISSION_TAG : EdmConstants::PERMISSION_TAG_VERSION_12;
372 ErrCode ret = ERR_OK;
373 if (hasAdmin) {
374 ret = proxy->GetDisallowedPolicy(&elementName, ipcCode, disallow, permissionTag);
375 } else {
376 ret = proxy->GetDisallowedPolicy(nullptr, ipcCode, disallow, permissionTag);
377 }
378 if (FAILED(ret)) {
379 napi_throw(env, CreateError(env, ret));
380 return nullptr;
381 }
382 napi_value result = nullptr;
383 napi_get_boolean(env, disallow, &result);
384 return result;
385 }
386
387 static napi_module g_restrictionsModule = {
388 .nm_version = 1,
389 .nm_flags = 0,
390 .nm_filename = nullptr,
391 .nm_register_func = RestrictionsAddon::Init,
392 .nm_modname = "enterprise.restrictions",
393 .nm_priv = ((void *)0),
394 .reserved = {0},
395 };
396
RestrictionsRegister()397 extern "C" __attribute__((constructor)) void RestrictionsRegister()
398 {
399 napi_module_register(&g_restrictionsModule);
400 }
401