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
75 #ifdef EVENTHANDLER_ENABLE
GetSendEventHandler() const76 std::shared_ptr<AccessEventHandler> TokenSyncManagerService::GetSendEventHandler() const
77 {
78 return sendHandler_;
79 }
80
GetRecvEventHandler() const81 std::shared_ptr<AccessEventHandler> TokenSyncManagerService::GetRecvEventHandler() const
82 {
83 return recvHandler_;
84 }
85 #endif
86
GetRemoteHapTokenInfo(const std::string & deviceID,AccessTokenID tokenID)87 int TokenSyncManagerService::GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID)
88 {
89 if (!DataValidator::IsDeviceIdValid(deviceID) || tokenID == 0) {
90 ACCESSTOKEN_LOG_INFO(LABEL, "Params is wrong.");
91 return TOKEN_SYNC_PARAMS_INVALID;
92 }
93 DeviceInfo devInfo;
94 bool result = DeviceInfoRepository::GetInstance().FindDeviceInfo(deviceID, DeviceIdType::UNKNOWN, devInfo);
95 if (!result) {
96 ACCESSTOKEN_LOG_INFO(LABEL, "FindDeviceInfo failed");
97 return TOKEN_SYNC_REMOTE_DEVICE_INVALID;
98 }
99 std::string udid = devInfo.deviceId.uniqueDeviceId;
100 const std::shared_ptr<SyncRemoteHapTokenCommand> syncRemoteHapTokenCommand =
101 RemoteCommandFactory::GetInstance().NewSyncRemoteHapTokenCommand(ConstantCommon::GetLocalDeviceId(),
102 deviceID, tokenID);
103
104 const int32_t resultCode = RemoteCommandManager::GetInstance().ExecuteCommand(udid, syncRemoteHapTokenCommand);
105 if (resultCode != Constant::SUCCESS) {
106 ACCESSTOKEN_LOG_INFO(LABEL,
107 "RemoteExecutorManager executeCommand SyncRemoteHapTokenCommand failed, return %{public}d", resultCode);
108 return TOKEN_SYNC_COMMAND_EXECUTE_FAILED;
109 }
110 ACCESSTOKEN_LOG_INFO(LABEL, "get resultCode: %{public}d", resultCode);
111 return TOKEN_SYNC_SUCCESS;
112 }
113
DeleteRemoteHapTokenInfo(AccessTokenID tokenID)114 int TokenSyncManagerService::DeleteRemoteHapTokenInfo(AccessTokenID tokenID)
115 {
116 if (tokenID == 0) {
117 ACCESSTOKEN_LOG_INFO(LABEL, "Params is wrong, token id is invalid.");
118 return TOKEN_SYNC_PARAMS_INVALID;
119 }
120
121 std::vector<DeviceInfo> devices = DeviceInfoRepository::GetInstance().ListDeviceInfo();
122 std::string localUdid = ConstantCommon::GetLocalDeviceId();
123 for (const DeviceInfo& device : devices) {
124 if (device.deviceId.uniqueDeviceId == localUdid) {
125 ACCESSTOKEN_LOG_INFO(LABEL, "no need notify local device");
126 continue;
127 }
128 const std::shared_ptr<DeleteRemoteTokenCommand> deleteRemoteTokenCommand =
129 RemoteCommandFactory::GetInstance().NewDeleteRemoteTokenCommand(ConstantCommon::GetLocalDeviceId(),
130 device.deviceId.uniqueDeviceId, tokenID);
131
132 const int32_t resultCode = RemoteCommandManager::GetInstance().ExecuteCommand(
133 device.deviceId.uniqueDeviceId, deleteRemoteTokenCommand);
134 if (resultCode != Constant::SUCCESS) {
135 ACCESSTOKEN_LOG_INFO(LABEL,
136 "RemoteExecutorManager executeCommand DeleteRemoteTokenCommand failed, return %{public}d", resultCode);
137 continue;
138 }
139 ACCESSTOKEN_LOG_INFO(LABEL, "get resultCode: %{public}d", resultCode);
140 }
141 return TOKEN_SYNC_SUCCESS;
142 }
143
UpdateRemoteHapTokenInfo(const HapTokenInfoForSync & tokenInfo)144 int TokenSyncManagerService::UpdateRemoteHapTokenInfo(const HapTokenInfoForSync& tokenInfo)
145 {
146 std::vector<DeviceInfo> devices = DeviceInfoRepository::GetInstance().ListDeviceInfo();
147 std::string localUdid = ConstantCommon::GetLocalDeviceId();
148 for (const DeviceInfo& device : devices) {
149 if (device.deviceId.uniqueDeviceId == localUdid) {
150 ACCESSTOKEN_LOG_INFO(LABEL, "no need notify local device");
151 continue;
152 }
153
154 const std::shared_ptr<UpdateRemoteHapTokenCommand> updateRemoteHapTokenCommand =
155 RemoteCommandFactory::GetInstance().NewUpdateRemoteHapTokenCommand(ConstantCommon::GetLocalDeviceId(),
156 device.deviceId.uniqueDeviceId, tokenInfo);
157
158 const int32_t resultCode = RemoteCommandManager::GetInstance().ExecuteCommand(
159 device.deviceId.uniqueDeviceId, updateRemoteHapTokenCommand);
160 if (resultCode != Constant::SUCCESS) {
161 ACCESSTOKEN_LOG_INFO(LABEL,
162 "RemoteExecutorManager executeCommand updateRemoteHapTokenCommand failed, return %{public}d",
163 resultCode);
164 continue;
165 }
166 ACCESSTOKEN_LOG_INFO(LABEL, "get resultCode: %{public}d", resultCode);
167 }
168
169 return TOKEN_SYNC_SUCCESS;
170 }
171
Initialize()172 bool TokenSyncManagerService::Initialize()
173 {
174 #ifdef EVENTHANDLER_ENABLE
175 sendRunner_ = AppExecFwk::EventRunner::Create(true);
176 if (!sendRunner_) {
177 ACCESSTOKEN_LOG_ERROR(LABEL, "failed to create a sendRunner.");
178 return false;
179 }
180
181 sendHandler_ = std::make_shared<AccessEventHandler>(sendRunner_);
182 recvRunner_ = AppExecFwk::EventRunner::Create(true);
183 if (!recvRunner_) {
184 ACCESSTOKEN_LOG_ERROR(LABEL, "failed to create a recvRunner.");
185 return false;
186 }
187
188 recvHandler_ = std::make_shared<AccessEventHandler>(recvRunner_);
189 #endif
190 SoftBusManager::GetInstance().Initialize();
191 return true;
192 }
193 } // namespace AccessToken
194 } // namespace Security
195 } // namespace OHOS
196