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 "dlp_permission_proxy.h"
17 #include "dlp_permission.h"
18 #include "dlp_permission_log.h"
19 #include "parcel.h"
20 #include "string_ex.h"
21 
22 namespace OHOS {
23 namespace Security {
24 namespace DlpPermission {
25 namespace {
26 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpPermissionProxy"};
27 static const uint32_t MAX_SUPPORT_FILE_TYPE_NUM = 1024;
28 static const uint32_t MAX_RETENTION_SIZE = 1024;
29 static const uint32_t MAX_FIEL_RECORD_SIZE = 1024;
30 static const uint32_t MAX_APPID_LIST_SIZE = 250;
31 }
32 
DlpPermissionProxy(const sptr<IRemoteObject> & impl)33 DlpPermissionProxy::DlpPermissionProxy(const sptr<IRemoteObject>& impl) : IRemoteProxy<IDlpPermissionService>(impl)
34 {}
35 
~DlpPermissionProxy()36 DlpPermissionProxy::~DlpPermissionProxy()
37 {}
38 
GenerateDlpCertificate(const sptr<DlpPolicyParcel> & policyParcel,const sptr<IDlpPermissionCallback> & callback)39 int32_t DlpPermissionProxy::GenerateDlpCertificate(
40     const sptr<DlpPolicyParcel>& policyParcel, const sptr<IDlpPermissionCallback>& callback)
41 {
42     MessageParcel data;
43     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
44         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
45         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
46     }
47 
48     if (!data.WriteParcelable(policyParcel)) {
49         DLP_LOG_ERROR(LABEL, "Write parcel fail");
50         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
51     }
52 
53     if (!data.WriteRemoteObject(callback->AsObject())) {
54         DLP_LOG_ERROR(LABEL, "Write object fail");
55         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
56     }
57 
58     MessageParcel reply;
59     MessageOption option(MessageOption::TF_SYNC);
60     sptr<IRemoteObject> remote = Remote();
61     if (remote == nullptr) {
62         DLP_LOG_ERROR(LABEL, "Remote service is null");
63         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
64     }
65     int32_t requestResult = remote->SendRequest(
66         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GENERATE_DLP_CERTIFICATE), data, reply, option);
67     if (requestResult != DLP_OK) {
68         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
69         return requestResult;
70     }
71     int32_t res;
72     if (!reply.ReadInt32(res)) {
73         DLP_LOG_ERROR(LABEL, "Read int32 fail");
74         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
75     }
76     return res;
77 }
78 
ParseDlpCertificate(sptr<CertParcel> & certParcel,const sptr<IDlpPermissionCallback> & callback,const std::string & appId,const bool & offlineAccess)79 int32_t DlpPermissionProxy::ParseDlpCertificate(sptr<CertParcel>& certParcel,
80     const sptr<IDlpPermissionCallback>& callback, const std::string& appId, const bool& offlineAccess)
81 {
82     MessageParcel data;
83     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
84         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
85         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
86     }
87     if (!data.WriteString(appId)) {
88         DLP_LOG_ERROR(LABEL, "Write appId fail");
89         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
90     }
91     if (!data.WriteParcelable(certParcel)) {
92         DLP_LOG_ERROR(LABEL, "Write certParcel fail");
93         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
94     }
95     if (!data.WriteRemoteObject(callback->AsObject())) {
96         DLP_LOG_ERROR(LABEL, "Write object fail");
97         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
98     }
99     if (!data.WriteBool(offlineAccess)) {
100         DLP_LOG_ERROR(LABEL, "Write offlineAccess fail");
101         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
102     }
103 
104     MessageParcel reply;
105     MessageOption option(MessageOption::TF_SYNC);
106     sptr<IRemoteObject> remote = Remote();
107     if (remote == nullptr) {
108         DLP_LOG_ERROR(LABEL, "Remote service is null");
109         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
110     }
111 
112     int32_t requestResult = remote->SendRequest(
113         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::PARSE_DLP_CERTIFICATE),
114         data, reply, option);
115     if (requestResult != DLP_OK) {
116         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
117         return requestResult;
118     }
119 
120     int32_t res;
121     if (!reply.ReadInt32(res)) {
122         DLP_LOG_ERROR(LABEL, "Read int32 fail");
123         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
124     }
125     return res;
126 }
127 
InstallDlpSandbox(const std::string & bundleName,DLPFileAccess dlpFileAccess,int32_t userId,SandboxInfo & sandboxInfo,const std::string & uri)128 int32_t DlpPermissionProxy::InstallDlpSandbox(const std::string& bundleName, DLPFileAccess dlpFileAccess,
129     int32_t userId, SandboxInfo& sandboxInfo, const std::string& uri)
130 {
131     MessageParcel data;
132     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
133         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
134         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
135     }
136 
137     if (!data.WriteString(bundleName)) {
138         DLP_LOG_ERROR(LABEL, "Write string fail");
139         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
140     }
141 
142     if (!data.WriteUint32(dlpFileAccess)) {
143         DLP_LOG_ERROR(LABEL, "Write uint32 fail");
144         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
145     }
146 
147     if (!data.WriteInt32(userId)) {
148         DLP_LOG_ERROR(LABEL, "Write int32 fail");
149         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
150     }
151 
152     if (!data.WriteString(uri)) {
153         DLP_LOG_ERROR(LABEL, "Write string fail");
154         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
155     }
156 
157     MessageParcel reply;
158     MessageOption option(MessageOption::TF_SYNC);
159     sptr<IRemoteObject> remote = Remote();
160     if (remote == nullptr) {
161         DLP_LOG_ERROR(LABEL, "Remote service is null");
162         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
163     }
164     int32_t requestResult = remote->SendRequest(
165         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::INSTALL_DLP_SANDBOX), data, reply, option);
166     if (requestResult != DLP_OK) {
167         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
168         return requestResult;
169     }
170     int32_t res;
171     if (!reply.ReadInt32(res)) {
172         DLP_LOG_ERROR(LABEL, "Read int32 fail");
173         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
174     }
175 
176     if (!reply.ReadInt32(sandboxInfo.appIndex)) {
177         DLP_LOG_ERROR(LABEL, "Read int32 fail");
178         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
179     }
180 
181     if (!reply.ReadUint32(sandboxInfo.tokenId)) {
182         DLP_LOG_ERROR(LABEL, "Read uint32 fail");
183         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
184     }
185     return res;
186 }
187 
UninstallDlpSandbox(const std::string & bundleName,int32_t appIndex,int32_t userId)188 int32_t DlpPermissionProxy::UninstallDlpSandbox(const std::string& bundleName, int32_t appIndex, int32_t userId)
189 {
190     MessageParcel data;
191     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
192         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
193         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
194     }
195 
196     if (!data.WriteString(bundleName)) {
197         DLP_LOG_ERROR(LABEL, "Write string fail");
198         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
199     }
200 
201     if (!data.WriteInt32(appIndex)) {
202         DLP_LOG_ERROR(LABEL, "Write int32 fail");
203         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
204     }
205 
206     if (!data.WriteInt32(userId)) {
207         DLP_LOG_ERROR(LABEL, "Write int32 fail");
208         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
209     }
210 
211     MessageParcel reply;
212     MessageOption option(MessageOption::TF_SYNC);
213     sptr<IRemoteObject> remote = Remote();
214     if (remote == nullptr) {
215         DLP_LOG_ERROR(LABEL, "Remote service is null");
216         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
217     }
218     int32_t requestResult = remote->SendRequest(
219         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::UNINSTALL_DLP_SANDBOX), data, reply, option);
220     if (requestResult != DLP_OK) {
221         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
222         return requestResult;
223     }
224     int32_t res;
225     if (!reply.ReadInt32(res)) {
226         DLP_LOG_ERROR(LABEL, "Read int32 fail");
227         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
228     }
229     return res;
230 }
231 
GetSandboxExternalAuthorization(int sandboxUid,const AAFwk::Want & want,SandBoxExternalAuthorType & authType)232 int32_t DlpPermissionProxy::GetSandboxExternalAuthorization(int sandboxUid,
233     const AAFwk::Want& want, SandBoxExternalAuthorType& authType)
234 {
235     MessageParcel data;
236     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
237         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
238         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
239     }
240 
241     if (!data.WriteInt32(sandboxUid)) {
242         DLP_LOG_ERROR(LABEL, "Write int32 fail");
243         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
244     }
245 
246     if (!data.WriteParcelable(&want)) {
247         DLP_LOG_ERROR(LABEL, "Write want fail");
248         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
249     }
250 
251     MessageParcel reply;
252     MessageOption option(MessageOption::TF_SYNC);
253     sptr<IRemoteObject> remote = Remote();
254     if (remote == nullptr) {
255         DLP_LOG_ERROR(LABEL, "Remote service is null");
256         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
257     }
258     int32_t requestResult = remote->SendRequest(
259         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_SANDBOX_EXTERNAL_AUTH), data, reply, option);
260     if (requestResult != DLP_OK) {
261         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
262         return requestResult;
263     }
264     int32_t res;
265     if (!reply.ReadInt32(res)) {
266         DLP_LOG_ERROR(LABEL, "Read int32 fail");
267         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
268     }
269     if (res < DENY_START_ABILITY || res > ALLOW_START_ABILITY) {
270         DLP_LOG_ERROR(LABEL, "Read authType result value error");
271         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
272     }
273     authType = static_cast<SandBoxExternalAuthorType>(res);
274     return DLP_OK;
275 }
276 
QueryDlpFileCopyableByTokenId(bool & copyable,uint32_t tokenId)277 int32_t DlpPermissionProxy::QueryDlpFileCopyableByTokenId(bool& copyable, uint32_t tokenId)
278 {
279     MessageParcel data;
280     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
281         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
282         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
283     }
284 
285     if (!data.WriteUint32(tokenId)) {
286         DLP_LOG_ERROR(LABEL, "Write uint32 fail");
287         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
288     }
289 
290     MessageParcel reply;
291     MessageOption option(MessageOption::TF_SYNC);
292     sptr<IRemoteObject> remote = Remote();
293     if (remote == nullptr) {
294         DLP_LOG_ERROR(LABEL, "Remote service is null");
295         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
296     }
297     int32_t requestResult = remote->SendRequest(
298         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::QUERY_DLP_FILE_ACCESS_BY_TOKEN_ID), data, reply,
299         option);
300     if (requestResult != DLP_OK) {
301         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
302         return requestResult;
303     }
304     int32_t res;
305     if (!reply.ReadInt32(res)) {
306         DLP_LOG_ERROR(LABEL, "Read int32 fail");
307         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
308     }
309     if (!reply.ReadBool(copyable)) {
310         DLP_LOG_ERROR(LABEL, "Read bool fail");
311         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
312     }
313     return res;
314 }
315 
QueryDlpFileAccess(DLPPermissionInfoParcel & permInfoParcel)316 int32_t DlpPermissionProxy::QueryDlpFileAccess(DLPPermissionInfoParcel& permInfoParcel)
317 {
318     MessageParcel data;
319     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
320         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
321         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
322     }
323 
324     MessageParcel reply;
325     MessageOption option(MessageOption::TF_SYNC);
326     sptr<IRemoteObject> remote = Remote();
327     if (remote == nullptr) {
328         DLP_LOG_ERROR(LABEL, "Remote service is null");
329         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
330     }
331     int32_t requestResult = remote->SendRequest(
332         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::QUERY_DLP_FILE_ACCESS), data, reply, option);
333     if (requestResult != DLP_OK) {
334         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
335         return requestResult;
336     }
337     int32_t res;
338     if (!reply.ReadInt32(res)) {
339         DLP_LOG_ERROR(LABEL, "Read int32 fail");
340         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
341     }
342     std::unique_ptr<DLPPermissionInfoParcel> info(reply.ReadParcelable<DLPPermissionInfoParcel>());
343     if (info == nullptr) {
344         DLP_LOG_ERROR(LABEL, "ReadParcelable fail");
345         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
346     }
347     permInfoParcel = *info;
348     return res;
349 }
350 
IsInDlpSandbox(bool & inSandbox)351 int32_t DlpPermissionProxy::IsInDlpSandbox(bool& inSandbox)
352 {
353     MessageParcel data;
354     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
355         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
356         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
357     }
358 
359     MessageParcel reply;
360     MessageOption option(MessageOption::TF_SYNC);
361     sptr<IRemoteObject> remote = Remote();
362     if (remote == nullptr) {
363         DLP_LOG_ERROR(LABEL, "Remote service is null");
364         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
365     }
366     int32_t requestResult = remote->SendRequest(
367         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::IS_IN_DLP_SANDBOX), data, reply, option);
368     if (requestResult != DLP_OK) {
369         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
370         return requestResult;
371     }
372     int32_t res;
373     if (!reply.ReadInt32(res)) {
374         DLP_LOG_ERROR(LABEL, "Read int32 fail");
375         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
376     }
377     if (!reply.ReadBool(inSandbox)) {
378         DLP_LOG_ERROR(LABEL, "Read bool fail");
379         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
380     }
381     return res;
382 }
383 
GetDlpSupportFileType(std::vector<std::string> & supportFileType)384 int32_t DlpPermissionProxy::GetDlpSupportFileType(std::vector<std::string>& supportFileType)
385 {
386     MessageParcel data;
387     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
388         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
389         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
390     }
391 
392     MessageParcel reply;
393     MessageOption option(MessageOption::TF_SYNC);
394     sptr<IRemoteObject> remote = Remote();
395     if (remote == nullptr) {
396         DLP_LOG_ERROR(LABEL, "Remote service is null");
397         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
398     }
399     int32_t requestResult = remote->SendRequest(
400         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_DLP_SUPPORT_FILE_TYPE), data, reply, option);
401     if (requestResult != DLP_OK) {
402         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
403         return requestResult;
404     }
405     int32_t res;
406     if (!reply.ReadInt32(res)) {
407         DLP_LOG_ERROR(LABEL, "Read int32 fail");
408         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
409     }
410     uint32_t listNum;
411     if (!reply.ReadUint32(listNum)) {
412         DLP_LOG_ERROR(LABEL, "Read uint32 fail");
413         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
414     }
415     if (listNum > MAX_SUPPORT_FILE_TYPE_NUM) {
416         DLP_LOG_ERROR(LABEL, "listNum larger than 1024");
417         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
418     }
419     for (uint32_t i = 0; i < listNum; i++) {
420         std::string fileType;
421         if (!reply.ReadString(fileType)) {
422             DLP_LOG_ERROR(LABEL, "Read string fail");
423             return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
424         }
425         supportFileType.emplace_back(fileType);
426     }
427 
428     return res;
429 }
430 
RegisterDlpSandboxChangeCallback(const sptr<IRemoteObject> & callback)431 int32_t DlpPermissionProxy::RegisterDlpSandboxChangeCallback(const sptr<IRemoteObject> &callback)
432 {
433     MessageParcel data;
434     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
435         DLP_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken.");
436         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
437     }
438     if (!data.WriteRemoteObject(callback)) {
439         DLP_LOG_ERROR(LABEL, "Failed to write remote object.");
440         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
441     }
442 
443     MessageParcel reply;
444     MessageOption option(MessageOption::TF_SYNC);
445     sptr<IRemoteObject> remote = Remote();
446     if (remote == nullptr) {
447         DLP_LOG_ERROR(LABEL, "Remote service is null");
448         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
449     }
450     int32_t requestResult = remote->SendRequest(
451         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::REGISTER_DLP_SANDBOX_CHANGE_CALLBACK), data, reply,
452         option);
453     if (requestResult != DLP_OK) {
454         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
455         return DLP_CALLBACK_SA_WORK_ABNORMAL;
456     }
457 
458     int32_t result;
459     if (!reply.ReadInt32(result)) {
460         DLP_LOG_ERROR(LABEL, "ReadInt32 fail");
461         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
462     }
463     return result;
464 }
465 
UnRegisterDlpSandboxChangeCallback(bool & result)466 int32_t DlpPermissionProxy::UnRegisterDlpSandboxChangeCallback(bool &result)
467 {
468     MessageParcel data;
469     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
470         DLP_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken.");
471         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
472     }
473 
474     MessageParcel reply;
475     MessageOption option(MessageOption::TF_SYNC);
476     sptr<IRemoteObject> remote = Remote();
477     if (remote == nullptr) {
478         DLP_LOG_ERROR(LABEL, "Remote service is null");
479         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
480     }
481     int32_t requestResult = remote->SendRequest(
482         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::UNREGISTER_DLP_SANDBOX_CHANGE_CALLBACK), data,
483         reply, option);
484     if (requestResult != DLP_OK) {
485         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
486         return DLP_CALLBACK_SA_WORK_ABNORMAL;
487     }
488 
489     int32_t res;
490     if (!reply.ReadInt32(res)) {
491         DLP_LOG_ERROR(LABEL, "ReadInt32 fail");
492         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
493     }
494     if (!reply.ReadBool(result)) {
495         DLP_LOG_ERROR(LABEL, "Read bool fail");
496         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
497     }
498     return res;
499 }
500 
RegisterOpenDlpFileCallback(const sptr<IRemoteObject> & callback)501 int32_t DlpPermissionProxy::RegisterOpenDlpFileCallback(const sptr<IRemoteObject>& callback)
502 {
503     MessageParcel data;
504     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
505         DLP_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken.");
506         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
507     }
508     if (!data.WriteRemoteObject(callback)) {
509         DLP_LOG_ERROR(LABEL, "Failed to write remote object.");
510         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
511     }
512 
513     MessageParcel reply;
514     MessageOption option(MessageOption::TF_SYNC);
515     sptr<IRemoteObject> remote = Remote();
516     if (remote == nullptr) {
517         DLP_LOG_ERROR(LABEL, "Remote service is null");
518         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
519     }
520     int32_t requestResult = remote->SendRequest(
521         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::REGISTER_OPEN_DLP_FILE_CALLBACK), data, reply,
522         option);
523     if (requestResult != DLP_OK) {
524         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
525         return DLP_CALLBACK_SA_WORK_ABNORMAL;
526     }
527 
528     int32_t result;
529     if (!reply.ReadInt32(result)) {
530         DLP_LOG_ERROR(LABEL, "ReadInt32 fail");
531         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
532     }
533     return result;
534 }
535 
UnRegisterOpenDlpFileCallback(const sptr<IRemoteObject> & callback)536 int32_t DlpPermissionProxy::UnRegisterOpenDlpFileCallback(const sptr<IRemoteObject>& callback)
537 {
538     MessageParcel data;
539     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
540         DLP_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken.");
541         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
542     }
543     if (!data.WriteRemoteObject(callback)) {
544         DLP_LOG_ERROR(LABEL, "Failed to write remote object.");
545         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
546     }
547 
548     MessageParcel reply;
549     MessageOption option(MessageOption::TF_SYNC);
550     sptr<IRemoteObject> remote = Remote();
551     if (remote == nullptr) {
552         DLP_LOG_ERROR(LABEL, "Remote service is null");
553         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
554     }
555     int32_t requestResult = remote->SendRequest(
556         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::UN_REGISTER_OPEN_DLP_FILE_CALLBACK), data,
557         reply, option);
558     if (requestResult != DLP_OK) {
559         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
560         return DLP_CALLBACK_SA_WORK_ABNORMAL;
561     }
562 
563     int32_t res;
564     if (!reply.ReadInt32(res)) {
565         DLP_LOG_ERROR(LABEL, "ReadInt32 fail");
566         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
567     }
568     return res;
569 }
570 
GetDlpGatheringPolicy(bool & isGathering)571 int32_t DlpPermissionProxy::GetDlpGatheringPolicy(bool& isGathering)
572 {
573     MessageParcel data;
574     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
575         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
576         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
577     }
578 
579     MessageParcel reply;
580     MessageOption option(MessageOption::TF_SYNC);
581     sptr<IRemoteObject> remote = Remote();
582     if (remote == nullptr) {
583         DLP_LOG_ERROR(LABEL, "Remote service is null");
584         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
585     }
586     int32_t requestResult = remote->SendRequest(
587         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_DLP_GATHERING_POLICY), data, reply, option);
588     if (requestResult != DLP_OK) {
589         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
590         return requestResult;
591     }
592     int32_t res;
593     if (!reply.ReadInt32(res)) {
594         DLP_LOG_ERROR(LABEL, "Read int32 fail");
595         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
596     }
597     if (!reply.ReadBool(isGathering)) {
598         DLP_LOG_ERROR(LABEL, "Read bool fail");
599         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
600     }
601     return res;
602 }
603 
SetRetentionState(const std::vector<std::string> & docUriVec)604 int32_t DlpPermissionProxy::SetRetentionState(const std::vector<std::string>& docUriVec)
605 {
606     MessageParcel data;
607     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
608         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
609         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
610     }
611 
612     if (!data.WriteStringVector(docUriVec)) {
613         DLP_LOG_ERROR(LABEL, "Write string vector fail");
614         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
615     }
616 
617     MessageParcel reply;
618     MessageOption option(MessageOption::TF_SYNC);
619     sptr<IRemoteObject> remote = Remote();
620     if (remote == nullptr) {
621         DLP_LOG_ERROR(LABEL, "Remote service is null");
622         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
623     }
624     int32_t requestResult = remote->SendRequest(
625         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::SET_RETENTION_STATE), data, reply, option);
626     if (requestResult != DLP_OK) {
627         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
628         return requestResult;
629     }
630     int32_t res;
631     if (!reply.ReadInt32(res)) {
632         DLP_LOG_ERROR(LABEL, "Read int32 fail");
633         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
634     }
635     return res;
636 }
637 
CancelRetentionState(const std::vector<std::string> & docUriVec)638 int32_t DlpPermissionProxy::CancelRetentionState(const std::vector<std::string>& docUriVec)
639 {
640     MessageParcel data;
641     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
642         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
643         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
644     }
645 
646     if (!data.WriteStringVector(docUriVec)) {
647         DLP_LOG_ERROR(LABEL, "Write string vector fail");
648         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
649     }
650 
651     MessageParcel reply;
652     MessageOption option(MessageOption::TF_SYNC);
653     sptr<IRemoteObject> remote = Remote();
654     if (remote == nullptr) {
655         DLP_LOG_ERROR(LABEL, "Remote service is null");
656         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
657     }
658     int32_t requestResult = remote->SendRequest(
659         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::SET_NOT_RETENTION_STATE), data, reply, option);
660     if (requestResult != DLP_OK) {
661         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
662         return requestResult;
663     }
664     int32_t res;
665     if (!reply.ReadInt32(res)) {
666         DLP_LOG_ERROR(LABEL, "Read int32 fail");
667         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
668     }
669     return res;
670 }
671 
GetRetentionSandboxList(const std::string & bundleName,std::vector<RetentionSandBoxInfo> & retentionSandBoxInfoVec)672 int32_t DlpPermissionProxy::GetRetentionSandboxList(const std::string& bundleName,
673     std::vector<RetentionSandBoxInfo>& retentionSandBoxInfoVec)
674 {
675     MessageParcel data;
676     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
677         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
678         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
679     }
680 
681     if (!data.WriteString(bundleName)) {
682         DLP_LOG_ERROR(LABEL, "Write string vector fail");
683         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
684     }
685 
686     MessageParcel reply;
687     MessageOption option(MessageOption::TF_SYNC);
688     sptr<IRemoteObject> remote = Remote();
689     if (remote == nullptr) {
690         DLP_LOG_ERROR(LABEL, "Remote service is null");
691         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
692     }
693     int32_t requestResult = remote->SendRequest(
694         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_RETENTION_SANDBOX_LIST), data, reply, option);
695     if (requestResult != DLP_OK) {
696         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
697         return requestResult;
698     }
699 
700     int32_t res;
701     if (!reply.ReadInt32(res)) {
702         DLP_LOG_ERROR(LABEL, "Read int32 fail");
703         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
704     }
705     uint32_t size;
706     if (!reply.ReadUint32(size)) {
707         DLP_LOG_ERROR(LABEL, "Read uint32 size fail");
708         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
709     }
710     if (size > MAX_RETENTION_SIZE) {
711         DLP_LOG_ERROR(LABEL, "size larger than 1024");
712         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
713     }
714 
715     for (uint32_t i = 0; i < size; i++) {
716         std::unique_ptr<RetentionSandBoxInfo> info(reply.ReadParcelable<RetentionSandBoxInfo>());
717         if (info != nullptr) {
718             retentionSandBoxInfoVec.push_back(*info);
719         }
720     }
721     return res;
722 }
723 
ClearUnreservedSandbox()724 int32_t DlpPermissionProxy::ClearUnreservedSandbox()
725 {
726     MessageParcel data;
727     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
728         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
729         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
730     }
731 
732     MessageParcel reply;
733     MessageOption option(MessageOption::TF_SYNC);
734     sptr<IRemoteObject> remote = Remote();
735     if (remote == nullptr) {
736         DLP_LOG_ERROR(LABEL, "Remote service is null");
737         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
738     }
739     int32_t requestResult = remote->SendRequest(
740         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::CLEAR_UNRESERVED_SANDBOX), data, reply, option);
741     if (requestResult != DLP_OK) {
742         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
743     }
744     return requestResult;
745 }
746 
GetDLPFileVisitRecord(std::vector<VisitedDLPFileInfo> & infoVec)747 int32_t DlpPermissionProxy::GetDLPFileVisitRecord(std::vector<VisitedDLPFileInfo>& infoVec)
748 {
749     MessageParcel data;
750     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
751         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
752         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
753     }
754 
755     MessageParcel reply;
756     MessageOption option(MessageOption::TF_SYNC);
757     sptr<IRemoteObject> remote = Remote();
758     if (remote == nullptr) {
759         DLP_LOG_ERROR(LABEL, "Remote service is null");
760         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
761     }
762     int32_t requestResult = remote->SendRequest(
763         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_VISTI_FILE_RECORD_LIST), data, reply, option);
764     if (requestResult != DLP_OK) {
765         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
766         return requestResult;
767     }
768     int32_t res;
769     if (!reply.ReadInt32(res)) {
770         DLP_LOG_ERROR(LABEL, "Read int32 fail");
771         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
772     }
773     if (res != DLP_OK) {
774         DLP_LOG_ERROR(LABEL, "res!=DLP_OK");
775         return res;
776     }
777     uint32_t listNum;
778     if (!reply.ReadUint32(listNum)) {
779         DLP_LOG_ERROR(LABEL, "Read uint32 fail");
780         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
781     }
782     if (listNum > MAX_FIEL_RECORD_SIZE) {
783         DLP_LOG_ERROR(LABEL, "listNum larger than 1024");
784         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
785     }
786     for (uint32_t i = 0; i < listNum; i++) {
787         VisitedDLPFileInfo visitInfo;
788         std::unique_ptr<VisitedDLPFileInfo> info(reply.ReadParcelable<VisitedDLPFileInfo>());
789         if (info != nullptr) {
790             infoVec.emplace_back(*info);
791         }
792     }
793 
794     return res;
795 }
796 
SetMDMPolicy(const std::vector<std::string> & appIdList)797 int32_t DlpPermissionProxy::SetMDMPolicy(const std::vector<std::string>& appIdList)
798 {
799     MessageParcel data;
800     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
801         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
802         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
803     }
804 
805     if (!data.WriteStringVector(appIdList)) {
806         DLP_LOG_ERROR(LABEL, "Write string vector fail");
807         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
808     }
809 
810     MessageParcel reply;
811     MessageOption option(MessageOption::TF_SYNC);
812     sptr<IRemoteObject> remote = Remote();
813     if (remote == nullptr) {
814         DLP_LOG_ERROR(LABEL, "Remote service is null");
815         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
816     }
817     int32_t requestResult = remote->SendRequest(
818         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::SET_MDM_POLICY), data, reply, option);
819     if (requestResult != DLP_OK) {
820         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
821         return requestResult;
822     }
823     int32_t res;
824     if (!reply.ReadInt32(res)) {
825         DLP_LOG_ERROR(LABEL, "Read int32 fail");
826         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
827     }
828     return res;
829 }
830 
GetMDMPolicy(std::vector<std::string> & appIdList)831 int32_t DlpPermissionProxy::GetMDMPolicy(std::vector<std::string>& appIdList)
832 {
833     MessageParcel data;
834     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
835         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
836         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
837     }
838 
839     MessageParcel reply;
840     MessageOption option(MessageOption::TF_SYNC);
841     sptr<IRemoteObject> remote = Remote();
842     if (remote == nullptr) {
843         DLP_LOG_ERROR(LABEL, "Remote service is null");
844         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
845     }
846     int32_t requestResult = remote->SendRequest(
847         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_MDM_POLICY), data, reply, option);
848     if (requestResult != DLP_OK) {
849         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
850         return requestResult;
851     }
852     int32_t res;
853     if (!reply.ReadInt32(res)) {
854         DLP_LOG_ERROR(LABEL, "Read int32 fail");
855         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
856     }
857     uint32_t listNum;
858     if (!reply.ReadUint32(listNum)) {
859         DLP_LOG_ERROR(LABEL, "Read uint32 fail");
860         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
861     }
862     if (listNum > MAX_APPID_LIST_SIZE) {
863         DLP_LOG_ERROR(LABEL, "appIdList larger than limit");
864         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
865     }
866     if (!reply.ReadStringVector(&appIdList)) {
867         DLP_LOG_ERROR(LABEL, "Read appId List fail");
868         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
869     }
870     return res;
871 }
872 
RemoveMDMPolicy()873 int32_t DlpPermissionProxy::RemoveMDMPolicy()
874 {
875     MessageParcel data;
876     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
877         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
878         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
879     }
880 
881     MessageParcel reply;
882     MessageOption option(MessageOption::TF_SYNC);
883     sptr<IRemoteObject> remote = Remote();
884     if (remote == nullptr) {
885         DLP_LOG_ERROR(LABEL, "Remote service is null");
886         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
887     }
888     int32_t requestResult = remote->SendRequest(
889         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::REMOVE_MDM_POLICY), data, reply, option);
890     if (requestResult != DLP_OK) {
891         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
892         return requestResult;
893     }
894     int32_t res;
895     if (!reply.ReadInt32(res)) {
896         DLP_LOG_ERROR(LABEL, "Read int32 fail");
897         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
898     }
899     return res;
900 }
901 
SetSandboxAppConfig(const std::string & configInfo)902 int32_t DlpPermissionProxy::SetSandboxAppConfig(const std::string& configInfo)
903 {
904     MessageParcel data;
905     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
906         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
907         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
908     }
909     if (!data.WriteString(configInfo)) {
910         DLP_LOG_ERROR(LABEL, "Write string fail");
911         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
912     }
913     MessageParcel reply;
914     MessageOption option(MessageOption::TF_SYNC);
915     sptr<IRemoteObject> remote = Remote();
916     if (remote == nullptr) {
917         DLP_LOG_ERROR(LABEL, "Remote service is null");
918         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
919     }
920     int32_t requestResult = remote->SendRequest(
921         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::SET_SANDBOX_APP_CONFIG), data, reply, option);
922     if (requestResult != DLP_OK) {
923         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
924         return requestResult;
925     }
926     if (!reply.ReadInt32(requestResult)) {
927         DLP_LOG_ERROR(LABEL, "Read int32 fail");
928         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
929     }
930     return requestResult;
931 }
932 
CleanSandboxAppConfig()933 int32_t DlpPermissionProxy::CleanSandboxAppConfig()
934 {
935     MessageParcel data;
936     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
937         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
938         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
939     }
940     MessageParcel reply;
941     MessageOption option(MessageOption::TF_SYNC);
942     sptr<IRemoteObject> remote = Remote();
943     if (remote == nullptr) {
944         DLP_LOG_ERROR(LABEL, "Remote service is null");
945         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
946     }
947     int32_t requestResult = remote->SendRequest(
948         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::CLEAN_SANDBOX_APP_CONFIG), data, reply, option);
949     if (requestResult != DLP_OK) {
950         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
951         return requestResult;
952     }
953     if (!reply.ReadInt32(requestResult)) {
954         DLP_LOG_ERROR(LABEL, "Read int32 fail");
955         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
956     }
957     return requestResult;
958 }
959 
GetSandboxAppConfig(std::string & configInfo)960 int32_t DlpPermissionProxy::GetSandboxAppConfig(std::string& configInfo)
961 {
962     MessageParcel data;
963     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
964         DLP_LOG_ERROR(LABEL, "Write descriptor fail");
965         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
966     }
967     MessageParcel reply;
968     MessageOption option(MessageOption::TF_SYNC);
969     sptr<IRemoteObject> remote = Remote();
970     if (remote == nullptr) {
971         DLP_LOG_ERROR(LABEL, "Remote service is null");
972         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
973     }
974     int32_t requestResult = remote->SendRequest(
975         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_SANDBOX_APP_CONFIG), data, reply, option);
976     if (requestResult != DLP_OK) {
977         DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
978         return requestResult;
979     }
980     if (!reply.ReadInt32(requestResult)) {
981         DLP_LOG_ERROR(LABEL, "Read int32 fail");
982         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
983     }
984     if (requestResult == DLP_KV_GET_DATA_NOT_FOUND) {
985         return DLP_OK;
986     }
987     if (requestResult != DLP_OK) {
988         return requestResult;
989     }
990     if (!reply.ReadString(configInfo)) {
991         DLP_LOG_ERROR(LABEL, "Read string fail");
992         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
993     }
994     return requestResult;
995 }
996 
IsDLPFeatureProvided(bool & isProvideDLPFeature)997 int32_t DlpPermissionProxy::IsDLPFeatureProvided(bool& isProvideDLPFeature)
998 {
999     MessageParcel data;
1000     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
1001         DLP_LOG_ERROR(LABEL, "Write descriptor failed.");
1002         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
1003     }
1004     MessageParcel reply;
1005     MessageOption option(MessageOption::TF_SYNC);
1006     sptr<IRemoteObject> remote = Remote();
1007     if (remote == nullptr) {
1008         DLP_LOG_ERROR(LABEL, "Remote service is null.");
1009         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
1010     }
1011     int32_t requestResult = remote->SendRequest(
1012         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::IS_DLP_FEATURE_PROVIDED), data, reply, option);
1013     if (requestResult != DLP_OK) {
1014         DLP_LOG_ERROR(LABEL, "Request fail, result=%{public}d.", requestResult);
1015         return requestResult;
1016     }
1017     if (!reply.ReadBool(isProvideDLPFeature)) {
1018         DLP_LOG_ERROR(LABEL, "Read isProvideDLPFeature failed.");
1019         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
1020     }
1021     return requestResult;
1022 }
1023 
SetReadFlag(uint32_t uid)1024 int32_t DlpPermissionProxy::SetReadFlag(uint32_t uid)
1025 {
1026     MessageParcel data;
1027     if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
1028         DLP_LOG_ERROR(LABEL, "Write descriptor fail.");
1029         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
1030     }
1031     if (!data.WriteUint32(uid)) {
1032         DLP_LOG_ERROR(LABEL, "Write uid fail.");
1033         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
1034     }
1035     MessageParcel reply;
1036     MessageOption option(MessageOption::TF_SYNC);
1037     sptr<IRemoteObject> remote = Remote();
1038     if (remote == nullptr) {
1039         DLP_LOG_ERROR(LABEL, "Remote service is null.");
1040         return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
1041     }
1042     int32_t requestResult = remote->SendRequest(
1043         static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::SET_READ_FLAG), data, reply, option);
1044     if (requestResult != DLP_OK) {
1045         DLP_LOG_ERROR(LABEL, "Request fail, requestResult=%{public}d.", requestResult);
1046         return requestResult;
1047     }
1048     if (!reply.ReadInt32(requestResult)) {
1049         DLP_LOG_ERROR(LABEL, "Read requestResult fail.");
1050         return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
1051     }
1052     return requestResult;
1053 }
1054 }  // namespace DlpPermission
1055 }  // namespace Security
1056 }  // namespace OHOS
1057