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