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