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 "remote_command_manager.h"
17 #include <thread>
18 #ifdef EVENTHANDLER_ENABLE
19 #include "access_event_handler.h"
20 #endif
21 #include "device_info_manager.h"
22 #include "remote_command_factory.h"
23 #include "token_sync_manager_service.h"
24 #include "accesstoken_kit.h"
25 #include "constant_common.h"
26
27 namespace OHOS {
28 namespace Security {
29 namespace AccessToken {
30 namespace {
31 std::recursive_mutex g_instanceMutex;
32 }
RemoteCommandManager()33 RemoteCommandManager::RemoteCommandManager() : executors_(), mutex_()
34 {
35 LOGD(ATM_DOMAIN, ATM_TAG, "RemoteCommandManager()");
36 }
37
~RemoteCommandManager()38 RemoteCommandManager::~RemoteCommandManager()
39 {
40 LOGD(ATM_DOMAIN, ATM_TAG, "~RemoteCommandManager()");
41 }
42
GetInstance()43 RemoteCommandManager &RemoteCommandManager::GetInstance()
44 {
45 static RemoteCommandManager* instance = nullptr;
46 if (instance == nullptr) {
47 std::lock_guard<std::recursive_mutex> lock(g_instanceMutex);
48 if (instance == nullptr) {
49 RemoteCommandManager* tmp = new (std::nothrow) RemoteCommandManager();
50 instance = std::move(tmp);
51 }
52 }
53 return *instance;
54 }
55
Init()56 void RemoteCommandManager::Init()
57 {
58 LOGD(ATM_DOMAIN, ATM_TAG, "Init()");
59 }
60
AddCommand(const std::string & udid,const std::shared_ptr<BaseRemoteCommand> & command)61 int RemoteCommandManager::AddCommand(const std::string &udid, const std::shared_ptr<BaseRemoteCommand>& command)
62 {
63 if (udid.empty() || command == nullptr) {
64 LOGW(ATM_DOMAIN, ATM_TAG, "Invalid udid, or null command");
65 return Constant::FAILURE;
66 }
67 LOGI(ATM_DOMAIN, ATM_TAG, "Add uniqueId");
68
69 std::shared_ptr<RemoteCommandExecutor> executor = GetOrCreateRemoteCommandExecutor(udid);
70 if (executor == nullptr) {
71 LOGE(ATM_DOMAIN, ATM_TAG, "Cannot get or create remote command executor");
72 return Constant::FAILURE;
73 }
74
75 int result = executor->AddCommand(command);
76 LOGI(ATM_DOMAIN, ATM_TAG, "Add command result: %{public}d ", result);
77 return result;
78 }
79
RemoveCommand(const std::string & udid)80 void RemoteCommandManager::RemoveCommand(const std::string &udid)
81 {
82 LOGI(ATM_DOMAIN, ATM_TAG, "Remove command");
83 executors_.erase(udid);
84 }
85
ExecuteCommand(const std::string & udid,const std::shared_ptr<BaseRemoteCommand> & command)86 int RemoteCommandManager::ExecuteCommand(const std::string &udid, const std::shared_ptr<BaseRemoteCommand>& command)
87 {
88 if (udid.empty() || command == nullptr) {
89 LOGW(ATM_DOMAIN, ATM_TAG, "Invalid udid: %{public}s, or null command",
90 ConstantCommon::EncryptDevId(udid).c_str());
91 return Constant::FAILURE;
92 }
93 std::string uniqueId = command->remoteProtocol_.uniqueId;
94 LOGI(ATM_DOMAIN, ATM_TAG, "Start with udid: %{public}s , uniqueId: %{public}s ",
95 ConstantCommon::EncryptDevId(udid).c_str(), ConstantCommon::EncryptDevId(uniqueId).c_str());
96
97 std::shared_ptr<RemoteCommandExecutor> executor = GetOrCreateRemoteCommandExecutor(udid);
98 if (executor == nullptr) {
99 LOGE(ATM_DOMAIN, ATM_TAG, "Cannot get or create remote command executor");
100 return Constant::FAILURE;
101 }
102
103 int result = executor->ProcessOneCommand(command);
104 LOGI(ATM_DOMAIN, ATM_TAG, "RemoteCommandExecutor processOneCommand result:%{public}d ", result);
105 return result;
106 }
107
ProcessDeviceCommandImmediately(const std::string & udid)108 int RemoteCommandManager::ProcessDeviceCommandImmediately(const std::string &udid)
109 {
110 if (udid.empty()) {
111 LOGW(ATM_DOMAIN, ATM_TAG, "Invalid udid: %{public}s", ConstantCommon::EncryptDevId(udid).c_str());
112 return Constant::FAILURE;
113 }
114 LOGI(ATM_DOMAIN, ATM_TAG, "Start with udid:%{public}s ", ConstantCommon::EncryptDevId(udid).c_str());
115
116 std::unique_lock<std::mutex> lock(mutex_);
117 auto executorIt = executors_.find(udid);
118 if (executorIt == executors_.end()) {
119 LOGE(ATM_DOMAIN, ATM_TAG, "No executor found, udid:%{public}s", ConstantCommon::EncryptDevId(udid).c_str());
120 return Constant::FAILURE;
121 }
122
123 auto executor = executorIt->second;
124 if (executor == nullptr) {
125 LOGI(ATM_DOMAIN, ATM_TAG, "RemoteCommandExecutor is null for udid %{public}s ",
126 ConstantCommon::EncryptDevId(udid).c_str());
127 return Constant::FAILURE;
128 }
129
130 int result = executor->ProcessBufferedCommands();
131 LOGI(ATM_DOMAIN, ATM_TAG, "ProcessBufferedCommands result: %{public}d", result);
132 return result;
133 }
134
Loop()135 int RemoteCommandManager::Loop()
136 {
137 LOGI(ATM_DOMAIN, ATM_TAG, "Start");
138 std::unique_lock<std::mutex> lock(mutex_);
139 for (auto it = executors_.begin(); it != executors_.end(); it++) {
140 LOGI(ATM_DOMAIN, ATM_TAG, "Udid:%{public}s", ConstantCommon::EncryptDevId(it->first).c_str());
141 if (it->second == nullptr) {
142 LOGE(ATM_DOMAIN, ATM_TAG, "RemoteCommandExecutor is null.");
143 continue;
144 }
145 (*it).second->ProcessBufferedCommandsWithThread();
146 }
147 return Constant::SUCCESS;
148 }
149
150 /**
151 * caller: service connection listener
152 */
Clear()153 void RemoteCommandManager::Clear()
154 {
155 LOGI(ATM_DOMAIN, ATM_TAG, "Remove all remote command executors.");
156
157 std::map<std::string, std::shared_ptr<RemoteCommandExecutor>> dummy;
158 std::unique_lock<std::mutex> lock(mutex_);
159 executors_.swap(dummy);
160 executors_.clear();
161 }
162
163 /**
164 * caller: device listener
165 */
NotifyDeviceOnline(const std::string & nodeId)166 int RemoteCommandManager::NotifyDeviceOnline(const std::string &nodeId)
167 {
168 if (!DataValidator::IsDeviceIdValid(nodeId)) {
169 LOGI(ATM_DOMAIN, ATM_TAG, "Invalid nodeId: %{public}s", ConstantCommon::EncryptDevId(nodeId).c_str());
170 return Constant::FAILURE;
171 }
172 LOGI(ATM_DOMAIN, ATM_TAG, "Operation start with nodeId: %{public}s",
173 ConstantCommon::EncryptDevId(nodeId).c_str());
174
175 auto executor = GetOrCreateRemoteCommandExecutor(nodeId);
176 std::unique_lock<std::mutex> lock(mutex_);
177 if (executor == nullptr) {
178 LOGE(ATM_DOMAIN, ATM_TAG, "Cannot get or create remote command executor");
179 return Constant::FAILURE;
180 }
181
182 if (executor->GetChannel() == nullptr) {
183 auto channel = RemoteCommandExecutor::CreateChannel(nodeId);
184 if (channel == nullptr) {
185 LOGE(ATM_DOMAIN, ATM_TAG, "Create channel failed.");
186 return Constant::FAILURE;
187 }
188 executor->SetChannel(channel);
189 }
190
191 lock.unlock();
192
193 return Constant::SUCCESS;
194 }
195
196 /**
197 * caller: device listener
198 */
NotifyDeviceOffline(const std::string & nodeId)199 int RemoteCommandManager::NotifyDeviceOffline(const std::string &nodeId)
200 {
201 if (!DataValidator::IsDeviceIdValid(nodeId)) {
202 LOGI(ATM_DOMAIN, ATM_TAG, "Invalid nodeId: %{public}s", ConstantCommon::EncryptDevId(nodeId).c_str());
203 return Constant::FAILURE;
204 }
205 LOGI(ATM_DOMAIN, ATM_TAG, "Operation start with nodeId: %{public}s",
206 ConstantCommon::EncryptDevId(nodeId).c_str());
207
208 auto channel = GetExecutorChannel(nodeId);
209 if (channel != nullptr) {
210 channel->Release();
211 }
212
213 std::unique_lock<std::mutex> lock(mutex_);
214 RemoveCommand(nodeId);
215 lock.unlock();
216
217 DeviceInfo devInfo;
218 bool result = DeviceInfoManager::GetInstance().GetDeviceInfo(nodeId, DeviceIdType::UNKNOWN, devInfo);
219 if (!result) {
220 LOGI(ATM_DOMAIN, ATM_TAG, "Get remote networkId failed");
221 return Constant::FAILURE;
222 }
223 std::string uniqueDeviceId = devInfo.deviceId.uniqueDeviceId;
224 std::function<void()> delayed = ([uniqueDeviceId]() {
225 AccessTokenKit::DeleteRemoteDeviceTokens(uniqueDeviceId);
226 });
227
228 #ifdef EVENTHANDLER_ENABLE
229 auto tokenSyncManagerService = DelayedSingleton<TokenSyncManagerService>::GetInstance();
230 if (tokenSyncManagerService == nullptr) {
231 LOGE(ATM_DOMAIN, ATM_TAG, "TokenSyncManagerService is null.");
232 return Constant::FAILURE;
233 }
234 std::shared_ptr<AccessEventHandler> handler = tokenSyncManagerService->GetSendEventHandler();
235 if (handler == nullptr) {
236 LOGE(ATM_DOMAIN, ATM_TAG, "Fail to get EventHandler");
237 return Constant::FAILURE;
238 }
239 handler->ProxyPostTask(delayed, "HandleDeviceOffline");
240 #endif
241
242 LOGI(ATM_DOMAIN, ATM_TAG, "Complete");
243 return Constant::SUCCESS;
244 }
245
GetOrCreateRemoteCommandExecutor(const std::string & nodeId)246 std::shared_ptr<RemoteCommandExecutor> RemoteCommandManager::GetOrCreateRemoteCommandExecutor(const std::string &nodeId)
247 {
248 LOGD(ATM_DOMAIN, ATM_TAG, "Begin, nodeId %{public}s", ConstantCommon::EncryptDevId(nodeId).c_str());
249
250 std::unique_lock<std::mutex> lock(mutex_);
251 auto executorIter = executors_.find(nodeId);
252 if (executorIter != executors_.end()) {
253 return executorIter->second;
254 }
255
256 auto executor = std::make_shared<RemoteCommandExecutor>(nodeId);
257 executors_.insert(std::pair<std::string, std::shared_ptr<RemoteCommandExecutor>>(nodeId, executor));
258 LOGD(ATM_DOMAIN, ATM_TAG, "Executor added, nodeId: %{public}s", ConstantCommon::EncryptDevId(nodeId).c_str());
259 return executor;
260 }
261
262 /**
263 * caller: session listener(OnBytes)
264 */
GetExecutorChannel(const std::string & nodeId)265 std::shared_ptr<RpcChannel> RemoteCommandManager::GetExecutorChannel(const std::string &nodeId)
266 {
267 LOGD(ATM_DOMAIN, ATM_TAG, "Convert udid start, nodeId:%{public}s", ConstantCommon::EncryptDevId(nodeId).c_str());
268 std::string udid = DeviceInfoManager::GetInstance().ConvertToUniqueDeviceIdOrFetch(nodeId);
269 if (!DataValidator::IsDeviceIdValid(udid)) {
270 LOGW(ATM_DOMAIN, ATM_TAG, "Converted udid is invalid, nodeId:%{public}s",
271 ConstantCommon::EncryptDevId(nodeId).c_str());
272 return nullptr;
273 }
274
275 std::unique_lock<std::mutex> lock(mutex_);
276 std::map<std::string, std::shared_ptr<RemoteCommandExecutor>>::iterator iter = executors_.find(udid);
277 if (iter == executors_.end()) {
278 LOGI(ATM_DOMAIN, ATM_TAG, "Executor not found");
279 return nullptr;
280 }
281 std::shared_ptr<RemoteCommandExecutor> executor = iter->second;
282 if (executor == nullptr) {
283 LOGI(ATM_DOMAIN, ATM_TAG, "Executor is null");
284 return nullptr;
285 }
286 return executor->GetChannel();
287 }
288 } // namespace AccessToken
289 } // namespace Security
290 } // namespace OHOS
291