1 /*
2 * Copyright (c) 2022 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 "security_collector_manager_proxy.h"
17
18 #include "security_collector_define.h"
19 #include "security_collector_log.h"
20
21 namespace OHOS::Security::SecurityCollector {
SecurityCollectorManagerProxy(const sptr<IRemoteObject> & impl)22 SecurityCollectorManagerProxy::SecurityCollectorManagerProxy(const sptr<IRemoteObject> &impl)
23 : IRemoteProxy<ISecurityCollectorManager>(impl)
24 {
25 }
26
Subscribe(const SecurityCollectorSubscribeInfo & subscribeInfo,const sptr<IRemoteObject> & callback)27 int32_t SecurityCollectorManagerProxy::Subscribe(const SecurityCollectorSubscribeInfo &subscribeInfo,
28 const sptr<IRemoteObject> &callback)
29 {
30 MessageParcel data;
31 MessageParcel reply;
32
33 if (!data.WriteInterfaceToken(GetDescriptor())) {
34 LOGE("WriteInterfaceToken error");
35 return WRITE_ERR;
36 }
37
38 if (!data.WriteParcelable(&subscribeInfo)) {
39 LOGE("failed to write parcelable for subscribeInfo");
40 return WRITE_ERR;
41 }
42
43 data.WriteRemoteObject(callback);
44
45 MessageOption option = { MessageOption::TF_SYNC };
46 int ret = Remote()->SendRequest(CMD_COLLECTOR_SUBCRIBE, data, reply, option);
47 if (ret != ERR_NONE) {
48 LOGE("ret=%{public}d", ret);
49 return ret;
50 }
51 ret = reply.ReadInt32();
52 LOGD("reply=%{public}d", ret);
53 return ret;
54 }
55
Unsubscribe(const sptr<IRemoteObject> & callback)56 int32_t SecurityCollectorManagerProxy::Unsubscribe(const sptr<IRemoteObject> &callback)
57 {
58 MessageParcel data;
59 MessageParcel reply;
60
61 if (!data.WriteInterfaceToken(GetDescriptor())) {
62 LOGE("WriteInterfaceToken error");
63 return WRITE_ERR;
64 }
65
66 data.WriteRemoteObject(callback);
67
68 MessageOption option = { MessageOption::TF_SYNC };
69 int ret = Remote()->SendRequest(CMD_COLLECTOR_UNSUBCRIBE, data, reply, option);
70 if (ret != ERR_NONE) {
71 LOGE("ret=%{public}d", ret);
72 return ret;
73 }
74 ret = reply.ReadInt32();
75 LOGD("reply=%{public}d", ret);
76 return ret;
77 }
78
CollectorStart(const SecurityCollectorSubscribeInfo & subscribeInfo,const sptr<IRemoteObject> & callback)79 int32_t SecurityCollectorManagerProxy::CollectorStart(const SecurityCollectorSubscribeInfo &subscribeInfo,
80 const sptr<IRemoteObject> &callback)
81 {
82 MessageParcel data;
83 MessageParcel reply;
84 LOGD("==========================in CollectorControl");
85 if (!data.WriteInterfaceToken(GetDescriptor())) {
86 LOGE("WriteInterfaceToken error");
87 return WRITE_ERR;
88 }
89
90 if (!data.WriteParcelable(&subscribeInfo)) {
91 LOGE("failed to write parcelable for subscribeInfo");
92 return WRITE_ERR;
93 }
94 data.WriteRemoteObject(callback);
95 MessageOption option = { MessageOption::TF_SYNC };
96 int ret = Remote()->SendRequest(CMD_COLLECTOR_START, data, reply, option);
97 if (ret != ERR_NONE) {
98 LOGE("ret=%{public}d", ret);
99 return ret;
100 }
101 ret = reply.ReadInt32();
102 LOGD("reply=%{public}d", ret);
103 return ret;
104 }
105
CollectorStop(const SecurityCollectorSubscribeInfo & subscribeInfo,const sptr<IRemoteObject> & callback)106 int32_t SecurityCollectorManagerProxy::CollectorStop(const SecurityCollectorSubscribeInfo &subscribeInfo,
107 const sptr<IRemoteObject> &callback)
108 {
109 MessageParcel data;
110 MessageParcel reply;
111 LOGD("===========================in CollectorControl.");
112 if (!data.WriteInterfaceToken(GetDescriptor())) {
113 LOGE("WriteInterfaceToken error");
114 return WRITE_ERR;
115 }
116
117 if (!data.WriteParcelable(&subscribeInfo)) {
118 LOGE("failed to write parcelable for subscribeInfo");
119 return WRITE_ERR;
120 }
121 data.WriteRemoteObject(callback);
122 MessageOption option = { MessageOption::TF_SYNC };
123 int ret = Remote()->SendRequest(CMD_COLLECTOR_STOP, data, reply, option);
124 if (ret != ERR_NONE) {
125 LOGE("ret=%{public}d", ret);
126 return ret;
127 }
128 ret = reply.ReadInt32();
129 LOGD("reply=%{public}d", ret);
130 return ret;
131 }
132
QuerySecurityEvent(const std::vector<SecurityEventRuler> rulers,std::vector<SecurityEvent> & events)133 int32_t SecurityCollectorManagerProxy::QuerySecurityEvent(const std::vector<SecurityEventRuler> rulers,
134 std::vector<SecurityEvent> &events)
135 {
136 MessageParcel data;
137 MessageParcel reply;
138
139 if (!data.WriteInterfaceToken(GetDescriptor())) {
140 LOGE("WriteInterfaceToken error");
141 return WRITE_ERR;
142 }
143
144 if (!data.WriteUint32(rulers.size())) {
145 LOGE("failed to WriteInt32 for parcelable vector size");
146 return WRITE_ERR;
147 }
148
149 for (const auto &ruler : rulers) {
150 if (!data.WriteParcelable(&ruler)) {
151 LOGE("failed to WriteParcelable for parcelable");
152 return WRITE_ERR;
153 }
154 }
155
156 MessageOption option = { MessageOption::TF_SYNC };
157 int ret = Remote()->SendRequest(CMD_SECURITY_EVENT_QUERY, data, reply, option);
158 if (ret != ERR_NONE) {
159 LOGE("ret=%{public}d", ret);
160 return ret;
161 }
162
163 uint32_t size = 0;
164 if (!reply.ReadUint32(size)) {
165 LOGE("failed to get the event size");
166 return BAD_PARAM;
167 }
168
169 if (size > MAX_QUERY_EVENT_SIZE) {
170 LOGE("the event size error");
171 return BAD_PARAM;
172 }
173 for (uint32_t index = 0; index < size; index++) {
174 std::shared_ptr<SecurityEvent> event(reply.ReadParcelable<SecurityEvent>());
175 if (event == nullptr) {
176 LOGE("failed read security event");
177 return BAD_PARAM;
178 }
179 events.emplace_back(*event);
180 }
181 return SUCCESS;
182 }
183 }