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 "token_sync_manager_service.h"
17
18 #include <securec.h>
19
20 #include "accesstoken_log.h"
21 #include "constant_common.h"
22 #include "device_info_repository.h"
23 #include "device_info.h"
24 #include "remote_command_manager.h"
25 #include "soft_bus_manager.h"
26
27 namespace OHOS {
28 namespace Security {
29 namespace AccessToken {
30 namespace {
31 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "TokenSyncManagerService"};
32 }
33
34 const bool REGISTER_RESULT =
35 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<TokenSyncManagerService>::GetInstance().get());
36
TokenSyncManagerService()37 TokenSyncManagerService::TokenSyncManagerService()
38 : SystemAbility(SA_ID_TOKENSYNC_MANAGER_SERVICE, false), state_(ServiceRunningState::STATE_NOT_START)
39 {
40 ACCESSTOKEN_LOG_INFO(LABEL, "TokenSyncManagerService()");
41 }
42
~TokenSyncManagerService()43 TokenSyncManagerService::~TokenSyncManagerService()
44 {
45 ACCESSTOKEN_LOG_INFO(LABEL, "~TokenSyncManagerService()");
46 }
47
OnStart()48 void TokenSyncManagerService::OnStart()
49 {
50 if (state_ == ServiceRunningState::STATE_RUNNING) {
51 ACCESSTOKEN_LOG_INFO(LABEL, "TokenSyncManagerService has already started!");
52 return;
53 }
54 ACCESSTOKEN_LOG_INFO(LABEL, "TokenSyncManagerService is starting");
55 if (!Initialize()) {
56 ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to initialize");
57 return;
58 }
59 state_ = ServiceRunningState::STATE_RUNNING;
60 bool ret = Publish(DelayedSingleton<TokenSyncManagerService>::GetInstance().get());
61 if (!ret) {
62 ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to publish service!");
63 return;
64 }
65 ACCESSTOKEN_LOG_INFO(LABEL, "Congratulations, TokenSyncManagerService start successfully!");
66 }
67
OnStop()68 void TokenSyncManagerService::OnStop()
69 {
70 ACCESSTOKEN_LOG_INFO(LABEL, "stop service");
71 state_ = ServiceRunningState::STATE_NOT_START;
72 SoftBusManager::GetInstance().Destroy();
73 }
74
GetSendEventHandler() const75 std::shared_ptr<TokenSyncEventHandler> TokenSyncManagerService::GetSendEventHandler() const
76 {
77 return sendHandler_;
78 }
79
GetRecvEventHandler() const80 std::shared_ptr<TokenSyncEventHandler> TokenSyncManagerService::GetRecvEventHandler() const
81 {
82 return recvHandler_;
83 }
84
GetRemoteHapTokenInfo(const std::string & deviceID,AccessTokenID tokenID)85 int TokenSyncManagerService::GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID)
86 {
87 if (!DataValidator::IsDeviceIdValid(deviceID) || tokenID == 0) {
88 ACCESSTOKEN_LOG_INFO(LABEL, "Params is wrong.");
89 return TOKEN_SYNC_PARAMS_INVALID;
90 }
91 DeviceInfo devInfo;
92 bool result = DeviceInfoRepository::GetInstance().FindDeviceInfo(deviceID, DeviceIdType::UNKNOWN, devInfo);
93 if (!result) {
94 ACCESSTOKEN_LOG_INFO(LABEL, "FindDeviceInfo failed");
95 return TOKEN_SYNC_REMOTE_DEVICE_INVALID;
96 }
97 std::string udid = devInfo.deviceId.uniqueDeviceId;
98 const std::shared_ptr<SyncRemoteHapTokenCommand> syncRemoteHapTokenCommand =
99 RemoteCommandFactory::GetInstance().NewSyncRemoteHapTokenCommand(ConstantCommon::GetLocalDeviceId(),
100 deviceID, tokenID);
101
102 const int32_t resultCode = RemoteCommandManager::GetInstance().ExecuteCommand(udid, syncRemoteHapTokenCommand);
103 if (resultCode != Constant::SUCCESS) {
104 ACCESSTOKEN_LOG_INFO(LABEL,
105 "RemoteExecutorManager executeCommand SyncRemoteHapTokenCommand failed, return %{public}d", resultCode);
106 return TOKEN_SYNC_COMMAND_EXECUTE_FAILED;
107 }
108 ACCESSTOKEN_LOG_INFO(LABEL, "get resultCode: %{public}d", resultCode);
109 return TOKEN_SYNC_SUCCESS;
110 }
111
DeleteRemoteHapTokenInfo(AccessTokenID tokenID)112 int TokenSyncManagerService::DeleteRemoteHapTokenInfo(AccessTokenID tokenID)
113 {
114 if (tokenID == 0) {
115 ACCESSTOKEN_LOG_INFO(LABEL, "Params is wrong, token id is invalid.");
116 return TOKEN_SYNC_PARAMS_INVALID;
117 }
118
119 std::vector<DeviceInfo> devices = DeviceInfoRepository::GetInstance().ListDeviceInfo();
120 std::string localUdid = ConstantCommon::GetLocalDeviceId();
121 for (const DeviceInfo& device : devices) {
122 if (device.deviceId.uniqueDeviceId == localUdid) {
123 ACCESSTOKEN_LOG_INFO(LABEL, "no need notify local device");
124 continue;
125 }
126 const std::shared_ptr<DeleteRemoteTokenCommand> deleteRemoteTokenCommand =
127 RemoteCommandFactory::GetInstance().NewDeleteRemoteTokenCommand(ConstantCommon::GetLocalDeviceId(),
128 device.deviceId.uniqueDeviceId, tokenID);
129
130 const int32_t resultCode = RemoteCommandManager::GetInstance().ExecuteCommand(
131 device.deviceId.uniqueDeviceId, deleteRemoteTokenCommand);
132 if (resultCode != Constant::SUCCESS) {
133 ACCESSTOKEN_LOG_INFO(LABEL,
134 "RemoteExecutorManager executeCommand DeleteRemoteTokenCommand failed, return %{public}d", resultCode);
135 continue;
136 }
137 ACCESSTOKEN_LOG_INFO(LABEL, "get resultCode: %{public}d", resultCode);
138 }
139 return TOKEN_SYNC_SUCCESS;
140 }
141
UpdateRemoteHapTokenInfo(const HapTokenInfoForSync & tokenInfo)142 int TokenSyncManagerService::UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo)
143 {
144 std::vector<DeviceInfo> devices = DeviceInfoRepository::GetInstance().ListDeviceInfo();
145 std::string localUdid = ConstantCommon::GetLocalDeviceId();
146 for (const DeviceInfo& device : devices) {
147 if (device.deviceId.uniqueDeviceId == localUdid) {
148 ACCESSTOKEN_LOG_INFO(LABEL, "no need notify local device");
149 continue;
150 }
151
152 const std::shared_ptr<UpdateRemoteHapTokenCommand> updateRemoteHapTokenCommand =
153 RemoteCommandFactory::GetInstance().NewUpdateRemoteHapTokenCommand(ConstantCommon::GetLocalDeviceId(),
154 device.deviceId.uniqueDeviceId, tokenInfo);
155
156 const int32_t resultCode = RemoteCommandManager::GetInstance().ExecuteCommand(
157 device.deviceId.uniqueDeviceId, updateRemoteHapTokenCommand);
158 if (resultCode != Constant::SUCCESS) {
159 ACCESSTOKEN_LOG_INFO(LABEL,
160 "RemoteExecutorManager executeCommand updateRemoteHapTokenCommand failed, return %{public}d",
161 resultCode);
162 continue;
163 }
164 ACCESSTOKEN_LOG_INFO(LABEL, "get resultCode: %{public}d", resultCode);
165 }
166
167 return TOKEN_SYNC_SUCCESS;
168 }
169
Initialize()170 bool TokenSyncManagerService::Initialize()
171 {
172 sendRunner_ = AppExecFwk::EventRunner::Create(true);
173 if (!sendRunner_) {
174 ACCESSTOKEN_LOG_ERROR(LABEL, "failed to create a sendRunner.");
175 return false;
176 }
177
178 sendHandler_ = std::make_shared<TokenSyncEventHandler>(sendRunner_);
179 if (!sendHandler_) {
180 ACCESSTOKEN_LOG_ERROR(LABEL, "sendHandler_ is nullptr.");
181 return false;
182 }
183
184 recvRunner_ = AppExecFwk::EventRunner::Create(true);
185 if (!recvRunner_) {
186 ACCESSTOKEN_LOG_ERROR(LABEL, "failed to create a recvRunner.");
187 return false;
188 }
189
190 recvHandler_ = std::make_shared<TokenSyncEventHandler>(recvRunner_);
191 if (!recvHandler_) {
192 ACCESSTOKEN_LOG_ERROR(LABEL, "recvHandler_ is nullptr.");
193 return false;
194 }
195
196 SoftBusManager::GetInstance().Initialize();
197 return true;
198 }
199 } // namespace AccessToken
200 } // namespace Security
201 } // namespace OHOS
202