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_log.h"
22 #include "config_policy_loader.h"
23 #include "constant.h"
24 #include "constant_common.h"
25 #include "device_info_manager.h"
26 #include "device_manager.h"
27 #include "ipc_skeleton.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 OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "SoftBusManager"};
39 static constexpr int32_t DEFAULT_SEND_REQUEST_REPEAT_TIMES = 5;
40 }
41 namespace {
42 static const int MAX_PTHREAD_NAME_LEN = 15; // pthread name max length
43 
44 static const std::string TOKEN_SYNC_PACKAGE_NAME = "ohos.security.distributed_access_token";
45 static const std::string TOKEN_SYNC_SOCKET_NAME = "ohos.security.atm_channel.";
46 
47 static const uint32_t SOCKET_NAME_MAX_LEN = 256;
48 static const uint32_t QOS_LEN = 3;
49 static const int32_t MIN_BW = 64 * 1024; // 64k
50 static const int32_t MAX_LATENCY = 10000; // 10s
51 static const int32_t MIN_LATENCY = 2000; // 2s
52 
53 static const int32_t ERROR_TRANSFORM_STRING_TO_CHAR = -1;
54 static const int32_t ERROR_CREATE_SOCKET_FAIL = -2;
55 static const int32_t ERROR_CREATE_LISTENER_FAIL = -3;
56 static const int32_t ERROR_CLIENT_HAS_BIND_ALREADY = -4;
57 
58 static const int32_t BIND_SERVICE_MAX_RETRY_TIMES = 10;
59 static const int32_t BIND_SERVICE_SLEEP_TIMES_MS = 100; // 0.1s
60 std::recursive_mutex g_instanceMutex;
61 } // namespace
62 
SoftBusManager()63 SoftBusManager::SoftBusManager() : isSoftBusServiceBindSuccess_(false), inited_(false), mutex_(), fulfillMutex_()
64 {
65     ACCESSTOKEN_LOG_DEBUG(LABEL, "SoftBusManager()");
66 }
67 
~SoftBusManager()68 SoftBusManager::~SoftBusManager()
69 {
70     ACCESSTOKEN_LOG_DEBUG(LABEL, "~SoftBusManager()");
71 }
72 
GetInstance()73 SoftBusManager &SoftBusManager::GetInstance()
74 {
75     static SoftBusManager* instance = nullptr;
76     if (instance == nullptr) {
77         std::lock_guard<std::recursive_mutex> lock(g_instanceMutex);
78         if (instance == nullptr) {
79             instance = new SoftBusManager();
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         ACCESSTOKEN_LOG_ERROR(LABEL, "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             ACCESSTOKEN_LOG_ERROR(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "Initialize: InitDeviceManager error, result: %{public}d", ret);
127         return ret;
128     }
129 
130     ret = AddTrustedDeviceInfo();
131     if (ret != ERR_OK) {
132         ACCESSTOKEN_LOG_ERROR(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "Invalid src length");
153         return false;
154     }
155     if (strcpy_s(dest, destLen, src.c_str()) != EOK) {
156         ACCESSTOKEN_LOG_ERROR(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "Create service socket faild, ret is %{public}d.", ret);
183         return ERROR_CREATE_SOCKET_FAIL;
184     } else {
185         socketFd_ = ret;
186         ACCESSTOKEN_LOG_DEBUG(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "Create listener failed, ret is %{public}d.", ret);
204         return ERROR_CREATE_LISTENER_FAIL;
205     } else {
206         ACCESSTOKEN_LOG_DEBUG(LABEL, "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     ACCESSTOKEN_LOG_INFO(LABEL, "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_POLICY_LIBPATH);
228     ConfigPolicyLoaderInterface* policy = loader.GetObject<ConfigPolicyLoaderInterface>();
229     if (policy == nullptr) {
230         ACCESSTOKEN_LOG_ERROR(LABEL, "Dlopen libaccesstoken_config_policy 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     ACCESSTOKEN_LOG_INFO(LABEL, "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         ACCESSTOKEN_LOG_DEBUG(LABEL, "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             ACCESSTOKEN_LOG_ERROR(LABEL, "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     ACCESSTOKEN_LOG_DEBUG(LABEL, "Initialize thread started");
278 }
279 
Destroy()280 void SoftBusManager::Destroy()
281 {
282     ACCESSTOKEN_LOG_DEBUG(LABEL, "Destroy, init: %{public}d, isSoftBusServiceBindSuccess: %{public}d", inited_.load(),
283         isSoftBusServiceBindSuccess_);
284 
285     if (!inited_.load()) {
286         ACCESSTOKEN_LOG_DEBUG(LABEL, "Not inited, skip");
287         return;
288     }
289 
290     std::unique_lock<std::mutex> lock(mutex_);
291     if (!inited_.load()) {
292         ACCESSTOKEN_LOG_DEBUG(LABEL, "Not inited, skip");
293         return;
294     }
295 
296     if (isSoftBusServiceBindSuccess_) {
297         if (socketFd_ > Constant::INVALID_SOCKET_FD) {
298             ::Shutdown(socketFd_);
299         }
300 
301         ACCESSTOKEN_LOG_DEBUG(LABEL, "Destroy service socket.");
302 
303         SoftBusSocketListener::CleanUpAllBindSocket();
304 
305         ACCESSTOKEN_LOG_DEBUG(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "UnRegisterDevStateCallback failed, code: %{public}d", ret);
314     }
315     ret = DistributedHardware::DeviceManager::GetInstance().UnInitDeviceManager(packageName);
316     if (ret != ERR_OK) {
317         ACCESSTOKEN_LOG_ERROR(LABEL, "UnInitDeviceManager failed, code: %{public}d", ret);
318     }
319 
320     inited_.store(false);
321 
322     ACCESSTOKEN_LOG_DEBUG(LABEL, "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     ACCESSTOKEN_LOG_INFO(LABEL, "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         ACCESSTOKEN_LOG_WARN(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "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             ACCESSTOKEN_LOG_ERROR(LABEL, "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     ACCESSTOKEN_LOG_INFO(LABEL, "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     ACCESSTOKEN_LOG_DEBUG(LABEL, "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         ACCESSTOKEN_LOG_INFO(LABEL, "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     ACCESSTOKEN_LOG_INFO(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "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         ACCESSTOKEN_LOG_DEBUG(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "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         ACCESSTOKEN_LOG_INFO(LABEL, "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         ACCESSTOKEN_LOG_ERROR(LABEL, "GetLocalDeviceInfo error");
523         fulfillMutex_.unlock();
524         return Constant::FAILURE;
525     }
526     std::string networkId = std::string(deviceInfo.networkId);
527 
528     ACCESSTOKEN_LOG_DEBUG(LABEL, "Call softbus finished, type:%{public}d", deviceInfo.deviceTypeId);
529 
530     std::string uuid;
531     std::string udid;
532 
533     DistributedHardware::DeviceManager::GetInstance().GetUuidByNetworkId(TOKEN_SYNC_PACKAGE_NAME, networkId, uuid);
534     DistributedHardware::DeviceManager::GetInstance().GetUdidByNetworkId(TOKEN_SYNC_PACKAGE_NAME, networkId, udid);
535     if (uuid.empty() || udid.empty()) {
536         ACCESSTOKEN_LOG_ERROR(LABEL, "FulfillLocalDeviceInfo: uuid or udid is empty, abort.");
537         fulfillMutex_.unlock();
538         return Constant::FAILURE;
539     }
540 
541     DeviceInfoManager::GetInstance().AddDeviceInfo(networkId, uuid, udid, std::string(deviceInfo.deviceName),
542         std::to_string(deviceInfo.deviceTypeId));
543     ACCESSTOKEN_LOG_DEBUG(LABEL, "AddDeviceInfo finished");
544 
545     fulfillMutex_.unlock();
546     return Constant::SUCCESS;
547 }
548 } // namespace AccessToken
549 } // namespace Security
550 } // namespace OHOS
551