1 /*
2 * Copyright (c) 2024-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 "plugin_policy_reader.h"
17
18 #ifdef BLUETOOTH_EDM_ENABLE
19 #include "allowed_bluetooth_devices_query.h"
20 #include "disallowed_bluetooth_devices_query.h"
21 #include "disable_bluetooth_query.h"
22 #endif
23
24 #ifdef USB_SERVICE_EDM_ENABLE
25 #include "allowed_usb_devices_query.h"
26 #include "disable_usb_query.h"
27 #endif
28
29 #ifdef USERIAM_EDM_ENABLE
30 #include "fingerprint_auth_query.h"
31 #include "password_policy.h"
32 #include "password_policy_query.h"
33 #include "password_policy_serializer.h"
34 #endif
35
36 #ifdef PASTEBOARD_EDM_ENABLE
37 #include "clipboard_policy.h"
38 #include "clipboard_policy_query.h"
39 #include "clipboard_policy_serializer.h"
40 #endif
41
42 #include "permission_managed_state_query.h"
43
44 #ifdef CAMERA_FRAMEWORK_EDM_ENABLE
45 #include "disable_camera_query.h"
46 #endif
47
48 #ifdef AUDIO_FRAMEWORK_EDM_ENABLE
49 #include "disable_hdc_query.h"
50 #include "disable_microphone_query.h"
51 #include "disable_printer_query.h"
52 #endif
53
54 #ifdef OS_ACCOUNT_EDM_ENABLE
55 #include "disallow_add_local_account_query.h"
56 #endif
57
58 #ifdef ABILITY_RUNTIME_EDM_ENABLE
59 #include "disallowed_running_bundles_query.h"
60 #endif
61
62 #ifdef LOCATION_EDM_ENABLE
63 #include "location_policy_query.h"
64 #endif
65
66 #ifdef WIFI_EDM_ENABLE
67 #include "allowed_wifi_list_query.h"
68 #include "array_wifi_id_serializer.h"
69 #include "disallowed_wifi_list_query.h"
70 #include "set_wifi_disabled_query.h"
71 #endif
72
73 #ifdef USB_STORAGE_SERVICE_EDM_ENABLE
74 #include "usb_read_only_query.h"
75 #endif
76
77 #ifdef COMMON_EVENT_SERVICE_EDM_ENABLE
78 #include "set_browser_policies_query.h"
79 #endif
80
81 #ifdef SMS_EDM_ENABLE
82 #include "disallowed_sms_query.h"
83 #endif
84
85 #ifdef APN_EDM_ENABLE
86 #include "disallow_modify_apn_query.h"
87 #endif
88
89 #ifdef MMS_EDM_ENABLE
90 #include "disallowed_mms_query.h"
91 #endif
92
93 #ifdef BACKUP_AND_RESTORE_EDM_ENABLE
94 #include "disable_backup_and_restore_query.h"
95 #endif
96
97 #ifdef MOBILE_DATA_ENABLE
98 #include "disallowed_mobile_data_query.h"
99 #endif
100
101 #ifdef TELEPHONY_EDM_ENABLE
102 #include "disallowed_telephony_call_query.h"
103 #include "telephony_call_policy_query.h"
104 #endif
105
106 #ifdef SAMBA_EDM_ENABLE
107 #include "disable_samba_client_query.h"
108 #include "disable_samba_server_query.h"
109 #endif
110
111 #ifdef POWER_MANAGER_EDM_ENABLE
112 #include "disallow_power_long_press_query.h"
113 #endif
114
115 #ifdef NET_MANAGER_BASE_EDM_ENABLE
116 #include "disallowed_airplane_mode_query.h"
117 #endif
118
119 #ifdef NOTIFICATION_EDM_ENABLE
120 #include "disallowed_notification_query.h"
121 #endif
122
123 #ifdef FEATURE_PC_ONLY
124 #include "disallow_export_recovery_key_query.h"
125 #include "get_auto_unlock_after_reboot_query.h"
126 #include "disable_usb_storage_device_write_query.h"
127 #include "disallow_modify_ethernet_ip_query.h"
128 #include "install_local_enterprise_app_enabled_query.h"
129 #include "disable_print_query.h"
130 #endif
131
132 #ifdef NETMANAGER_EXT_EDM_ENABLE
133 #include "disallow_vpn_query.h"
134 #endif
135
136 #ifdef SUDO_EDM_ENABLE
137 #include "disable_sudo_query.h"
138 #endif
139
140 #ifdef PRIVATE_SPACE_EDM_ENABLE
141 #include "disable_private_space_query.h"
142 #endif
143
144 #include "allowed_app_distribution_types_query.h"
145 #include "allowed_install_bundles_query.h"
146 #include "disable_maintenance_mode_query.h"
147 #include "disable_mtp_client_query.h"
148 #include "disable_mtp_server_query.h"
149 #include "disable_user_mtp_client_query.h"
150 #include "disable_set_biometrics_and_screenLock_query.h"
151 #include "disable_set_device_name_query.h"
152 #include "disallow_distributed_transmission_query.h"
153 #include "disallow_modify_datetime_query.h"
154 #include "disallowed_install_bundles_query.h"
155 #include "disallowed_tethering_query.h"
156 #include "disallowed_uninstall_bundles_query.h"
157 #include "edm_ipc_interface_code.h"
158 #include "edm_log.h"
159 #include "func_code_utils.h"
160 #include "get_device_encryption_status_query.h"
161 #include "get_display_version_query.h"
162 #include "get_security_patch_tag_query.h"
163 #include "inactive_user_freeze_query.h"
164 #include "installed_bundle_info_list_query.h"
165 #include "is_app_kiosk_allowed_query.h"
166 #include "ntp_server_query.h"
167 #include "parameters.h"
168 #include "snapshot_skip_query.h"
169
170 namespace OHOS {
171 namespace EDM {
172 std::shared_ptr<PluginPolicyReader> PluginPolicyReader::instance_ = nullptr;
173 std::once_flag PluginPolicyReader::flag_;
174
GetInstance()175 std::shared_ptr<PluginPolicyReader> PluginPolicyReader::GetInstance()
176 {
177 std::call_once(flag_, []() {
178 if (instance_ == nullptr) {
179 instance_ = std::make_shared<PluginPolicyReader>();
180 }
181 });
182 return instance_;
183 }
184
GetPolicyByCode(std::shared_ptr<PolicyManager> policyManager,uint32_t funcCode,MessageParcel & data,MessageParcel & reply,int32_t userId)185 ErrCode PluginPolicyReader::GetPolicyByCode(std::shared_ptr<PolicyManager> policyManager, uint32_t funcCode,
186 MessageParcel &data, MessageParcel &reply, int32_t userId)
187 {
188 FuncCodeUtils::PrintFuncCode(funcCode);
189 FuncFlag flag = FuncCodeUtils::GetSystemFlag(funcCode);
190 if (flag != FuncFlag::POLICY_FLAG) {
191 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
192 }
193 std::uint32_t code = FuncCodeUtils::GetPolicyCode(funcCode);
194 return GetPolicyByCodeInner(policyManager, code, data, reply, userId);
195 }
196
GetPolicyByCodeInner(std::shared_ptr<PolicyManager> policyManager,uint32_t code,MessageParcel & data,MessageParcel & reply,int32_t userId)197 ErrCode PluginPolicyReader::GetPolicyByCodeInner(std::shared_ptr<PolicyManager> policyManager, uint32_t code,
198 MessageParcel &data, MessageParcel &reply, int32_t userId)
199 {
200 EDMLOGI("PluginPolicyReader query policy ::code %{public}u", code);
201 std::shared_ptr<IPolicyQuery> obj;
202 ErrCode ret = GetPolicyQuery(obj, code);
203 EDMLOGI("GetPolicyQuery errcode = %{public}d", ret);
204 if (obj == nullptr) {
205 EDMLOGI("GetPolicyQuery obj is null, query from plugin");
206 return ret;
207 }
208 return obj->GetPolicy(policyManager, code, data, reply, userId);
209 }
210
GetPolicyQuery(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)211 ErrCode PluginPolicyReader::GetPolicyQuery(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
212 {
213 switch (code) {
214 case EdmInterfaceCode::ALLOWED_BLUETOOTH_DEVICES:
215 #ifdef BLUETOOTH_EDM_ENABLE
216 obj = std::make_shared<AllowedBluetoothDevicesQuery>();
217 return ERR_OK;
218 #else
219 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
220 #endif
221 case EdmInterfaceCode::ALLOWED_INSTALL_BUNDLES:
222 obj = std::make_shared<AllowedInstallBundlesQuery>();
223 return ERR_OK;
224 case EdmInterfaceCode::ALLOWED_USB_DEVICES:
225 #ifdef USB_SERVICE_EDM_ENABLE
226 obj = std::make_shared<AllowedUsbDevicesQuery>();
227 return ERR_OK;
228 #else
229 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
230 #endif
231 case EdmInterfaceCode::CLIPBOARD_POLICY:
232 #ifdef PASTEBOARD_EDM_ENABLE
233 obj = std::make_shared<ClipboardPolicyQuery>();
234 return ERR_OK;
235 #else
236 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
237 #endif
238 case EdmInterfaceCode::DISABLE_BLUETOOTH:
239 #ifdef BLUETOOTH_EDM_ENABLE
240 obj = std::make_shared<DisableBluetoothQuery>();
241 return ERR_OK;
242 #else
243 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
244 #endif
245 case EdmInterfaceCode::DISABLE_CAMERA:
246 #ifdef CAMERA_FRAMEWORK_EDM_ENABLE
247 obj = std::make_shared<DisableCameraQuery>();
248 return ERR_OK;
249 #else
250 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
251 #endif
252 default:
253 break;
254 }
255 return GetPolicyQueryFirst(obj, code);
256 }
257
GetPolicyQueryFirst(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)258 ErrCode PluginPolicyReader::GetPolicyQueryFirst(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
259 {
260 switch (code) {
261 case EdmInterfaceCode::DISABLED_HDC:
262 #ifdef AUDIO_FRAMEWORK_EDM_ENABLE
263 obj = std::make_shared<DisableHdcQuery>();
264 return ERR_OK;
265 #else
266 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
267 #endif
268 case EdmInterfaceCode::DISABLE_MICROPHONE:
269 #ifdef AUDIO_FRAMEWORK_EDM_ENABLE
270 obj = std::make_shared<DisableMicrophoneQuery>();
271 return ERR_OK;
272 #else
273 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
274 #endif
275 case EdmInterfaceCode::DISABLED_PRINTER:
276 #ifdef AUDIO_FRAMEWORK_EDM_ENABLE
277 obj = std::make_shared<DisablePrinterQuery>();
278 return ERR_OK;
279 #else
280 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
281 #endif
282 case EdmInterfaceCode::DISABLE_USB:
283 #ifdef USB_SERVICE_EDM_ENABLE
284 obj = std::make_shared<DisableUsbQuery>();
285 return ERR_OK;
286 #else
287 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
288 #endif
289 case EdmInterfaceCode::DISALLOW_ADD_LOCAL_ACCOUNT:
290 #ifdef OS_ACCOUNT_EDM_ENABLE
291 obj = std::make_shared<DisallowAddLocalAccountQuery>();
292 return ERR_OK;
293 #else
294 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
295 #endif
296 case EdmInterfaceCode::DISALLOW_MODIFY_DATETIME:
297 obj = std::make_shared<DisallowModifyDateTimeQuery>();
298 return ERR_OK;
299 case EdmInterfaceCode::DISALLOWED_INSTALL_BUNDLES:
300 obj = std::make_shared<DisallowedInstallBundlesQuery>();
301 return ERR_OK;
302 default:
303 break;
304 }
305 return GetPolicyQuerySecond(obj, code);
306 }
307
GetPolicyQuerySecond(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)308 ErrCode PluginPolicyReader::GetPolicyQuerySecond(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
309 {
310 switch (code) {
311 case EdmInterfaceCode::DISALLOW_RUNNING_BUNDLES:
312 #ifdef ABILITY_RUNTIME_EDM_ENABLE
313 obj = std::make_shared<DisallowedRunningBundlesQuery>();
314 return ERR_OK;
315 #else
316 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
317 #endif
318 case EdmInterfaceCode::DISALLOWED_TETHERING:
319 obj = std::make_shared<DisallowedThtheringQuery>();
320 return ERR_OK;
321 case EdmInterfaceCode::DISALLOWED_UNINSTALL_BUNDLES:
322 obj = std::make_shared<DisallowedUninstallBundlesQuery>();
323 return ERR_OK;
324 case EdmInterfaceCode::FINGERPRINT_AUTH:
325 #ifdef USERIAM_EDM_ENABLE
326 obj = std::make_shared<FingerprintAuthQuery>();
327 return ERR_OK;
328 #else
329 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
330 #endif
331 case EdmInterfaceCode::GET_DEVICE_ENCRYPTION_STATUS:
332 obj = std::make_shared<GetDeviceEncryptionStatusQuery>();
333 return ERR_OK;
334 case EdmInterfaceCode::GET_DISPLAY_VERSION:
335 obj = std::make_shared<GetDisplayVersionQuery>();
336 return ERR_OK;
337 case EdmInterfaceCode::GET_SECURITY_PATCH_TAG:
338 obj = std::make_shared<GetSecurityPatchTagQuery>();
339 return ERR_OK;
340 case EdmInterfaceCode::INACTIVE_USER_FREEZE:
341 obj = std::make_shared<InactiveUserFreezeQuery>();
342 return ERR_OK;
343 case EdmInterfaceCode::LOCATION_POLICY:
344 #ifdef LOCATION_EDM_ENABLE
345 obj = std::make_shared<LocationPolicyQuery>();
346 break;
347 #else
348 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
349 #endif
350 case EdmInterfaceCode::NTP_SERVER:
351 obj = std::make_shared<NTPServerQuery>();
352 return ERR_OK;
353 }
354 return GetPolicyQueryThird(obj, code);
355 }
356
GetPolicyQueryThird(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)357 ErrCode PluginPolicyReader::GetPolicyQueryThird(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
358 {
359 switch (code) {
360 case EdmInterfaceCode::PASSWORD_POLICY:
361 #ifdef USERIAM_EDM_ENABLE
362 obj = std::make_shared<PasswordPolicyQuery>();
363 return ERR_OK;
364 #else
365 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
366 #endif
367 case EdmInterfaceCode::DISABLE_WIFI:
368 #ifdef WIFI_EDM_ENABLE
369 obj = std::make_shared<SetWifiDisabledQuery>();
370 return ERR_OK;
371 #else
372 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
373 #endif
374 case EdmInterfaceCode::SNAPSHOT_SKIP:
375 obj = std::make_shared<SnapshotSkipQuery>();
376 return ERR_OK;
377 case EdmInterfaceCode::USB_READ_ONLY:
378 #ifdef USB_STORAGE_SERVICE_EDM_ENABLE
379 obj = std::make_shared<UsbReadOnlyQuery>();
380 return ERR_OK;
381 #else
382 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
383 #endif
384 case EdmInterfaceCode::SET_BROWSER_POLICIES:
385 #ifdef COMMON_EVENT_SERVICE_EDM_ENABLE
386 obj = std::make_shared<SetBrowserPoliciesQuery>();
387 return ERR_OK;
388 #else
389 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
390 #endif
391 case EdmInterfaceCode::DISABLE_MTP_CLIENT:
392 obj = std::make_shared<DisableMtpClientQuery>();
393 return ERR_OK;
394 case EdmInterfaceCode::DISABLE_MTP_SERVER:
395 obj = std::make_shared<DisableMtpServerQuery>();
396 return ERR_OK;
397 case EdmInterfaceCode::DISABLE_USER_MTP_CLIENT:
398 obj = std::make_shared<DisableUserMtpClientQuery>();
399 return ERR_OK;
400 case EdmInterfaceCode::DISABLE_MAINTENANCE_MODE:
401 obj = std::make_shared<DisableMaintenanceModeQuery>();
402 return ERR_OK;
403 default:
404 break;
405 }
406 return GetPolicyQueryFourth(obj, code);
407 }
408
GetPolicyQueryFourth(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)409 ErrCode PluginPolicyReader::GetPolicyQueryFourth(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
410 {
411 switch (code) {
412 case EdmInterfaceCode::DISABLE_SAMBA_CLIENT:
413 #ifdef SAMBA_EDM_ENABLE
414 obj = std::make_shared<DisableSambaClientQuery>();
415 return ERR_OK;
416 #else
417 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
418 #endif
419 case EdmInterfaceCode::DISALLOWED_EXPORT_RECOVERY_KEY:
420 #ifdef FEATURE_PC_ONLY
421 obj = std::make_shared<DisallowExportRecoveryKeyQuery>();
422 return ERR_OK;
423 #else
424 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
425 #endif
426 case EdmInterfaceCode::DISABLE_SAMBA_SERVER:
427 #ifdef SAMBA_EDM_ENABLE
428 obj = std::make_shared<DisableSambaServerQuery>();
429 return ERR_OK;
430 #else
431 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
432 #endif
433 case EdmInterfaceCode::IS_APP_KIOSK_ALLOWED:
434 obj = std::make_shared<IsAppKioskAllowedQuery>();
435 return ERR_OK;
436 case EdmInterfaceCode::DISALLOW_POWER_LONG_PRESS:
437 #ifdef POWER_MANAGER_EDM_ENABLE
438 obj = std::make_shared<DisallowPowerLongPressQuery>();
439 return ERR_OK;
440 #else
441 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
442 #endif
443 case EdmInterfaceCode::DISABLE_PRIVATE_SPACE:
444 #ifdef PRIVATE_SPACE_EDM_ENABLE
445 obj = std::make_shared<DisablePrivateSpaceQuery>();
446 return ERR_OK;
447 #else
448 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
449 #endif
450 default:
451 break;
452 }
453 return GetPolicyQueryFifthPartOne(obj, code);
454 }
455
GetPolicyQueryFifthPartOne(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)456 ErrCode PluginPolicyReader::GetPolicyQueryFifthPartOne(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
457 {
458 switch (code) {
459 case EdmInterfaceCode::GET_BUNDLE_INFO_LIST:
460 obj = std::make_shared<InstalledBundleInfoListQuery>();
461 return ERR_OK;
462 case EdmInterfaceCode::DISALLOWED_BLUETOOTH_DEVICES:
463 #ifdef BLUETOOTH_EDM_ENABLE
464 obj = std::make_shared<DisallowedBluetoothDevicesQuery>();
465 return ERR_OK;
466 #else
467 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
468 #endif
469 case EdmInterfaceCode::ALLOWED_WIFI_LIST:
470 #ifdef WIFI_EDM_ENABLE
471 obj = std::make_shared<AllowedWifiListQuery>();
472 return ERR_OK;
473 #else
474 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
475 #endif
476 case EdmInterfaceCode::DISALLOWED_WIFI_LIST:
477 #ifdef WIFI_EDM_ENABLE
478 obj = std::make_shared<DisallowedWifiListQuery>();
479 return ERR_OK;
480 #else
481 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
482 #endif
483 default:
484 break;
485 }
486 return GetPolicyQueryFifthPartTwo(obj, code);
487 }
488
489
GetPolicyQueryFifthPartTwo(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)490 ErrCode PluginPolicyReader::GetPolicyQueryFifthPartTwo(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
491 {
492 switch (code) {
493 case EdmInterfaceCode::DISALLOWED_SMS:
494 #ifdef SMS_EDM_ENABLE
495 obj = std::make_shared<DisallowedSMSQuery>();
496 return ERR_OK;
497 #else
498 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
499 #endif
500 case EdmInterfaceCode::DISALLOWED_MMS:
501 #ifdef MMS_EDM_ENABLE
502 obj = std::make_shared<DisallowedMMSQuery>();
503 return ERR_OK;
504 #else
505 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
506 #endif
507 case EdmInterfaceCode::DISABLE_BACKUP_AND_RESTORE:
508 #ifdef BACKUP_AND_RESTORE_EDM_ENABLE
509 obj = std::make_shared<DisableBackupAndRestoreQuery>();
510 return ERR_OK;
511 #else
512 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
513 #endif
514 default:
515 break;
516 }
517 return GetPolicyQuerySixth(obj, code);
518 }
519
GetPolicyQuerySixth(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)520 ErrCode PluginPolicyReader::GetPolicyQuerySixth(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
521 {
522 switch (code) {
523 case EdmInterfaceCode::DISALLOWED_DISTRIBUTED_TRANSMISSION:
524 obj = std::make_shared<DisallowDistributedTransmissionQuery>();
525 return ERR_OK;
526 case EdmInterfaceCode::DISALLOWED_NOTIFICATION:
527 #ifdef NOTIFICATION_EDM_ENABLE
528 obj = std::make_shared<DisallowedNotificationQuery>();
529 return ERR_OK;
530 #else
531 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
532 #endif
533 case EdmInterfaceCode::DISALLOWED_TELEPHONY_CALL:
534 #ifdef TELEPHONY_EDM_ENABLE
535 obj = std::make_shared<DisallowedTelephonyCallQuery>();
536 return ERR_OK;
537 #else
538 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
539 #endif
540 case EdmInterfaceCode::TELEPHONY_CALL_POLICY:
541 #ifdef TELEPHONY_EDM_ENABLE
542 obj = std::make_shared<TelephonyCallPolicyQuery>();
543 return ERR_OK;
544 #else
545 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
546 #endif
547 case EdmInterfaceCode::DISALLOWED_USB_STORAGE_DEVICE_WRITE:
548 #ifdef FEATURE_PC_ONLY
549 obj = std::make_shared<DisableUsbStorageDeviceWriteQuery>();
550 return ERR_OK;
551 #else
552 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
553 #endif
554 case EdmInterfaceCode::PERMISSION_MANAGED_STATE:
555 obj = std::make_shared<PermissionManagedStateQuery>();
556 return ERR_OK;
557 default:
558 break;
559 }
560 return GetPolicyQuerySeventh(obj, code);
561 }
562
GetPolicyQuerySeventh(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)563 ErrCode PluginPolicyReader::GetPolicyQuerySeventh(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
564 {
565 switch (code) {
566 case EdmInterfaceCode::DISABLED_PRINT:
567 #ifdef FEATURE_PC_ONLY
568 obj = std::make_shared<DisablePrintQuery>();
569 return ERR_OK;
570 #else
571 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
572 #endif
573 case EdmInterfaceCode::DISALLOW_VPN:
574 #ifdef NETMANAGER_EXT_EDM_ENABLE
575 obj = std::make_shared<DisallowVPNQuery>();
576 return ERR_OK;
577 #else
578 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
579 #endif
580 case EdmInterfaceCode::DISALLOWED_MOBILE_DATA:
581 #ifdef MOBILE_DATA_ENABLE
582 obj = std::make_shared<DisallowedMobileDataQuery>();
583 return ERR_OK;
584 #else
585 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
586 #endif
587 case EdmInterfaceCode::DISALLOWED_AIRPLANE_MODE:
588 #ifdef NET_MANAGER_BASE_EDM_ENABLE
589 obj = std::make_shared<DisallowedAirplaneModeQuery>();
590 return ERR_OK;
591 #else
592 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
593 #endif
594 default:
595 break;
596 }
597 return GetPolicyQueryEighth(obj, code);
598 }
599
GetPolicyQueryEighth(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)600 ErrCode PluginPolicyReader::GetPolicyQueryEighth(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
601 {
602 switch (code) {
603 case EdmInterfaceCode::DISALLOW_MODIFY_APN:
604 #ifdef APN_EDM_ENABLE
605 obj = std::make_shared<DisallowModifyAPNQuery>();
606 return ERR_OK;
607 #else
608 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
609 #endif
610 case EdmInterfaceCode::SET_AUTO_UNLOCK_AFTER_REBOOT:
611 #ifdef FEATURE_PC_ONLY
612 obj = std::make_shared<GetAutoUnlockAfterRebootQuery>();
613 return ERR_OK;
614 #else
615 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
616 #endif
617 case EdmInterfaceCode::DISABLE_SET_BIOMETRICS_AND_SCREENLOCK:
618 obj = std::make_shared<DisableSetBiometricsAndScreenLockQuery>();
619 return ERR_OK;
620 case EdmInterfaceCode::ALLOWED_INSTALL_APP_TYPE:
621 obj = std::make_shared<AllowedAppDistributionTypesQuery>();
622 return ERR_OK;
623 case EdmInterfaceCode::DISABLE_SET_DEVICE_NAME:
624 obj = std::make_shared<DisableSetDeviceNameQuery>();
625 return ERR_OK;
626 case EdmInterfaceCode::DISALLOW_MODIFY_ETHERNET_IP:
627 #ifdef FEATURE_PC_ONLY
628 obj = std::make_shared<DisallowModifyEthernetIpQuery>();
629 return ERR_OK;
630 #else
631 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
632 #endif
633 default:
634 break;
635 }
636 return GetPolicyQueryNinth(obj, code);
637 }
638
GetPolicyQueryNinth(std::shared_ptr<IPolicyQuery> & obj,uint32_t code)639 ErrCode PluginPolicyReader::GetPolicyQueryNinth(std::shared_ptr<IPolicyQuery> &obj, uint32_t code)
640 {
641 switch (code) {
642 case EdmInterfaceCode::DISALLOWED_SUDO:
643 #ifdef SUDO_EDM_ENABLE
644 obj = std::make_shared<DisableSudoQuery>();
645 return ERR_OK;
646 #else
647 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
648 #endif
649 case EdmInterfaceCode::SET_INSTALL_LOCAL_ENTERPRISE_APP_ENABLED:
650 #ifdef FEATURE_PC_ONLY
651 obj = std::make_shared<InstallLocalEnterpriceAppEnabledQuery>();
652 return ERR_OK;
653 #else
654 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
655 #endif
656 default:
657 break;
658 }
659 return ERR_CANNOT_FIND_QUERY_FAILED;
660 }
661
662 } // namespace EDM
663 } // namespace OHOS