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 if (subscriber == nullptr) {
28 LOGE("subscriber is null");
29 return BAD_PARAM;
30 }
31 std::lock_guard<std::mutex> lock(mutex_);
32 if (eventListeners_.find(subscriber) != eventListeners_.end()) {
33 LOGE("Already subscribed");
34 return BAD_PARAM;
35 }
36
37 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
38 auto proxy = iface_cast<ISecurityCollectorManager>(object);
39 if (proxy == nullptr) {
40 LOGE("proxy is null");
41 return NULL_OBJECT;
42 }
43 if (deathRecipient_ == nullptr) {
44 deathRecipient_ = new (std::nothrow) DeathRecipient();
45 if (deathRecipient_ == nullptr) {
46 LOGE("deathRecipient_ is null");
47 return NULL_OBJECT;
48 }
49 }
50 if (!object->AddDeathRecipient(deathRecipient_)) {
51 LOGE("Failed to add death recipient");
52 return NULL_OBJECT;
53 }
54
55 sptr<SecurityCollectorManagerCallbackService> callback =
56 new (std::nothrow) SecurityCollectorManagerCallbackService(subscriber);
57 if (callback == nullptr) {
58 LOGE("callback is null");
59 return NULL_OBJECT;
60 }
61 int32_t ret = proxy->Subscribe(subscriber->GetSubscribeInfo(), callback);
62 if (ret == SUCCESS) {
63 eventListeners_[subscriber] = callback;
64 }
65 LOGI("Subscribe result, ret=%{public}d", ret);
66 return ret;
67 }
68
Unsubscribe(const std::shared_ptr<ICollectorSubscriber> & subscriber)69 int32_t CollectorManager::Unsubscribe(const std::shared_ptr<ICollectorSubscriber> &subscriber)
70 {
71 if (subscriber == nullptr) {
72 LOGE("subscriber is null");
73 return BAD_PARAM;
74 }
75
76 std::lock_guard<std::mutex> lock(mutex_);
77 if (eventListeners_.find(subscriber) == eventListeners_.end()) {
78 LOGE("Not subscribed");
79 return BAD_PARAM;
80 }
81 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
82 auto proxy = iface_cast<ISecurityCollectorManager>(object);
83 if (proxy == nullptr) {
84 LOGE("Proxy is null");
85 return NULL_OBJECT;
86 }
87
88 int32_t ret = proxy->Unsubscribe(eventListeners_[subscriber]);
89 LOGI("Unsubscribe result, ret=%{public}d", ret);
90 eventListeners_.erase(subscriber);
91 return ret;
92 }
93
OnRemoteDied(const wptr<IRemoteObject> & remote)94 void CollectorManager::DeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
95 {
96 if (remote == nullptr) {
97 LOGE("remote object is nullptr");
98 return;
99 }
100 sptr<IRemoteObject> object = remote.promote();
101 if (object == nullptr) {
102 LOGE("object is nullptr");
103 return;
104 }
105 object->RemoveDeathRecipient(this);
106 CollectorManager::GetInstance().HandleDecipient();
107 }
108
HandleDecipient()109 void CollectorManager::HandleDecipient()
110 {
111 std::lock_guard<std::mutex> lock(mutex_);
112 eventListeners_.clear();
113 }
114
QuerySecurityEvent(const std::vector<SecurityEventRuler> rulers,std::vector<SecurityEvent> & events)115 int32_t CollectorManager::QuerySecurityEvent(const std::vector<SecurityEventRuler> rulers,
116 std::vector<SecurityEvent> &events)
117 {
118 LOGE("begin collector QuerySecurityEvent");
119 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
120 auto proxy = iface_cast<ISecurityCollectorManager>(object);
121 if (proxy == nullptr) {
122 LOGE("proxy is null");
123 return NULL_OBJECT;
124 }
125
126 int32_t ret = proxy->QuerySecurityEvent(rulers, events);
127 if (ret != SUCCESS) {
128 LOGI("QuerySecurityEvent failed, ret=%{public}d", ret);
129 return ret;
130 }
131 LOGI("QuerySecurityEvent result, ret=%{public}d", ret);
132 return SUCCESS;
133 }
134
CollectorStart(const SecurityCollector::SecurityCollectorSubscribeInfo & subscriber)135 int32_t CollectorManager::CollectorStart(const SecurityCollector::SecurityCollectorSubscribeInfo &subscriber)
136 {
137 LOGI("begin CollectorStart");
138 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
139 auto proxy = iface_cast<ISecurityCollectorManager>(object);
140 if (proxy == nullptr) {
141 LOGE("proxy is null");
142 return NULL_OBJECT;
143 }
144 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
145 new (std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
146 if (callback == nullptr) {
147 LOGE("callback is null");
148 return NULL_OBJECT;
149 }
150 int32_t ret = proxy->CollectorStart(subscriber, callback);
151 if (ret != SUCCESS) {
152 LOGI("CollectorStart failed, ret=%{public}d", ret);
153 return ret;
154 }
155 LOGI("CollectorStart result, ret=%{public}d", ret);
156 return SUCCESS;
157 }
158
CollectorStop(const SecurityCollector::SecurityCollectorSubscribeInfo & subscriber)159 int32_t CollectorManager::CollectorStop(const SecurityCollector::SecurityCollectorSubscribeInfo &subscriber)
160 {
161 LOGI("begin CollectorStart");
162 auto object = CollectorServiceLoader::GetInstance().LoadCollectorService();
163 auto proxy = iface_cast<ISecurityCollectorManager>(object);
164 if (proxy == nullptr) {
165 LOGE("proxy is null");
166 return NULL_OBJECT;
167 }
168 sptr<SecurityCollector::SecurityCollectorManagerCallbackService> callback =
169 new (std::nothrow) SecurityCollector::SecurityCollectorManagerCallbackService(nullptr);
170 if (callback == nullptr) {
171 LOGE("callback is null");
172 return NULL_OBJECT;
173 }
174 int32_t ret = proxy->CollectorStop(subscriber, callback);
175 if (ret != SUCCESS) {
176 LOGI("CollectorStart failed, ret=%{public}d", ret);
177 return ret;
178 }
179 LOGI("CollectorStart result, ret=%{public}d", ret);
180 return SUCCESS;
181 }
182 }