1 /*
2 * Copyright (c) 2023 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 }
31
DlpPermissionProxy(const sptr<IRemoteObject> & impl)32 DlpPermissionProxy::DlpPermissionProxy(const sptr<IRemoteObject>& impl) : IRemoteProxy<IDlpPermissionService>(impl)
33 {}
34
~DlpPermissionProxy()35 DlpPermissionProxy::~DlpPermissionProxy()
36 {}
37
GenerateDlpCertificate(const sptr<DlpPolicyParcel> & policyParcel,sptr<IDlpPermissionCallback> & callback)38 int32_t DlpPermissionProxy::GenerateDlpCertificate(
39 const sptr<DlpPolicyParcel>& policyParcel, sptr<IDlpPermissionCallback>& callback)
40 {
41 MessageParcel data;
42 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
43 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
44 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
45 }
46
47 if (!data.WriteParcelable(policyParcel)) {
48 DLP_LOG_ERROR(LABEL, "Write parcel fail");
49 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
50 }
51
52 if (!data.WriteRemoteObject(callback->AsObject())) {
53 DLP_LOG_ERROR(LABEL, "Write object fail");
54 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
55 }
56
57 MessageParcel reply;
58 MessageOption option(MessageOption::TF_SYNC);
59 sptr<IRemoteObject> remote = Remote();
60 if (remote == nullptr) {
61 DLP_LOG_ERROR(LABEL, "Remote service is null");
62 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
63 }
64 int32_t requestResult = remote->SendRequest(
65 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GENERATE_DLP_CERTIFICATE), data, reply, option);
66 if (requestResult != DLP_OK) {
67 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
68 return requestResult;
69 }
70 int32_t res;
71 if (!reply.ReadInt32(res)) {
72 DLP_LOG_ERROR(LABEL, "Read int32 fail");
73 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
74 }
75 return res;
76 }
77
ParseDlpCertificate(const std::vector<uint8_t> & cert,uint32_t flag,sptr<IDlpPermissionCallback> & callback)78 int32_t DlpPermissionProxy::ParseDlpCertificate(
79 const std::vector<uint8_t>& cert, uint32_t flag, sptr<IDlpPermissionCallback>& callback)
80 {
81 MessageParcel data;
82 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
83 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
84 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
85 }
86
87 if (!data.WriteUint32(flag)) {
88 DLP_LOG_ERROR(LABEL, "Write uint32 flag fail");
89 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
90 }
91
92 if (!data.WriteUInt8Vector(cert)) {
93 DLP_LOG_ERROR(LABEL, "Write uint8 vector fail");
94 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
95 }
96
97 if (!data.WriteRemoteObject(callback->AsObject())) {
98 DLP_LOG_ERROR(LABEL, "Write object fail");
99 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
100 }
101
102 MessageParcel reply;
103 MessageOption option(MessageOption::TF_SYNC);
104 sptr<IRemoteObject> remote = Remote();
105 if (remote == nullptr) {
106 DLP_LOG_ERROR(LABEL, "Remote service is null");
107 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
108 }
109
110 int32_t requestResult = remote->SendRequest(
111 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::PARSE_DLP_CERTIFICATE), data, reply, option);
112 if (requestResult != DLP_OK) {
113 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
114 return requestResult;
115 }
116
117 int32_t res;
118 if (!reply.ReadInt32(res)) {
119 DLP_LOG_ERROR(LABEL, "Read int32 fail");
120 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
121 }
122 return res;
123 }
124
InstallDlpSandbox(const std::string & bundleName,DLPFileAccess dlpFileAccess,int32_t userId,SandboxInfo & sandboxInfo,const std::string & uri)125 int32_t DlpPermissionProxy::InstallDlpSandbox(const std::string& bundleName, DLPFileAccess dlpFileAccess,
126 int32_t userId, SandboxInfo& sandboxInfo, const std::string& uri)
127 {
128 MessageParcel data;
129 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
130 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
131 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
132 }
133
134 if (!data.WriteString(bundleName)) {
135 DLP_LOG_ERROR(LABEL, "Write string fail");
136 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
137 }
138
139 if (!data.WriteUint32(dlpFileAccess)) {
140 DLP_LOG_ERROR(LABEL, "Write uint32 fail");
141 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
142 }
143
144 if (!data.WriteInt32(userId)) {
145 DLP_LOG_ERROR(LABEL, "Write int32 fail");
146 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
147 }
148
149 if (!data.WriteString(uri)) {
150 DLP_LOG_ERROR(LABEL, "Write string fail");
151 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
152 }
153
154 MessageParcel reply;
155 MessageOption option(MessageOption::TF_SYNC);
156 sptr<IRemoteObject> remote = Remote();
157 if (remote == nullptr) {
158 DLP_LOG_ERROR(LABEL, "Remote service is null");
159 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
160 }
161 int32_t requestResult = remote->SendRequest(
162 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::INSTALL_DLP_SANDBOX), data, reply, option);
163 if (requestResult != DLP_OK) {
164 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
165 return requestResult;
166 }
167 int32_t res;
168 if (!reply.ReadInt32(res)) {
169 DLP_LOG_ERROR(LABEL, "Read int32 fail");
170 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
171 }
172
173 if (!reply.ReadInt32(sandboxInfo.appIndex)) {
174 DLP_LOG_ERROR(LABEL, "Read int32 fail");
175 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
176 }
177
178 if (!reply.ReadUint32(sandboxInfo.tokenId)) {
179 DLP_LOG_ERROR(LABEL, "Read uint32 fail");
180 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
181 }
182 return res;
183 }
184
UninstallDlpSandbox(const std::string & bundleName,int32_t appIndex,int32_t userId)185 int32_t DlpPermissionProxy::UninstallDlpSandbox(const std::string& bundleName, int32_t appIndex, int32_t userId)
186 {
187 MessageParcel data;
188 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
189 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
190 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
191 }
192
193 if (!data.WriteString(bundleName)) {
194 DLP_LOG_ERROR(LABEL, "Write string fail");
195 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
196 }
197
198 if (!data.WriteInt32(appIndex)) {
199 DLP_LOG_ERROR(LABEL, "Write int32 fail");
200 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
201 }
202
203 if (!data.WriteInt32(userId)) {
204 DLP_LOG_ERROR(LABEL, "Write int32 fail");
205 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
206 }
207
208 MessageParcel reply;
209 MessageOption option(MessageOption::TF_SYNC);
210 sptr<IRemoteObject> remote = Remote();
211 if (remote == nullptr) {
212 DLP_LOG_ERROR(LABEL, "Remote service is null");
213 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
214 }
215 int32_t requestResult = remote->SendRequest(
216 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::UNINSTALL_DLP_SANDBOX), data, reply, option);
217 if (requestResult != DLP_OK) {
218 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
219 return requestResult;
220 }
221 int32_t res;
222 if (!reply.ReadInt32(res)) {
223 DLP_LOG_ERROR(LABEL, "Read int32 fail");
224 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
225 }
226 return res;
227 }
228
GetSandboxExternalAuthorization(int sandboxUid,const AAFwk::Want & want,SandBoxExternalAuthorType & authType)229 int32_t DlpPermissionProxy::GetSandboxExternalAuthorization(int sandboxUid,
230 const AAFwk::Want& want, SandBoxExternalAuthorType& authType)
231 {
232 MessageParcel data;
233 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
234 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
235 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
236 }
237
238 if (!data.WriteInt32(sandboxUid)) {
239 DLP_LOG_ERROR(LABEL, "Write int32 fail");
240 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
241 }
242
243 if (!data.WriteParcelable(&want)) {
244 DLP_LOG_ERROR(LABEL, "Write want fail");
245 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
246 }
247
248 MessageParcel reply;
249 MessageOption option(MessageOption::TF_SYNC);
250 sptr<IRemoteObject> remote = Remote();
251 if (remote == nullptr) {
252 DLP_LOG_ERROR(LABEL, "Remote service is null");
253 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
254 }
255 int32_t requestResult = remote->SendRequest(
256 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_SANDBOX_EXTERNAL_AUTH), data, reply, option);
257 if (requestResult != DLP_OK) {
258 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
259 return requestResult;
260 }
261 int32_t res;
262 if (!reply.ReadInt32(res)) {
263 DLP_LOG_ERROR(LABEL, "Read int32 fail");
264 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
265 }
266 if (res < DENY_START_ABILITY || res > ALLOW_START_ABILITY) {
267 DLP_LOG_ERROR(LABEL, "Read authType result value error");
268 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
269 }
270 authType = static_cast<SandBoxExternalAuthorType>(res);
271 return DLP_OK;
272 }
273
QueryDlpFileCopyableByTokenId(bool & copyable,uint32_t tokenId)274 int32_t DlpPermissionProxy::QueryDlpFileCopyableByTokenId(bool& copyable, uint32_t tokenId)
275 {
276 MessageParcel data;
277 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
278 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
279 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
280 }
281
282 if (!data.WriteUint32(tokenId)) {
283 DLP_LOG_ERROR(LABEL, "Write uint32 fail");
284 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
285 }
286
287 MessageParcel reply;
288 MessageOption option(MessageOption::TF_SYNC);
289 sptr<IRemoteObject> remote = Remote();
290 if (remote == nullptr) {
291 DLP_LOG_ERROR(LABEL, "Remote service is null");
292 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
293 }
294 int32_t requestResult = remote->SendRequest(
295 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::QUERY_DLP_FILE_ACCESS_BY_TOKEN_ID), data, reply,
296 option);
297 if (requestResult != DLP_OK) {
298 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
299 return requestResult;
300 }
301 int32_t res;
302 if (!reply.ReadInt32(res)) {
303 DLP_LOG_ERROR(LABEL, "Read int32 fail");
304 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
305 }
306 if (!reply.ReadBool(copyable)) {
307 DLP_LOG_ERROR(LABEL, "Read bool fail");
308 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
309 }
310 return res;
311 }
312
QueryDlpFileAccess(DLPPermissionInfoParcel & permInfoParcel)313 int32_t DlpPermissionProxy::QueryDlpFileAccess(DLPPermissionInfoParcel& permInfoParcel)
314 {
315 MessageParcel data;
316 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
317 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
318 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
319 }
320
321 MessageParcel reply;
322 MessageOption option(MessageOption::TF_SYNC);
323 sptr<IRemoteObject> remote = Remote();
324 if (remote == nullptr) {
325 DLP_LOG_ERROR(LABEL, "Remote service is null");
326 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
327 }
328 int32_t requestResult = remote->SendRequest(
329 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::QUERY_DLP_FILE_ACCESS), data, reply, option);
330 if (requestResult != DLP_OK) {
331 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
332 return requestResult;
333 }
334 int32_t res;
335 if (!reply.ReadInt32(res)) {
336 DLP_LOG_ERROR(LABEL, "Read int32 fail");
337 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
338 }
339 std::unique_ptr<DLPPermissionInfoParcel> info(reply.ReadParcelable<DLPPermissionInfoParcel>());
340 if (info == nullptr) {
341 DLP_LOG_ERROR(LABEL, "ReadParcelable fail");
342 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
343 }
344 permInfoParcel = *info;
345 return res;
346 }
347
IsInDlpSandbox(bool & inSandbox)348 int32_t DlpPermissionProxy::IsInDlpSandbox(bool& inSandbox)
349 {
350 MessageParcel data;
351 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
352 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
353 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
354 }
355
356 MessageParcel reply;
357 MessageOption option(MessageOption::TF_SYNC);
358 sptr<IRemoteObject> remote = Remote();
359 if (remote == nullptr) {
360 DLP_LOG_ERROR(LABEL, "Remote service is null");
361 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
362 }
363 int32_t requestResult = remote->SendRequest(
364 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::IS_IN_DLP_SANDBOX), data, reply, option);
365 if (requestResult != DLP_OK) {
366 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
367 return requestResult;
368 }
369 int32_t res;
370 if (!reply.ReadInt32(res)) {
371 DLP_LOG_ERROR(LABEL, "Read int32 fail");
372 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
373 }
374 if (!reply.ReadBool(inSandbox)) {
375 DLP_LOG_ERROR(LABEL, "Read bool fail");
376 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
377 }
378 return res;
379 }
380
GetDlpSupportFileType(std::vector<std::string> & supportFileType)381 int32_t DlpPermissionProxy::GetDlpSupportFileType(std::vector<std::string>& supportFileType)
382 {
383 MessageParcel data;
384 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
385 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
386 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
387 }
388
389 MessageParcel reply;
390 MessageOption option(MessageOption::TF_SYNC);
391 sptr<IRemoteObject> remote = Remote();
392 if (remote == nullptr) {
393 DLP_LOG_ERROR(LABEL, "Remote service is null");
394 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
395 }
396 int32_t requestResult = remote->SendRequest(
397 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_DLP_SUPPORT_FILE_TYPE), data, reply, option);
398 if (requestResult != DLP_OK) {
399 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
400 return requestResult;
401 }
402 int32_t res;
403 if (!reply.ReadInt32(res)) {
404 DLP_LOG_ERROR(LABEL, "Read int32 fail");
405 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
406 }
407 uint32_t listNum;
408 if (!reply.ReadUint32(listNum)) {
409 DLP_LOG_ERROR(LABEL, "Read uint32 fail");
410 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
411 }
412 if (listNum > MAX_SUPPORT_FILE_TYPE_NUM) {
413 DLP_LOG_ERROR(LABEL, "listNum larger than 1024");
414 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
415 }
416 for (uint32_t i = 0; i < listNum; i++) {
417 std::string fileType;
418 if (!reply.ReadString(fileType)) {
419 DLP_LOG_ERROR(LABEL, "Read string fail");
420 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
421 }
422 supportFileType.emplace_back(fileType);
423 }
424
425 return res;
426 }
427
RegisterDlpSandboxChangeCallback(const sptr<IRemoteObject> & callback)428 int32_t DlpPermissionProxy::RegisterDlpSandboxChangeCallback(const sptr<IRemoteObject> &callback)
429 {
430 MessageParcel data;
431 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
432 DLP_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken.");
433 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
434 }
435 if (!data.WriteRemoteObject(callback)) {
436 DLP_LOG_ERROR(LABEL, "Failed to write remote object.");
437 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
438 }
439
440 MessageParcel reply;
441 MessageOption option(MessageOption::TF_SYNC);
442 sptr<IRemoteObject> remote = Remote();
443 if (remote == nullptr) {
444 DLP_LOG_ERROR(LABEL, "Remote service is null");
445 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
446 }
447 int32_t requestResult = remote->SendRequest(
448 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::REGISTER_DLP_SANDBOX_CHANGE_CALLBACK), data, reply,
449 option);
450 if (requestResult != DLP_OK) {
451 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
452 return DLP_CALLBACK_SA_WORK_ABNORMAL;
453 }
454
455 int32_t result;
456 if (!reply.ReadInt32(result)) {
457 DLP_LOG_ERROR(LABEL, "ReadInt32 fail");
458 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
459 }
460 return result;
461 }
462
UnRegisterDlpSandboxChangeCallback(bool & result)463 int32_t DlpPermissionProxy::UnRegisterDlpSandboxChangeCallback(bool &result)
464 {
465 MessageParcel data;
466 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
467 DLP_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken.");
468 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
469 }
470
471 MessageParcel reply;
472 MessageOption option(MessageOption::TF_SYNC);
473 sptr<IRemoteObject> remote = Remote();
474 if (remote == nullptr) {
475 DLP_LOG_ERROR(LABEL, "Remote service is null");
476 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
477 }
478 int32_t requestResult = remote->SendRequest(
479 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::UNREGISTER_DLP_SANDBOX_CHANGE_CALLBACK), data,
480 reply, option);
481 if (requestResult != DLP_OK) {
482 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
483 return DLP_CALLBACK_SA_WORK_ABNORMAL;
484 }
485
486 int32_t res;
487 if (!reply.ReadInt32(res)) {
488 DLP_LOG_ERROR(LABEL, "ReadInt32 fail");
489 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
490 }
491 if (!reply.ReadBool(result)) {
492 DLP_LOG_ERROR(LABEL, "Read bool fail");
493 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
494 }
495 return res;
496 }
497
RegisterOpenDlpFileCallback(const sptr<IRemoteObject> & callback)498 int32_t DlpPermissionProxy::RegisterOpenDlpFileCallback(const sptr<IRemoteObject>& callback)
499 {
500 MessageParcel data;
501 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
502 DLP_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken.");
503 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
504 }
505 if (!data.WriteRemoteObject(callback)) {
506 DLP_LOG_ERROR(LABEL, "Failed to write remote object.");
507 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
508 }
509
510 MessageParcel reply;
511 MessageOption option(MessageOption::TF_SYNC);
512 sptr<IRemoteObject> remote = Remote();
513 if (remote == nullptr) {
514 DLP_LOG_ERROR(LABEL, "Remote service is null");
515 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
516 }
517 int32_t requestResult = remote->SendRequest(
518 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::REGISTER_OPEN_DLP_FILE_CALLBACK), data, reply,
519 option);
520 if (requestResult != DLP_OK) {
521 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
522 return DLP_CALLBACK_SA_WORK_ABNORMAL;
523 }
524
525 int32_t result;
526 if (!reply.ReadInt32(result)) {
527 DLP_LOG_ERROR(LABEL, "ReadInt32 fail");
528 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
529 }
530 return result;
531 }
532
UnRegisterOpenDlpFileCallback(const sptr<IRemoteObject> & callback)533 int32_t DlpPermissionProxy::UnRegisterOpenDlpFileCallback(const sptr<IRemoteObject>& callback)
534 {
535 MessageParcel data;
536 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
537 DLP_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken.");
538 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
539 }
540 if (!data.WriteRemoteObject(callback)) {
541 DLP_LOG_ERROR(LABEL, "Failed to write remote object.");
542 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
543 }
544
545 MessageParcel reply;
546 MessageOption option(MessageOption::TF_SYNC);
547 sptr<IRemoteObject> remote = Remote();
548 if (remote == nullptr) {
549 DLP_LOG_ERROR(LABEL, "Remote service is null");
550 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
551 }
552 int32_t requestResult = remote->SendRequest(
553 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::UN_REGISTER_OPEN_DLP_FILE_CALLBACK), data,
554 reply, option);
555 if (requestResult != DLP_OK) {
556 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
557 return DLP_CALLBACK_SA_WORK_ABNORMAL;
558 }
559
560 int32_t res;
561 if (!reply.ReadInt32(res)) {
562 DLP_LOG_ERROR(LABEL, "ReadInt32 fail");
563 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
564 }
565 return res;
566 }
567
GetDlpGatheringPolicy(bool & isGathering)568 int32_t DlpPermissionProxy::GetDlpGatheringPolicy(bool& isGathering)
569 {
570 MessageParcel data;
571 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
572 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
573 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
574 }
575
576 MessageParcel reply;
577 MessageOption option(MessageOption::TF_SYNC);
578 sptr<IRemoteObject> remote = Remote();
579 if (remote == nullptr) {
580 DLP_LOG_ERROR(LABEL, "Remote service is null");
581 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
582 }
583 int32_t requestResult = remote->SendRequest(
584 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_DLP_GATHERING_POLICY), data, reply, option);
585 if (requestResult != DLP_OK) {
586 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
587 return requestResult;
588 }
589 int32_t res;
590 if (!reply.ReadInt32(res)) {
591 DLP_LOG_ERROR(LABEL, "Read int32 fail");
592 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
593 }
594 if (!reply.ReadBool(isGathering)) {
595 DLP_LOG_ERROR(LABEL, "Read bool fail");
596 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
597 }
598 return res;
599 }
600
SetRetentionState(const std::vector<std::string> & docUriVec)601 int32_t DlpPermissionProxy::SetRetentionState(const std::vector<std::string>& docUriVec)
602 {
603 MessageParcel data;
604 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
605 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
606 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
607 }
608
609 if (!data.WriteStringVector(docUriVec)) {
610 DLP_LOG_ERROR(LABEL, "Write string vector fail");
611 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
612 }
613
614 MessageParcel reply;
615 MessageOption option(MessageOption::TF_SYNC);
616 sptr<IRemoteObject> remote = Remote();
617 if (remote == nullptr) {
618 DLP_LOG_ERROR(LABEL, "Remote service is null");
619 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
620 }
621 int32_t requestResult = remote->SendRequest(
622 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::SET_RETENTION_STATE), data, reply, option);
623 if (requestResult != DLP_OK) {
624 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
625 return requestResult;
626 }
627 int32_t res;
628 if (!reply.ReadInt32(res)) {
629 DLP_LOG_ERROR(LABEL, "Read int32 fail");
630 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
631 }
632 return res;
633 }
634
CancelRetentionState(const std::vector<std::string> & docUriVec)635 int32_t DlpPermissionProxy::CancelRetentionState(const std::vector<std::string>& docUriVec)
636 {
637 MessageParcel data;
638 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
639 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
640 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
641 }
642
643 if (!data.WriteStringVector(docUriVec)) {
644 DLP_LOG_ERROR(LABEL, "Write string vector fail");
645 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
646 }
647
648 MessageParcel reply;
649 MessageOption option(MessageOption::TF_SYNC);
650 sptr<IRemoteObject> remote = Remote();
651 if (remote == nullptr) {
652 DLP_LOG_ERROR(LABEL, "Remote service is null");
653 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
654 }
655 int32_t requestResult = remote->SendRequest(
656 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::SET_NOT_RETENTION_STATE), data, reply, option);
657 if (requestResult != DLP_OK) {
658 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
659 return requestResult;
660 }
661 int32_t res;
662 if (!reply.ReadInt32(res)) {
663 DLP_LOG_ERROR(LABEL, "Read int32 fail");
664 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
665 }
666 return res;
667 }
668
GetRetentionSandboxList(const std::string & bundleName,std::vector<RetentionSandBoxInfo> & retentionSandBoxInfoVec)669 int32_t DlpPermissionProxy::GetRetentionSandboxList(const std::string& bundleName,
670 std::vector<RetentionSandBoxInfo>& retentionSandBoxInfoVec)
671 {
672 MessageParcel data;
673 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
674 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
675 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
676 }
677
678 if (!data.WriteString(bundleName)) {
679 DLP_LOG_ERROR(LABEL, "Write string vector fail");
680 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
681 }
682
683 MessageParcel reply;
684 MessageOption option(MessageOption::TF_SYNC);
685 sptr<IRemoteObject> remote = Remote();
686 if (remote == nullptr) {
687 DLP_LOG_ERROR(LABEL, "Remote service is null");
688 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
689 }
690 int32_t requestResult = remote->SendRequest(
691 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_RETETNTION_SANDBOX_LIST), data, reply, option);
692 if (requestResult != DLP_OK) {
693 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
694 return requestResult;
695 }
696
697 int32_t res;
698 if (!reply.ReadInt32(res)) {
699 DLP_LOG_ERROR(LABEL, "Read int32 fail");
700 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
701 }
702 uint32_t size;
703 if (!reply.ReadUint32(size)) {
704 DLP_LOG_ERROR(LABEL, "Read uint32 size fail");
705 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
706 }
707 if (size > MAX_RETENTION_SIZE) {
708 DLP_LOG_ERROR(LABEL, "size larger than 1024");
709 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
710 }
711
712 for (uint32_t i = 0; i < size; i++) {
713 std::unique_ptr<RetentionSandBoxInfo> info(reply.ReadParcelable<RetentionSandBoxInfo>());
714 if (info != nullptr) {
715 retentionSandBoxInfoVec.push_back(*info);
716 }
717 }
718 return res;
719 }
720
ClearUnreservedSandbox()721 int32_t DlpPermissionProxy::ClearUnreservedSandbox()
722 {
723 MessageParcel data;
724 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
725 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
726 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
727 }
728
729 MessageParcel reply;
730 MessageOption option(MessageOption::TF_SYNC);
731 sptr<IRemoteObject> remote = Remote();
732 if (remote == nullptr) {
733 DLP_LOG_ERROR(LABEL, "Remote service is null");
734 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
735 }
736 int32_t requestResult = remote->SendRequest(
737 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::CLEAR_UNRESERVED_SANDBOX), data, reply, option);
738 if (requestResult != DLP_OK) {
739 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
740 }
741 return requestResult;
742 }
743
GetDLPFileVisitRecord(std::vector<VisitedDLPFileInfo> & infoVec)744 int32_t DlpPermissionProxy::GetDLPFileVisitRecord(std::vector<VisitedDLPFileInfo>& infoVec)
745 {
746 MessageParcel data;
747 if (!data.WriteInterfaceToken(DlpPermissionProxy::GetDescriptor())) {
748 DLP_LOG_ERROR(LABEL, "Write descriptor fail");
749 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
750 }
751
752 MessageParcel reply;
753 MessageOption option(MessageOption::TF_SYNC);
754 sptr<IRemoteObject> remote = Remote();
755 if (remote == nullptr) {
756 DLP_LOG_ERROR(LABEL, "Remote service is null");
757 return DLP_SERVICE_ERROR_SERVICE_NOT_EXIST;
758 }
759 int32_t requestResult = remote->SendRequest(
760 static_cast<uint32_t>(DlpPermissionServiceInterfaceCode::GET_VISTI_FILE_RECORD_LIST), data, reply, option);
761 if (requestResult != DLP_OK) {
762 DLP_LOG_ERROR(LABEL, "Request fail, result: %{public}d", requestResult);
763 return requestResult;
764 }
765 int32_t res;
766 if (!reply.ReadInt32(res)) {
767 DLP_LOG_ERROR(LABEL, "Read int32 fail");
768 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
769 }
770 if (res != DLP_OK) {
771 DLP_LOG_ERROR(LABEL, "res!=DLP_OK");
772 return res;
773 }
774 uint32_t listNum;
775 if (!reply.ReadUint32(listNum)) {
776 DLP_LOG_ERROR(LABEL, "Read uint32 fail");
777 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
778 }
779 if (listNum > MAX_FIEL_RECORD_SIZE) {
780 DLP_LOG_ERROR(LABEL, "listNum larger than 1024");
781 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
782 }
783 for (uint32_t i = 0; i < listNum; i++) {
784 VisitedDLPFileInfo visitInfo;
785 std::unique_ptr<VisitedDLPFileInfo> info(reply.ReadParcelable<VisitedDLPFileInfo>());
786 if (info != nullptr) {
787 infoVec.emplace_back(*info);
788 }
789 }
790
791 return res;
792 }
793 } // namespace DlpPermission
794 } // namespace Security
795 } // namespace OHOS
796