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