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_async_stub.h"
17 #include "dlp_permission.h"
18 #include "dlp_permission_log.h"
19 #include "dlp_permission_service_ipc_interface_code.h"
20 #include "dlp_policy_parcel.h"
21 #include "ipc_skeleton.h"
22 #include "permission_policy.h"
23
24 namespace OHOS {
25 namespace Security {
26 namespace DlpPermission {
27 namespace {
28 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
29 LOG_CORE, SECURITY_DOMAIN_DLP_PERMISSION, "DlpPermissionAsyncStub"};
30 }
DlpPermissionAsyncStub(std::shared_ptr<GenerateDlpCertificateCallback> & impl)31 DlpPermissionAsyncStub::DlpPermissionAsyncStub(std::shared_ptr<GenerateDlpCertificateCallback>& impl)
32 : generateDlpCertificateCallback_(impl)
33 {}
34
DlpPermissionAsyncStub(std::shared_ptr<ParseDlpCertificateCallback> & impl)35 DlpPermissionAsyncStub::DlpPermissionAsyncStub(std::shared_ptr<ParseDlpCertificateCallback>& impl)
36 : parseDlpCertificateCallback_(impl)
37 {}
38
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)39 int32_t DlpPermissionAsyncStub::OnRemoteRequest(
40 uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
41 {
42 DLP_LOG_INFO(LABEL, "Called, code: 0x%{public}x, pid: %{public}d, uid: %{public}d", code,
43 IPCSkeleton::GetCallingRealPid(), IPCSkeleton::GetCallingUid());
44
45 std::u16string descripter = DlpPermissionAsyncStub::GetDescriptor();
46 std::u16string remoteDescripter = data.ReadInterfaceToken();
47 if (descripter != remoteDescripter) {
48 DLP_LOG_ERROR(LABEL, "OnRemoteRequest failed, descriptor is not matched");
49 return DLP_SERVICE_ERROR_IPC_REQUEST_FAIL;
50 }
51
52 switch (code) {
53 case static_cast<int32_t>(DlpPermissionCallbackInterfaceCode::ON_GENERATE_DLP_CERTIFICATE):
54 return OnGenerateDlpCertificateStub(data, reply);
55 case static_cast<int32_t>(DlpPermissionCallbackInterfaceCode::ON_PARSE_DLP_CERTIFICATE):
56 return OnParseDlpCertificateStub(data, reply);
57 default:
58 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
59 }
60 }
61
OnGenerateDlpCertificateStub(MessageParcel & data,MessageParcel & reply)62 int32_t DlpPermissionAsyncStub::OnGenerateDlpCertificateStub(MessageParcel& data, MessageParcel& reply)
63 {
64 std::vector<uint8_t> cert;
65 int32_t result;
66
67 if (!data.ReadInt32(result)) {
68 DLP_LOG_ERROR(LABEL, "Read int32 fail");
69 this->OnGenerateDlpCertificate(DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL, {});
70 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
71 }
72 if (result != DLP_OK) {
73 this->OnGenerateDlpCertificate(result, {});
74 return DLP_OK;
75 }
76 if (!data.ReadUInt8Vector(&cert)) {
77 DLP_LOG_ERROR(LABEL, "Read int8 vector fail");
78 this->OnGenerateDlpCertificate(DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL, {});
79 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
80 }
81 this->OnGenerateDlpCertificate(result, cert);
82 return DLP_OK;
83 }
84
OnGenerateDlpCertificate(int32_t result,const std::vector<uint8_t> & cert)85 void DlpPermissionAsyncStub::OnGenerateDlpCertificate(int32_t result, const std::vector<uint8_t>& cert)
86 {
87 if (generateDlpCertificateCallback_ == nullptr) {
88 DLP_LOG_ERROR(LABEL, "Callback is null");
89 return;
90 }
91
92 generateDlpCertificateCallback_->OnGenerateDlpCertificate(result, cert);
93 }
94
OnParseDlpCertificateStub(MessageParcel & data,MessageParcel & reply)95 int32_t DlpPermissionAsyncStub::OnParseDlpCertificateStub(MessageParcel& data, MessageParcel& reply)
96 {
97 int32_t result;
98 if (!data.ReadInt32(result)) {
99 DLP_LOG_ERROR(LABEL, "Read int32 fail");
100 PermissionPolicy policyNull;
101 this->OnParseDlpCertificate(DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL, policyNull, {});
102 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
103 }
104 if (result != DLP_OK) {
105 PermissionPolicy policyNull;
106 this->OnParseDlpCertificate(result, policyNull, {});
107 return DLP_OK;
108 }
109 sptr<DlpPolicyParcel> policyParcel = data.ReadParcelable<DlpPolicyParcel>();
110 if (policyParcel == nullptr) {
111 DLP_LOG_ERROR(LABEL, "Read parcel fail");
112 PermissionPolicy policyNull;
113 this->OnParseDlpCertificate(DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL, policyNull, {});
114 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
115 }
116 std::vector<uint8_t> cert;
117 if (!data.ReadUInt8Vector(&cert)) {
118 DLP_LOG_ERROR(LABEL, "Read int8 vector fail");
119 this->OnGenerateDlpCertificate(DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL, {});
120 return DLP_SERVICE_ERROR_PARCEL_OPERATE_FAIL;
121 }
122 this->OnParseDlpCertificate(result, policyParcel->policyParams_, cert);
123 return DLP_OK;
124 }
125
OnParseDlpCertificate(int32_t result,const PermissionPolicy & policy,const std::vector<uint8_t> & cert)126 void DlpPermissionAsyncStub::OnParseDlpCertificate(int32_t result, const PermissionPolicy& policy,
127 const std::vector<uint8_t>& cert)
128 {
129 if (parseDlpCertificateCallback_ == nullptr) {
130 DLP_LOG_ERROR(LABEL, "Callback is null");
131 return;
132 }
133
134 parseDlpCertificateCallback_->OnParseDlpCertificate(result, policy, cert);
135 }
136 } // namespace DlpPermission
137 } // namespace Security
138 } // namespace OHOS
139