1 /*
2 * Copyright (c) 2022-2024 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 #include "soft_bus_manager.h"
16
17 #include <securec.h>
18 #include <thread>
19 #include <pthread.h>
20
21 #include "accesstoken_common_log.h"
22 #include "constant.h"
23 #include "constant_common.h"
24 #include "device_info_manager.h"
25 #include "device_manager.h"
26 #include "ipc_skeleton.h"
27 #include "json_parse_loader.h"
28 #include "libraryloader.h"
29 #include "remote_command_manager.h"
30 #include "soft_bus_device_connection_listener.h"
31 #include "soft_bus_socket_listener.h"
32 #include "token_setproc.h"
33
34 namespace OHOS {
35 namespace Security {
36 namespace AccessToken {
37 namespace {
38 static constexpr int32_t DEFAULT_SEND_REQUEST_REPEAT_TIMES = 5;
39 }
40 namespace {
41 static const int MAX_PTHREAD_NAME_LEN = 15; // pthread name max length
42
43 static const std::string TOKEN_SYNC_PACKAGE_NAME = "ohos.security.distributed_access_token";
44 static const std::string TOKEN_SYNC_SOCKET_NAME = "ohos.security.atm_channel.";
45
46 static const uint32_t SOCKET_NAME_MAX_LEN = 256;
47 static const uint32_t QOS_LEN = 3;
48 static const int32_t MIN_BW = 64 * 1024; // 64k
49 static const int32_t MAX_LATENCY = 10000; // 10s
50 static const int32_t MIN_LATENCY = 2000; // 2s
51
52 static const int32_t ERROR_TRANSFORM_STRING_TO_CHAR = -1;
53 static const int32_t ERROR_CREATE_SOCKET_FAIL = -2;
54 static const int32_t ERROR_CREATE_LISTENER_FAIL = -3;
55 static const int32_t ERROR_CLIENT_HAS_BIND_ALREADY = -4;
56
57 static const int32_t BIND_SERVICE_MAX_RETRY_TIMES = 10;
58 static const int32_t BIND_SERVICE_SLEEP_TIMES_MS = 100; // 0.1s
59 std::recursive_mutex g_instanceMutex;
60 } // namespace
61
SoftBusManager()62 SoftBusManager::SoftBusManager() : isSoftBusServiceBindSuccess_(false), inited_(false), mutex_(), fulfillMutex_()
63 {
64 LOGD(ATM_DOMAIN, ATM_TAG, "SoftBusManager()");
65 }
66
~SoftBusManager()67 SoftBusManager::~SoftBusManager()
68 {
69 LOGD(ATM_DOMAIN, ATM_TAG, "~SoftBusManager()");
70 }
71
GetInstance()72 SoftBusManager &SoftBusManager::GetInstance()
73 {
74 static SoftBusManager* instance = nullptr;
75 if (instance == nullptr) {
76 std::lock_guard<std::recursive_mutex> lock(g_instanceMutex);
77 if (instance == nullptr) {
78 SoftBusManager* tmp = new (std::nothrow) SoftBusManager();
79 instance = std::move(tmp);
80 }
81 }
82 return *instance;
83 }
84
AddTrustedDeviceInfo()85 int SoftBusManager::AddTrustedDeviceInfo()
86 {
87 std::string packageName = TOKEN_SYNC_PACKAGE_NAME;
88 std::string extra = "";
89 std::vector<DistributedHardware::DmDeviceInfo> deviceList;
90
91 int32_t ret = DistributedHardware::DeviceManager::GetInstance().GetTrustedDeviceList(packageName,
92 extra, deviceList);
93 if (ret != Constant::SUCCESS) {
94 LOGE(ATM_DOMAIN, ATM_TAG, "AddTrustedDeviceInfo: GetTrustedDeviceList error, result: %{public}d", ret);
95 return Constant::FAILURE;
96 }
97
98 for (const DistributedHardware::DmDeviceInfo& device : deviceList) {
99 std::string uuid;
100 std::string udid;
101 DistributedHardware::DeviceManager::GetInstance().GetUuidByNetworkId(TOKEN_SYNC_PACKAGE_NAME, device.networkId,
102 uuid);
103 DistributedHardware::DeviceManager::GetInstance().GetUdidByNetworkId(TOKEN_SYNC_PACKAGE_NAME, device.networkId,
104 udid);
105 if (uuid.empty() || udid.empty()) {
106 LOGE(ATM_DOMAIN, ATM_TAG, "Uuid = %{public}s, udid = %{public}s, uuid or udid is empty, abort.",
107 ConstantCommon::EncryptDevId(uuid).c_str(), ConstantCommon::EncryptDevId(udid).c_str());
108 continue;
109 }
110
111 DeviceInfoManager::GetInstance().AddDeviceInfo(device.networkId, uuid, udid, device.deviceName,
112 std::to_string(device.deviceTypeId));
113 RemoteCommandManager::GetInstance().NotifyDeviceOnline(udid);
114 }
115
116 return Constant::SUCCESS;
117 }
118
DeviceInit()119 int SoftBusManager::DeviceInit()
120 {
121 std::string packageName = TOKEN_SYNC_PACKAGE_NAME;
122 std::shared_ptr<TokenSyncDmInitCallback> ptrDmInitCallback = std::make_shared<TokenSyncDmInitCallback>();
123
124 int ret = DistributedHardware::DeviceManager::GetInstance().InitDeviceManager(packageName, ptrDmInitCallback);
125 if (ret != ERR_OK) {
126 LOGE(ATM_DOMAIN, ATM_TAG, "Initialize: InitDeviceManager error, result: %{public}d", ret);
127 return ret;
128 }
129
130 ret = AddTrustedDeviceInfo();
131 if (ret != ERR_OK) {
132 LOGE(ATM_DOMAIN, ATM_TAG, "Initialize: AddTrustedDeviceInfo error, result: %{public}d", ret);
133 return ret;
134 }
135
136 std::string extra = "";
137 std::shared_ptr<SoftBusDeviceConnectionListener> ptrDeviceStateCallback =
138 std::make_shared<SoftBusDeviceConnectionListener>();
139 ret = DistributedHardware::DeviceManager::GetInstance().RegisterDevStateCallback(packageName, extra,
140 ptrDeviceStateCallback);
141 if (ret != ERR_OK) {
142 LOGE(ATM_DOMAIN, ATM_TAG, "Initialize: RegisterDevStateCallback error, result: %{public}d", ret);
143 return ret;
144 }
145
146 return ERR_OK;
147 }
148
CheckAndCopyStr(char * dest,uint32_t destLen,const std::string & src)149 bool SoftBusManager::CheckAndCopyStr(char* dest, uint32_t destLen, const std::string& src)
150 {
151 if (destLen < src.length() + 1) {
152 LOGE(ATM_DOMAIN, ATM_TAG, "Invalid src length");
153 return false;
154 }
155 if (strcpy_s(dest, destLen, src.c_str()) != EOK) {
156 LOGE(ATM_DOMAIN, ATM_TAG, "Invalid src");
157 return false;
158 }
159 return true;
160 }
161
ServiceSocketInit()162 int32_t SoftBusManager::ServiceSocketInit()
163 {
164 std::string serviceName = TOKEN_SYNC_SOCKET_NAME + "service";
165 char name[SOCKET_NAME_MAX_LEN + 1];
166 if (!CheckAndCopyStr(name, SOCKET_NAME_MAX_LEN, serviceName)) {
167 return ERROR_TRANSFORM_STRING_TO_CHAR;
168 }
169
170 char pkgName[SOCKET_NAME_MAX_LEN + 1];
171 if (!CheckAndCopyStr(pkgName, SOCKET_NAME_MAX_LEN, TOKEN_SYNC_PACKAGE_NAME)) {
172 return ERROR_TRANSFORM_STRING_TO_CHAR;
173 }
174
175 SocketInfo info = {
176 .name = name,
177 .pkgName = pkgName,
178 .dataType = DATA_TYPE_BYTES
179 };
180 int32_t ret = ::Socket(info); // create service socket id
181 if (ret <= Constant::INVALID_SOCKET_FD) {
182 LOGE(ATM_DOMAIN, ATM_TAG, "Create service socket faild, ret is %{public}d.", ret);
183 return ERROR_CREATE_SOCKET_FAIL;
184 } else {
185 socketFd_ = ret;
186 LOGD(ATM_DOMAIN, ATM_TAG, "Create service socket[%{public}d] success.", socketFd_);
187 }
188
189 // set service qos, no need to regist OnQos now, regist it
190 QosTV serverQos[] = {
191 { .qos = QOS_TYPE_MIN_BW, .value = MIN_BW },
192 { .qos = QOS_TYPE_MAX_LATENCY, .value = MAX_LATENCY },
193 { .qos = QOS_TYPE_MIN_LATENCY, .value = MIN_LATENCY },
194 };
195
196 ISocketListener listener;
197 listener.OnBind = SoftBusSocketListener::OnBind; // only service may receive OnBind
198 listener.OnShutdown = SoftBusSocketListener::OnShutdown;
199 listener.OnBytes = SoftBusSocketListener::OnClientBytes;
200
201 ret = ::Listen(socketFd_, serverQos, QOS_LEN, &listener);
202 if (ret != ERR_OK) {
203 LOGE(ATM_DOMAIN, ATM_TAG, "Create listener failed, ret is %{public}d.", ret);
204 return ERROR_CREATE_LISTENER_FAIL;
205 } else {
206 LOGD(ATM_DOMAIN, ATM_TAG, "Create listener success.");
207 }
208
209 return ERR_OK;
210 }
211
GetRepeatTimes()212 int32_t SoftBusManager::GetRepeatTimes()
213 {
214 // this value only set in service OnStart, no need lock when set and get
215 return sendRequestRepeatTimes_;
216 }
217
SetDefaultConfigValue()218 void SoftBusManager::SetDefaultConfigValue()
219 {
220 LOGI(ATM_DOMAIN, ATM_TAG, "No config file or config file is not valid, use default values");
221
222 sendRequestRepeatTimes_ = DEFAULT_SEND_REQUEST_REPEAT_TIMES;
223 }
224
GetConfigValue()225 void SoftBusManager::GetConfigValue()
226 {
227 LibraryLoader loader(CONFIG_PARSE_LIBPATH);
228 ConfigPolicyLoaderInterface* policy = loader.GetObject<ConfigPolicyLoaderInterface>();
229 if (policy == nullptr) {
230 LOGE(ATM_DOMAIN, ATM_TAG, "Dlopen libaccesstoken_json_parse failed.");
231 return;
232 }
233 AccessTokenConfigValue value;
234 if (policy->GetConfigValue(ServiceType::TOKENSYNC_SERVICE, value)) {
235 sendRequestRepeatTimes_ = value.tsConfig.sendRequestRepeatTimes == 0
236 ? DEFAULT_SEND_REQUEST_REPEAT_TIMES : value.tsConfig.sendRequestRepeatTimes;
237 } else {
238 SetDefaultConfigValue();
239 }
240
241 LOGI(ATM_DOMAIN, ATM_TAG, "SendRequestRepeatTimes_ is %{public}d.", sendRequestRepeatTimes_);
242 }
243
Initialize()244 void SoftBusManager::Initialize()
245 {
246 bool inited = false;
247 // cas failed means already inited.
248 if (!inited_.compare_exchange_strong(inited, true)) {
249 LOGD(ATM_DOMAIN, ATM_TAG, "Already initialized, skip");
250 return;
251 }
252
253 GetConfigValue();
254
255 std::function<void()> runner = [this]() {
256 std::string name = "SoftBusMagInit";
257 pthread_setname_np(pthread_self(), name.substr(0, MAX_PTHREAD_NAME_LEN).c_str());
258 std::unique_lock<std::mutex> lock(mutex_);
259
260 int ret = DeviceInit();
261 if (ret != ERR_OK) {
262 LOGE(ATM_DOMAIN, ATM_TAG, "Initialize thread started");
263 return;
264 }
265
266 ret = ServiceSocketInit();
267 if (ret != ERR_OK) {
268 return;
269 }
270
271 isSoftBusServiceBindSuccess_ = true;
272 this->FulfillLocalDeviceInfo();
273 };
274
275 std::thread initThread(runner);
276 initThread.detach();
277 LOGD(ATM_DOMAIN, ATM_TAG, "Initialize thread started");
278 }
279
Destroy()280 void SoftBusManager::Destroy()
281 {
282 LOGD(ATM_DOMAIN, ATM_TAG, "Destroy, init: %{public}d, isSoftBusServiceBindSuccess: %{public}d", inited_.load(),
283 isSoftBusServiceBindSuccess_);
284
285 if (!inited_.load()) {
286 LOGD(ATM_DOMAIN, ATM_TAG, "Not inited, skip");
287 return;
288 }
289
290 std::unique_lock<std::mutex> lock(mutex_);
291 if (!inited_.load()) {
292 LOGD(ATM_DOMAIN, ATM_TAG, "Not inited, skip");
293 return;
294 }
295
296 if (isSoftBusServiceBindSuccess_) {
297 if (socketFd_ > Constant::INVALID_SOCKET_FD) {
298 ::Shutdown(socketFd_);
299 }
300
301 LOGD(ATM_DOMAIN, ATM_TAG, "Destroy service socket.");
302
303 SoftBusSocketListener::CleanUpAllBindSocket();
304
305 LOGD(ATM_DOMAIN, ATM_TAG, "Destroy client socket.");
306
307 isSoftBusServiceBindSuccess_ = false;
308 }
309
310 std::string packageName = TOKEN_SYNC_PACKAGE_NAME;
311 int ret = DistributedHardware::DeviceManager::GetInstance().UnRegisterDevStateCallback(packageName);
312 if (ret != ERR_OK) {
313 LOGE(ATM_DOMAIN, ATM_TAG, "UnRegisterDevStateCallback failed, code: %{public}d", ret);
314 }
315 ret = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(packageName);
316 if (ret != ERR_OK) {
317 LOGE(ATM_DOMAIN, ATM_TAG, "UnInitDeviceManager failed, code: %{public}d", ret);
318 }
319
320 inited_.store(false);
321
322 LOGD(ATM_DOMAIN, ATM_TAG, "Destroy, done");
323 }
324
InitSocketAndListener(const std::string & networkId,ISocketListener & listener)325 int32_t SoftBusManager::InitSocketAndListener(const std::string& networkId, ISocketListener& listener)
326 {
327 std::string clientName = TOKEN_SYNC_SOCKET_NAME + networkId;
328 char name[SOCKET_NAME_MAX_LEN + 1];
329 if (!CheckAndCopyStr(name, SOCKET_NAME_MAX_LEN, clientName)) {
330 return ERROR_TRANSFORM_STRING_TO_CHAR;
331 }
332
333 std::string serviceName = TOKEN_SYNC_SOCKET_NAME + "service";
334 char peerName[SOCKET_NAME_MAX_LEN + 1];
335 if (!CheckAndCopyStr(peerName, SOCKET_NAME_MAX_LEN, serviceName)) {
336 return ERROR_TRANSFORM_STRING_TO_CHAR;
337 }
338
339 char peerNetworkId[SOCKET_NAME_MAX_LEN + 1];
340 if (!CheckAndCopyStr(peerNetworkId, SOCKET_NAME_MAX_LEN, networkId)) {
341 return ERROR_TRANSFORM_STRING_TO_CHAR;
342 }
343
344 char pkgName[SOCKET_NAME_MAX_LEN + 1];
345 if (!CheckAndCopyStr(pkgName, SOCKET_NAME_MAX_LEN, TOKEN_SYNC_PACKAGE_NAME)) {
346 return ERROR_TRANSFORM_STRING_TO_CHAR;
347 }
348
349 SocketInfo info = {
350 .name = name,
351 .peerName = peerName,
352 .peerNetworkId = peerNetworkId,
353 .pkgName = pkgName,
354 .dataType = DATA_TYPE_BYTES
355 };
356
357 listener.OnShutdown = SoftBusSocketListener::OnShutdown;
358 listener.OnBytes = SoftBusSocketListener::OnServiceBytes;
359 listener.OnQos = SoftBusSocketListener::OnQos; // only client may receive OnQos
360
361 return ::Socket(info);
362 }
363
BindService(const std::string & deviceId)364 int32_t SoftBusManager::BindService(const std::string &deviceId)
365 {
366 #ifdef DEBUG_API_PERFORMANCE
367 LOGI(ATM_DOMAIN, ATM_TAG, "Api_performance:start bind service");
368 #endif
369
370 DeviceInfo info;
371 bool result = DeviceInfoManager::GetInstance().GetDeviceInfo(deviceId, DeviceIdType::UNKNOWN, info);
372 if (!result) {
373 LOGW(ATM_DOMAIN, ATM_TAG, "Device info not found for deviceId %{public}s",
374 ConstantCommon::EncryptDevId(deviceId).c_str());
375 return Constant::FAILURE;
376 }
377 std::string networkId = info.deviceId.networkId;
378
379 ISocketListener listener;
380 int32_t socketFd = InitSocketAndListener(networkId, listener);
381 if (socketFd_ <= Constant::INVALID_SOCKET_FD) {
382 LOGE(ATM_DOMAIN, ATM_TAG, "Create client socket faild.");
383 return ERROR_CREATE_SOCKET_FAIL;
384 }
385
386 {
387 std::lock_guard<std::mutex> guard(clientSocketMutex_);
388 auto iter = clientSocketMap_.find(socketFd);
389 if (iter == clientSocketMap_.end()) {
390 clientSocketMap_.insert(std::pair<int32_t, std::string>(socketFd, networkId));
391 } else {
392 LOGE(ATM_DOMAIN, ATM_TAG, "Client socket has bind already");
393 return ERROR_CLIENT_HAS_BIND_ALREADY;
394 }
395 }
396
397 QosTV clientQos[] = {
398 { .qos = QOS_TYPE_MIN_BW, .value = MIN_BW },
399 { .qos = QOS_TYPE_MAX_LATENCY, .value = MAX_LATENCY },
400 { .qos = QOS_TYPE_MIN_LATENCY, .value = MIN_LATENCY },
401 };
402
403 AccessTokenID firstCaller = IPCSkeleton::GetFirstTokenID();
404 SetFirstCallerTokenID(firstCaller);
405 LOGI(ATM_DOMAIN, ATM_TAG, "Bind service and setFirstCaller %{public}u.", firstCaller);
406
407 // retry 10 times or bind success
408 int32_t retryTimes = 0;
409 auto sleepTime = std::chrono::milliseconds(BIND_SERVICE_SLEEP_TIMES_MS);
410 while (retryTimes < BIND_SERVICE_MAX_RETRY_TIMES) {
411 int32_t res = ::Bind(socketFd, clientQos, QOS_LEN, &listener);
412 if (res != Constant::SUCCESS) {
413 std::this_thread::sleep_for(sleepTime);
414 retryTimes++;
415 continue;
416 }
417 break;
418 }
419
420 LOGD(ATM_DOMAIN, ATM_TAG, "Bind service succeed, socketFd is %{public}d.", socketFd);
421 return socketFd;
422 }
423
CloseSocket(int socketFd)424 int SoftBusManager::CloseSocket(int socketFd)
425 {
426 if (socketFd <= Constant::INVALID_SOCKET_FD) {
427 LOGI(ATM_DOMAIN, ATM_TAG, "Socket is invalid");
428 return Constant::FAILURE;
429 }
430
431 ::Shutdown(socketFd);
432
433 std::lock_guard<std::mutex> guard(clientSocketMutex_);
434 auto iter = clientSocketMap_.find(socketFd);
435 if (iter != clientSocketMap_.end()) {
436 clientSocketMap_.erase(iter);
437 }
438
439 LOGI(ATM_DOMAIN, ATM_TAG, "Close socket");
440
441 return Constant::SUCCESS;
442 }
443
GetNetworkIdBySocket(const int32_t socket,std::string & networkId)444 bool SoftBusManager::GetNetworkIdBySocket(const int32_t socket, std::string& networkId)
445 {
446 std::lock_guard<std::mutex> guard(clientSocketMutex_);
447 auto iter = clientSocketMap_.find(socket);
448 if (iter != clientSocketMap_.end()) {
449 networkId = iter->second;
450 return true;
451 }
452 return false;
453 }
454
GetUniversallyUniqueIdByNodeId(const std::string & networkId)455 std::string SoftBusManager::GetUniversallyUniqueIdByNodeId(const std::string &networkId)
456 {
457 if (!DataValidator::IsDeviceIdValid(networkId)) {
458 LOGE(ATM_DOMAIN, ATM_TAG, "Invalid networkId, empty or size extends 256");
459 return "";
460 }
461
462 std::string uuid;
463 DistributedHardware::DeviceManager::GetInstance().GetUuidByNetworkId(TOKEN_SYNC_PACKAGE_NAME, networkId, uuid);
464 if (uuid.empty()) {
465 LOGE(ATM_DOMAIN, ATM_TAG, "Softbus return null or empty string");
466 return "";
467 }
468
469 DeviceInfo info;
470 bool result = DeviceInfoManager::GetInstance().GetDeviceInfo(uuid, DeviceIdType::UNIVERSALLY_UNIQUE_ID, info);
471 if (!result) {
472 LOGD(ATM_DOMAIN, ATM_TAG, "Local device info not found for uuid %{public}s",
473 ConstantCommon::EncryptDevId(uuid).c_str());
474 } else {
475 std::string dimUuid = info.deviceId.universallyUniqueId;
476 if (uuid == dimUuid) {
477 // refresh cache
478 std::function<void()> fulfillDeviceInfo = [this]() {this->FulfillLocalDeviceInfo();};
479 std::thread fulfill(fulfillDeviceInfo);
480 fulfill.detach();
481 }
482 }
483
484 return uuid;
485 }
486
GetUniqueDeviceIdByNodeId(const std::string & networkId)487 std::string SoftBusManager::GetUniqueDeviceIdByNodeId(const std::string &networkId)
488 {
489 if (!DataValidator::IsDeviceIdValid(networkId)) {
490 LOGE(ATM_DOMAIN, ATM_TAG, "Invalid networkId: %{public}s", ConstantCommon::EncryptDevId(networkId).c_str());
491 return "";
492 }
493 std::string udid;
494 DistributedHardware::DeviceManager::GetInstance().GetUdidByNetworkId(TOKEN_SYNC_PACKAGE_NAME, networkId, udid);
495 if (udid.empty()) {
496 LOGE(ATM_DOMAIN, ATM_TAG, "Softbus return null or empty string: %{public}s",
497 ConstantCommon::EncryptDevId(udid).c_str());
498 return "";
499 }
500 std::string localUdid = ConstantCommon::GetLocalDeviceId();
501 if (udid == localUdid) {
502 // refresh cache
503 std::function<void()> fulfillDeviceInfo = [this]() {this->FulfillLocalDeviceInfo();};
504 std::thread fulfill(fulfillDeviceInfo);
505 fulfill.detach();
506 }
507 return udid;
508 }
509
FulfillLocalDeviceInfo()510 int SoftBusManager::FulfillLocalDeviceInfo()
511 {
512 // repeated task will just skip
513 if (!fulfillMutex_.try_lock()) {
514 LOGI(ATM_DOMAIN, ATM_TAG, "FulfillLocalDeviceInfo already running, skip.");
515 return Constant::SUCCESS;
516 }
517
518 DistributedHardware::DmDeviceInfo deviceInfo;
519 int32_t res = DistributedHardware::DeviceManager::GetInstance().GetLocalDeviceInfo(TOKEN_SYNC_PACKAGE_NAME,
520 deviceInfo);
521 if (res != Constant::SUCCESS) {
522 LOGE(ATM_DOMAIN, ATM_TAG, "GetLocalDeviceInfo error");
523 fulfillMutex_.unlock();
524 return Constant::FAILURE;
525 }
526 std::string networkId = std::string(deviceInfo.networkId);
527
528 std::string uuid;
529 std::string udid;
530
531 DistributedHardware::DeviceManager::GetInstance().GetUuidByNetworkId(TOKEN_SYNC_PACKAGE_NAME, networkId, uuid);
532 DistributedHardware::DeviceManager::GetInstance().GetUdidByNetworkId(TOKEN_SYNC_PACKAGE_NAME, networkId, udid);
533 if (uuid.empty() || udid.empty()) {
534 LOGE(ATM_DOMAIN, ATM_TAG, "FulfillLocalDeviceInfo: uuid or udid is empty, abort.");
535 fulfillMutex_.unlock();
536 return Constant::FAILURE;
537 }
538
539 DeviceInfoManager::GetInstance().AddDeviceInfo(networkId, uuid, udid, std::string(deviceInfo.deviceName),
540 std::to_string(deviceInfo.deviceTypeId));
541 LOGD(ATM_DOMAIN, ATM_TAG, "AddDeviceInfo finished");
542
543 fulfillMutex_.unlock();
544 return Constant::SUCCESS;
545 }
546 } // namespace AccessToken
547 } // namespace Security
548 } // namespace OHOS
549