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 #include "collector_manager.h"
16
17 #include "iservice_registry.h"
18 #include "security_collector_manager_proxy.h"
19 #include "security_collector_manager_callback_service.h"
20 #include "security_collector_define.h"
21 #include "security_collector_log.h"
22 #include "collector_service_loader.h"
23
24 namespace OHOS::Security::SecurityCollector {
Subscribe(const std::shared_ptr<ICollectorSubscriber> & subscriber)25 int32_t CollectorManager::Subscribe(const std::shared_ptr<ICollectorSubscriber> &subscriber)
26 {
27 LOGI("enter CollectorManager Subscribe");
28 if (subscriber == nullptr) {
29 LOGE("subscriber is null");
30 return BAD_PARAM;
31 }
32 std::lock_guard<std::mutex> lock(mutex_);
33 if (eventListeners_.find(subscriber) != eventListeners_.end()) {
34 LOGE("Already subscribed");
35 return BAD_PARAM;
36 }
37
38 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
39 if (object == nullptr) {
40 LOGE("object is null");
41 return NULL_OBJECT;
42 }
43 auto proxy = iface_cast<ISecurityCollectorManager>(object);
44 if (proxy == nullptr) {
45 LOGE("proxy is null");
46 return NULL_OBJECT;
47 }
48 if (deathRecipient_ == nullptr) {
49 deathRecipient_ = new (std::nothrow) DeathRecipient();
50 if (deathRecipient_ == nullptr) {
51 LOGE("deathRecipient_ is null");
52 return NULL_OBJECT;
53 }
54 }
55 if (!object->AddDeathRecipient(deathRecipient_)) {
56 LOGE("Failed to add death recipient");
57 return NULL_OBJECT;
58 }
59
60 sptr<SecurityCollectorManagerCallbackService> callback =
61 new (std::nothrow) SecurityCollectorManagerCallbackService(subscriber);
62 if (callback == nullptr) {
63 LOGE("callback is null");
64 return NULL_OBJECT;
65 }
66 int32_t ret = proxy->Subscribe(subscriber->GetSubscribeInfo(), callback);
67 if (ret == SUCCESS) {
68 eventListeners_[subscriber] = callback;
69 }
70 LOGI("Subscribe result, ret=%{public}d", ret);
71 return ret;
72 }
73
Unsubscribe(const std::shared_ptr<ICollectorSubscriber> & subscriber)74 int32_t CollectorManager::Unsubscribe(const std::shared_ptr<ICollectorSubscriber> &subscriber)
75 {
76 LOGI("enter CollectorManager Unsubscribe");
77 if (subscriber == nullptr) {
78 LOGE("subscriber is null");
79 return BAD_PARAM;
80 }
81
82 std::lock_guard<std::mutex> lock(mutex_);
83 if (eventListeners_.find(subscriber) == eventListeners_.end()) {
84 LOGE("Not subscribed");
85 return BAD_PARAM;
86 }
87 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
88 if (object == nullptr) {
89 LOGE("object is null");
90 return NULL_OBJECT;
91 }
92 auto proxy = iface_cast<ISecurityCollectorManager>(object);
93 if (proxy == nullptr) {
94 LOGE("Proxy is null");
95 return NULL_OBJECT;
96 }
97
98 int32_t ret = proxy->Unsubscribe(eventListeners_[subscriber]);
99 LOGI("Unsubscribe result, ret=%{public}d", ret);
100 eventListeners_.erase(subscriber);
101 return ret;
102 }
103
OnRemoteDied(const wptr<IRemoteObject> & remote)104 void CollectorManager::DeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
105 {
106 if (remote == nullptr) {
107 LOGE("remote object is nullptr");
108 return;
109 }
110 sptr<IRemoteObject> object = remote.promote();
111 if (object == nullptr) {
112 LOGE("object is nullptr");
113 return;
114 }
115 object->RemoveDeathRecipient(this);
116 CollectorManager::GetInstance().HandleDecipient();
117 }
118
HandleDecipient()119 void CollectorManager::HandleDecipient()
120 {
121 std::lock_guard<std::mutex> lock(mutex_);
122 eventListeners_.clear();
123 }
124
QuerySecurityEvent(const std::vector<SecurityEventRuler> rulers,std::vector<SecurityEvent> & events)125 int32_t CollectorManager::QuerySecurityEvent(const std::vector<SecurityEventRuler> rulers,
126 std::vector<SecurityEvent> &events)
127 {
128 LOGE("begin collector QuerySecurityEvent");
129 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
130 if (object == nullptr) {
131 LOGE("object is null");
132 return NULL_OBJECT;
133 }
134 auto proxy = iface_cast<ISecurityCollectorManager>(object);
135 if (proxy == nullptr) {
136 LOGE("proxy is null");
137 return NULL_OBJECT;
138 }
139
140 int32_t ret = proxy->QuerySecurityEvent(rulers, events);
141 if (ret != SUCCESS) {
142 LOGI("QuerySecurityEvent failed, ret=%{public}d", ret);
143 return ret;
144 }
145 LOGI("QuerySecurityEvent result, ret=%{public}d", ret);
146 return SUCCESS;
147 }
148
CollectorStart(const SecurityCollector::SecurityCollectorSubscribeInfo & subscriber)149 int32_t CollectorManager::CollectorStart(const SecurityCollector::SecurityCollectorSubscribeInfo &subscriber)
150 {
151 LOGI("enter CollectorManager CollectorStart");
152 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
153 if (object == nullptr) {
154 LOGE("object is null");
155 return NULL_OBJECT;
156 }
157 auto proxy = iface_cast<ISecurityCollectorManager>(object);
158 if (proxy == nullptr) {
159 LOGE("proxy is null");
160 return NULL_OBJECT;
161 }
162 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
163 new (std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
164 if (callback == nullptr) {
165 LOGE("callback is null");
166 return NULL_OBJECT;
167 }
168 int32_t ret = proxy->CollectorStart(subscriber, callback);
169 if (ret != SUCCESS) {
170 LOGI("CollectorStart failed, ret=%{public}d", ret);
171 return ret;
172 }
173 LOGI("CollectorStart result, ret=%{public}d", ret);
174 return SUCCESS;
175 }
176
CollectorStop(const SecurityCollector::SecurityCollectorSubscribeInfo & subscriber)177 int32_t CollectorManager::CollectorStop(const SecurityCollector::SecurityCollectorSubscribeInfo &subscriber)
178 {
179 LOGI("enter CollectorManager CollectorStart");
180 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
181 if (object == nullptr) {
182 LOGE("object is null");
183 return NULL_OBJECT;
184 }
185 auto proxy = iface_cast<ISecurityCollectorManager>(object);
186 if (proxy == nullptr) {
187 LOGE("proxy is null");
188 return NULL_OBJECT;
189 }
190 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
191 new (std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
192 if (callback == nullptr) {
193 LOGE("callback is null");
194 return NULL_OBJECT;
195 }
196 int32_t ret = proxy->CollectorStop(subscriber, callback);
197 if (ret != SUCCESS) {
198 LOGI("CollectorStop failed, ret=%{public}d", ret);
199 return ret;
200 }
201 LOGI("CollectorStop result, ret=%{public}d", ret);
202 return SUCCESS;
203 }
204
AddFilter(const SecurityCollectorEventFilter & subscribeMute)205 int32_t CollectorManager::AddFilter(const SecurityCollectorEventFilter &subscribeMute)
206 {
207 LOGI("enter CollectorManager AddFilter");
208 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
209 if (object == nullptr) {
210 LOGE("object is null");
211 return NULL_OBJECT;
212 }
213 auto proxy = iface_cast<ISecurityCollectorManager>(object);
214 if (proxy == nullptr) {
215 LOGE("proxy is null");
216 return NULL_OBJECT;
217 }
218
219 int32_t ret = proxy->AddFilter(subscribeMute);
220 if (ret != SUCCESS) {
221 LOGI("AddFilter failed, ret=%{public}d", ret);
222 return ret;
223 }
224 LOGI("AddFilter result, ret=%{public}d", ret);
225 return SUCCESS;
226 }
227
RemoveFilter(const SecurityCollectorEventFilter & subscribeMute)228 int32_t CollectorManager::RemoveFilter(const SecurityCollectorEventFilter &subscribeMute)
229 {
230 LOGI("enter CollectorManager RemoveFilter");
231 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
232 if (object == nullptr) {
233 LOGE("object is null");
234 return NULL_OBJECT;
235 }
236 auto proxy = iface_cast<ISecurityCollectorManager>(object);
237 if (proxy == nullptr) {
238 LOGE("proxy is null");
239 return NULL_OBJECT;
240 }
241
242 int32_t ret = proxy->RemoveFilter(subscribeMute);
243 if (ret != SUCCESS) {
244 LOGI("RemoveFilter failed, ret=%{public}d", ret);
245 return ret;
246 }
247 LOGI("RemoveFilter result, ret=%{public}d", ret);
248 return SUCCESS;
249 }
250 }