1 /*
2 * Copyright (c) 2022-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 "active_status_callback_manager.h"
17
18 #include <future>
19 #include <thread>
20 #include <datetime_ex.h>
21 #include <pthread.h>
22
23 #include "accesstoken_dfx_define.h"
24 #include "accesstoken_common_log.h"
25 #include "ipc_skeleton.h"
26 #include "privacy_error.h"
27
28 namespace OHOS {
29 namespace Security {
30 namespace AccessToken {
31 namespace {
32 static const uint32_t MAX_CALLBACK_SIZE = 1024;
33 std::recursive_mutex g_instanceMutex;
34 }
35
GetInstance()36 ActiveStatusCallbackManager& ActiveStatusCallbackManager::GetInstance()
37 {
38 static ActiveStatusCallbackManager* instance = nullptr;
39 if (instance == nullptr) {
40 std::lock_guard<std::recursive_mutex> lock(g_instanceMutex);
41 if (instance == nullptr) {
42 ActiveStatusCallbackManager* tmp = new ActiveStatusCallbackManager();
43 instance = std::move(tmp);
44 }
45 }
46 return *instance;
47 }
48
ActiveStatusCallbackManager()49 ActiveStatusCallbackManager::ActiveStatusCallbackManager()
50 : callbackDeathRecipient_(sptr<IRemoteObject::DeathRecipient>(
51 new (std::nothrow) PermActiveStatusCallbackDeathRecipient()))
52 {
53 }
54
~ActiveStatusCallbackManager()55 ActiveStatusCallbackManager::~ActiveStatusCallbackManager()
56 {
57 }
58
59 #ifdef EVENTHANDLER_ENABLE
InitEventHandler(const std::shared_ptr<AccessEventHandler> & eventHandler)60 void ActiveStatusCallbackManager::InitEventHandler(const std::shared_ptr<AccessEventHandler>& eventHandler)
61 {
62 eventHandler_ = eventHandler;
63 }
64 #endif
65
AddCallback(AccessTokenID regiterTokenId,const std::vector<std::string> & permList,const sptr<IRemoteObject> & callback)66 int32_t ActiveStatusCallbackManager::AddCallback(
67 AccessTokenID regiterTokenId, const std::vector<std::string>& permList, const sptr<IRemoteObject>& callback)
68 {
69 if (callback == nullptr) {
70 LOGE(PRI_DOMAIN, PRI_TAG, "Input is nullptr");
71 return PrivacyError::ERR_PARAM_INVALID;
72 }
73
74 std::lock_guard<std::mutex> lock(mutex_);
75 if (callbackDataList_.size() >= MAX_CALLBACK_SIZE) {
76 LOGE(PRI_DOMAIN, PRI_TAG, "List size has reached max value");
77 return PrivacyError::ERR_CALLBACKS_EXCEED_LIMITATION;
78 }
79 if (callback->IsProxyObject() && !callback->AddDeathRecipient(callbackDeathRecipient_)) {
80 LOGE(PRI_DOMAIN, PRI_TAG, "add death recipient failed");
81 return PrivacyError::ERR_ADD_DEATH_RECIPIENT_FAILED;
82 }
83
84 CallbackData recordInstance;
85 recordInstance.registerTokenId = regiterTokenId;
86 recordInstance.callbackObject_ = callback;
87 recordInstance.permList_ = permList;
88
89 callbackDataList_.emplace_back(recordInstance);
90
91 LOGI(PRI_DOMAIN, PRI_TAG, "RecordInstance is added");
92 return RET_SUCCESS;
93 }
94
RemoveCallback(const sptr<IRemoteObject> & callback)95 int32_t ActiveStatusCallbackManager::RemoveCallback(const sptr<IRemoteObject>& callback)
96 {
97 LOGI(PRI_DOMAIN, PRI_TAG, "Called");
98 if (callback == nullptr) {
99 LOGE(PRI_DOMAIN, PRI_TAG, "Callback is nullptr.");
100 return PrivacyError::ERR_PARAM_INVALID;
101 }
102
103 std::lock_guard<std::mutex> lock(mutex_);
104
105 for (auto it = callbackDataList_.begin(); it != callbackDataList_.end(); ++it) {
106 if (callback == (*it).callbackObject_) {
107 LOGI(PRI_DOMAIN, PRI_TAG, "Find callback");
108 if (callbackDeathRecipient_ != nullptr) {
109 callback->RemoveDeathRecipient(callbackDeathRecipient_);
110 }
111 (*it).callbackObject_ = nullptr;
112 callbackDataList_.erase(it);
113 break;
114 }
115 }
116 return RET_SUCCESS;
117 }
118
NeedCalled(const std::vector<std::string> & permList,const std::string & permName)119 bool ActiveStatusCallbackManager::NeedCalled(const std::vector<std::string>& permList, const std::string& permName)
120 {
121 if (permList.empty()) {
122 return true;
123 }
124 return std::any_of(permList.begin(), permList.end(),
125 [permName](const std::string& perm) { return perm == permName; });
126 }
127
128
ActiveStatusChange(ActiveChangeResponse & info)129 void ActiveStatusCallbackManager::ActiveStatusChange(ActiveChangeResponse& info)
130 {
131 std::vector<sptr<IRemoteObject>> list;
132 {
133 std::lock_guard<std::mutex> lock(mutex_);
134 for (auto it = callbackDataList_.begin(); it != callbackDataList_.end(); ++it) {
135 std::vector<std::string> permList = (*it).permList_;
136 if (!NeedCalled(permList, info.permissionName)) {
137 LOGI(PRI_DOMAIN, PRI_TAG, "TokenId %{public}u, perm %{public}s", info.tokenID,
138 info.permissionName.c_str());
139 continue;
140 }
141 list.emplace_back((*it).callbackObject_);
142 }
143 }
144 for (auto it = list.begin(); it != list.end(); ++it) {
145 sptr<IPermActiveStatusCallback> callback = new PermActiveStatusChangeCallbackProxy(*it);
146 if (callback != nullptr) {
147 LOGI(PRI_DOMAIN, PRI_TAG, "callback execute callingTokenId %{public}u, tokenId %{public}u, "
148 "permision %{public}s, changeType %{public}d, usedType %{public}d, pid %{public}d", info.callingTokenID,
149 info.tokenID, info.permissionName.c_str(), info.type, info.usedType, info.pid);
150 callback->ActiveStatusChangeCallback(info);
151 }
152 }
153 }
154
ExecuteCallbackAsync(ActiveChangeResponse & info)155 void ActiveStatusCallbackManager::ExecuteCallbackAsync(ActiveChangeResponse& info)
156 {
157 if (info.type == PERM_ACTIVE_IN_BACKGROUND) {
158 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::ACCESS_TOKEN, "PERMISSION_CHECK_EVENT",
159 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "CODE", BACKGROUND_CALL_EVENT,
160 "CALLER_TOKENID", info.tokenID, "PERMISSION_NAME", info.permissionName, "REASON", "background call");
161 }
162
163 #ifdef EVENTHANDLER_ENABLE
164 if (eventHandler_ == nullptr) {
165 LOGE(PRI_DOMAIN, PRI_TAG, "Fail to get EventHandler");
166 return;
167 }
168 std::string taskName = info.permissionName + std::to_string(info.tokenID);
169 LOGI(PRI_DOMAIN, PRI_TAG, "Add permission task name:%{public}s", taskName.c_str());
170 std::function<void()> task = ([info]() mutable {
171 ActiveStatusCallbackManager::GetInstance().ActiveStatusChange(info);
172 LOGI(PRI_DOMAIN, PRI_TAG,
173 "Token: %{public}u, permName: %{public}s, changeType: %{public}d, ActiveStatusChange end",
174 info.tokenID, info.permissionName.c_str(), info.type);
175 });
176 eventHandler_->ProxyPostTask(task, taskName);
177 LOGI(PRI_DOMAIN, PRI_TAG, "The callback execution is complete");
178 return;
179 #else
180 LOGI(PRI_DOMAIN, PRI_TAG, "Event handler is unenabled");
181 return;
182 #endif
183 }
184 } // namespace AccessToken
185 } // namespace Security
186 } // namespace OHOS
187