1 /*
2 * Copyright (c) 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
16 #include "soft_bus_manager.h"
17
18 #include <cinttypes>
19 #include <string>
20 #include <thread>
21 #include "socket.h"
22
23 #include "device_state_listener.h"
24 #include "device_manager.h"
25 #include "iam_logger.h"
26 #include "iservice_registry.h"
27 #include "remote_connect_listener_manager.h"
28 #include "socket_factory.h"
29 #include "soft_bus_base_socket.h"
30 #include "softbus_error_code.h"
31 #include "soft_bus_socket_listener.h"
32 #include "system_ability_definition.h"
33 #include "thread_handler.h"
34 #include "thread_handler_manager.h"
35 #include "token_setproc.h"
36
37 #define LOG_TAG "USER_AUTH_SA"
38 namespace OHOS {
39 namespace UserIam {
40 namespace UserAuth {
41 using namespace OHOS::DistributedHardware;
42 static const std::string USER_AUTH_SOCKET_NAME = "ohos.useriam.";
43 static constexpr uint32_t SOCKET_NAME_MAX_LEN = 256;
44 static constexpr uint32_t PACKAGE_NAME_MAX_LEN = 256;
45
46 static constexpr uint32_t QOS_LEN = 3;
47 static constexpr int32_t MIN_BW = 1024 * 1024; // 1M
48 static constexpr int32_t MAX_LATENCY = 30 * 1000; // 30s
49 static constexpr int32_t MIN_LATENCY = 100; // 100ms
50 static constexpr int32_t MAX_TIMEOUT = 3 * 60 * 1000; // 3min
51
52 static constexpr int32_t BIND_SERVICE_MAX_RETRY_TIMES = 3;
53 static constexpr int32_t BIND_SERVICE_SLEEP_TIMES_MS = 100; // 0.1s
54
55 static const int32_t MAX_ONBYTES_RECEIVED_DATA_LEN = 1024 * 1024 * 10;
56
SoftBusManager()57 SoftBusManager::SoftBusManager()
58 {
59 IAM_LOGD("start.");
60 }
61
~SoftBusManager()62 SoftBusManager::~SoftBusManager()
63 {
64 IAM_LOGD("start.");
65 }
66
GetInstance()67 SoftBusManager &SoftBusManager::GetInstance()
68 {
69 IAM_LOGD("start.");
70 static SoftBusManager instance;
71 return instance;
72 }
73
Start()74 void SoftBusManager::Start()
75 {
76 IAM_LOGD("start.");
77 std::unique_lock<std::recursive_mutex> lock(mutex_);
78 if (inited_) {
79 IAM_LOGI("already initialized, skip");
80 return;
81 }
82 ResultCode ret = RegistDeviceManagerListener();
83 if (ret != SUCCESS) {
84 IAM_LOGE("RegistDeviceManagerListener fail");
85 return;
86 }
87 ret = RegistSoftBusListener();
88 if (ret != SUCCESS) {
89 IAM_LOGE("RegistSoftBusListener fail");
90 return;
91 }
92 inited_ = true;
93 }
94
Stop()95 void SoftBusManager::Stop()
96 {
97 IAM_LOGD("start.");
98 std::unique_lock<std::recursive_mutex> lock(mutex_);
99 if (!inited_) {
100 IAM_LOGI("not inited, skip");
101 return;
102 }
103 ResultCode ret = UnRegistDeviceManagerListener();
104 if (ret != SUCCESS) {
105 IAM_LOGE("UnRegistDeviceManagerListener fail");
106 return;
107 }
108 ret = UnRegistSoftBusListener();
109 if (ret != SUCCESS) {
110 IAM_LOGE("UnRegistSoftBusListener fail");
111 return;
112 }
113 inited_ = false;
114 }
115
RegistDeviceManagerListener()116 ResultCode SoftBusManager::RegistDeviceManagerListener()
117 {
118 IAM_LOGD("start.");
119 std::lock_guard<std::recursive_mutex> lock(deviceManagerMutex_);
120 if (deviceManagerServiceListener_ != nullptr) {
121 IAM_LOGI("deviceManagerServiceListener_ is not nullptr.");
122 return SUCCESS;
123 }
124
125 deviceManagerServiceListener_ = SystemAbilityListener::Subscribe(
126 "device_manager", DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID,
127 []() {
128 SoftBusManager::GetInstance().DeviceInit();
129 },
130 []() {
131 SoftBusManager::GetInstance().DeviceUnInit();
132 });
133 if (deviceManagerServiceListener_ == nullptr) {
134 IAM_LOGE("deviceManagerServiceListener_ is nullptr.");
135 return GENERAL_ERROR;
136 }
137
138 IAM_LOGI("RegistDeviceManagerListener success.");
139 return SUCCESS;
140 }
141
UnRegistDeviceManagerListener()142 ResultCode SoftBusManager::UnRegistDeviceManagerListener()
143 {
144 IAM_LOGD("start.");
145 std::lock_guard<std::recursive_mutex> lock(deviceManagerMutex_);
146 if (deviceManagerServiceListener_ == nullptr) {
147 IAM_LOGI("deviceManagerServiceListener_ is nullptr.");
148 return SUCCESS;
149 }
150
151 int32_t ret = SystemAbilityListener::UnSubscribe(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID,
152 deviceManagerServiceListener_);
153 if (ret != SUCCESS) {
154 IAM_LOGE("UnSubscribe service fail.");
155 return GENERAL_ERROR;
156 }
157
158 deviceManagerServiceListener_ = nullptr;
159 IAM_LOGI("UnRegistDeviceManagerListener success.");
160 return SUCCESS;
161 }
162
RegistSoftBusListener()163 ResultCode SoftBusManager::RegistSoftBusListener()
164 {
165 IAM_LOGD("start.");
166 std::lock_guard<std::recursive_mutex> lock(softBusMutex_);
167 if (softBusServiceListener_ != nullptr) {
168 IAM_LOGI("softBusServiceListener_ is not nullptr.");
169 return SUCCESS;
170 }
171
172 softBusServiceListener_ = SystemAbilityListener::Subscribe(
173 "softbus_server", SOFTBUS_SERVER_SA_ID,
174 []() {
175 SoftBusManager::GetInstance().ServiceSocketInit();
176 },
177 []() {
178 SoftBusManager::GetInstance().ServiceSocketUnInit();
179 });
180 if (softBusServiceListener_ == nullptr) {
181 IAM_LOGE("softBusServiceListener_ is nullptr.");
182 return GENERAL_ERROR;
183 }
184
185 IAM_LOGI("RegistSoftBusListener success.");
186 return SUCCESS;
187 }
188
UnRegistSoftBusListener()189 ResultCode SoftBusManager::UnRegistSoftBusListener()
190 {
191 IAM_LOGD("start.");
192 std::lock_guard<std::recursive_mutex> lock(softBusMutex_);
193 if (softBusServiceListener_ == nullptr) {
194 IAM_LOGI("softBusServiceListener_ is nullptr.");
195 return SUCCESS;
196 }
197
198 int32_t ret = SystemAbilityListener::UnSubscribe(SOFTBUS_SERVER_SA_ID, softBusServiceListener_);
199 if (ret != SUCCESS) {
200 IAM_LOGE("UnSubscribe service fail.");
201 return GENERAL_ERROR;
202 }
203
204 softBusServiceListener_ = nullptr;
205 IAM_LOGI("UnRegistSoftBusListener success.");
206 return SUCCESS;
207 }
208
DeviceInit()209 ResultCode SoftBusManager::DeviceInit()
210 {
211 IAM_LOGD("start.");
212 auto dmInitCallback = Common::MakeShared<IamDmInitCallback>();
213 if (dmInitCallback == nullptr) {
214 IAM_LOGE("dmInitCallback create fail");
215 return GENERAL_ERROR;
216 }
217
218 int ret = DeviceManager::GetInstance().InitDeviceManager(USER_AUTH_PACKAGE_NAME, dmInitCallback);
219 if (ret != SUCCESS) {
220 IAM_LOGE("Initialize: InitDeviceManager error, result: %{public}d", ret);
221 return GENERAL_ERROR;
222 }
223
224 return SUCCESS;
225 }
226
DeviceUnInit()227 void SoftBusManager::DeviceUnInit()
228 {
229 IAM_LOGD("start.");
230 int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(USER_AUTH_PACKAGE_NAME);
231 if (ret != SUCCESS) {
232 IAM_LOGE("UnInitDeviceManager failed, code: %{public}d", ret);
233 }
234
235 IAM_LOGI("DeviceUnInit success");
236 }
237
ServiceSocketListen(const int32_t socketId)238 ResultCode SoftBusManager::ServiceSocketListen(const int32_t socketId)
239 {
240 IAM_LOGD("start.");
241 QosTV serverQos[] = {
242 { .qos = QOS_TYPE_MIN_BW, .value = MIN_BW },
243 { .qos = QOS_TYPE_MAX_LATENCY, .value = MAX_LATENCY },
244 { .qos = QOS_TYPE_MIN_LATENCY, .value = MIN_LATENCY },
245 { .qos = QOS_TYPE_MAX_WAIT_TIMEOUT, .value = MAX_TIMEOUT },
246 };
247
248 ISocketListener listener;
249 listener.OnBind = SoftBusSocketListener::OnBind;
250 listener.OnShutdown = SoftBusSocketListener::OnShutdown;
251 listener.OnBytes = SoftBusSocketListener::OnClientBytes;
252 listener.OnNegotiate = SoftBusSocketListener::OnNegotiate;
253
254 int32_t ret = Listen(socketId, serverQos, QOS_LEN, &listener);
255 if (ret != SUCCESS) {
256 IAM_LOGE("create listener failed, ret is %{public}d.", ret);
257 return GENERAL_ERROR;
258 }
259
260 IAM_LOGI("ServiceSocketListen success.");
261 return SUCCESS;
262 }
263
ServiceSocketInit()264 void SoftBusManager::ServiceSocketInit()
265 {
266 auto handler = ThreadHandler::GetSingleThreadInstance();
267 IF_FALSE_LOGE_AND_RETURN(handler != nullptr);
268 handler->PostTask([=]() {
269 ResultCode ret = GENERAL_ERROR;
270 auto sleepTime = std::chrono::milliseconds(BIND_SERVICE_SLEEP_TIMES_MS);
271 for (int32_t retryTimes = 0; retryTimes < BIND_SERVICE_MAX_RETRY_TIMES; retryTimes++) {
272 ret = DoServiceSocketInit();
273 if (ret == SUCCESS) {
274 break;
275 }
276 std::this_thread::sleep_for(sleepTime);
277 }
278
279 IAM_LOGI("ServiceSocketInit result %{public}d.", ret);
280 });
281 }
282
DoServiceSocketInit()283 ResultCode SoftBusManager::DoServiceSocketInit()
284 {
285 IAM_LOGD("start.");
286 std::string serviceName = USER_AUTH_SOCKET_NAME + "service";
287 char name[SOCKET_NAME_MAX_LEN + 1];
288 if (!CheckAndCopyStr(name, SOCKET_NAME_MAX_LEN, serviceName)) {
289 IAM_LOGE("copy socket name fail");
290 return GENERAL_ERROR;
291 }
292
293 char pkgName[PACKAGE_NAME_MAX_LEN + 1];
294 if (!CheckAndCopyStr(pkgName, PACKAGE_NAME_MAX_LEN, USER_AUTH_PACKAGE_NAME)) {
295 IAM_LOGE("copy pkg name fail");
296 return GENERAL_ERROR;
297 }
298
299 SocketInfo info = {
300 .name = name,
301 .pkgName = pkgName,
302 .dataType = DATA_TYPE_BYTES
303 };
304 int32_t socketId = Socket(info);
305 if (socketId <= INVALID_SOCKET_ID) {
306 IAM_LOGE("create service socket failed.");
307 return GENERAL_ERROR;
308 }
309
310 int ret = ServiceSocketListen(socketId);
311 if (ret != SUCCESS) {
312 IAM_LOGE("socket listen failed, ret is %{public}d.", ret);
313 return GENERAL_ERROR;
314 }
315
316 auto serverSocket = SocketFactory::CreateServerSocket(socketId);
317 if (serverSocket == nullptr) {
318 IAM_LOGE("server socket create failed.");
319 return GENERAL_ERROR;
320 }
321
322 AddSocket(socketId, serverSocket);
323 SetServerSocket(serverSocket);
324 IAM_LOGI("ServiceSocketInit success.");
325 return SUCCESS;
326 }
327
ServiceSocketUnInit()328 void SoftBusManager::ServiceSocketUnInit()
329 {
330 IAM_LOGE("soft bus service is down.");
331 auto serverSocket = GetServerSocket();
332 if (serverSocket == nullptr) {
333 IAM_LOGI("serverSocket is nullptr.");
334 return;
335 }
336 DeleteSocket(serverSocket->GetSocketId());
337 ClearServerSocket();
338
339 std::vector<int32_t> socketIds;
340 {
341 std::lock_guard<std::recursive_mutex> lock(softBusMutex_);
342 socketIds.reserve(socketMap_.size());
343 for (const auto &iter : socketMap_) {
344 socketIds.push_back(iter.first);
345 }
346 }
347 for (int32_t socketId : socketIds) {
348 IAM_LOGI("service down shutdown socket %{public}d", socketId);
349 OnShutdown(socketId, SHUTDOWN_REASON_SERVICE_DIED);
350 }
351
352 IAM_LOGI("UnInitialize success");
353 }
354
ClientSocketInit(const std::string & connectionName,const std::string & networkId)355 int32_t SoftBusManager::ClientSocketInit(const std::string &connectionName, const std::string &networkId)
356 {
357 IAM_LOGD("start.");
358 std::string clientName = USER_AUTH_SOCKET_NAME + connectionName;
359 char name[SOCKET_NAME_MAX_LEN + 1];
360 if (!CheckAndCopyStr(name, SOCKET_NAME_MAX_LEN, clientName)) {
361 IAM_LOGE("copy socket name fail");
362 return INVALID_SOCKET_ID;
363 }
364
365 std::string serviceName = USER_AUTH_SOCKET_NAME + "service";
366 char peerName[SOCKET_NAME_MAX_LEN + 1];
367 if (!CheckAndCopyStr(peerName, SOCKET_NAME_MAX_LEN, serviceName)) {
368 IAM_LOGE("copy peer name fail");
369 return INVALID_SOCKET_ID;
370 }
371
372 char peerNetworkId[SOCKET_NAME_MAX_LEN + 1];
373 if (!CheckAndCopyStr(peerNetworkId, SOCKET_NAME_MAX_LEN, networkId)) {
374 IAM_LOGE("copy peer networkId name fail");
375 return INVALID_SOCKET_ID;
376 }
377
378 char pkgName[PACKAGE_NAME_MAX_LEN + 1];
379 if (!CheckAndCopyStr(pkgName, PACKAGE_NAME_MAX_LEN, USER_AUTH_PACKAGE_NAME)) {
380 IAM_LOGE("copy pkg name fail");
381 return INVALID_SOCKET_ID;
382 }
383
384 SocketInfo info = {
385 .name = name,
386 .peerName = peerName,
387 .peerNetworkId = peerNetworkId,
388 .pkgName = pkgName,
389 .dataType = DATA_TYPE_BYTES
390 };
391
392 return Socket(info);
393 }
394
ClientSocketBind(const int32_t socketId)395 ResultCode SoftBusManager::ClientSocketBind(const int32_t socketId)
396 {
397 IAM_LOGD("start.");
398 QosTV clientQos[] = {
399 { .qos = QOS_TYPE_MIN_BW, .value = MIN_BW },
400 { .qos = QOS_TYPE_MAX_LATENCY, .value = MAX_LATENCY },
401 { .qos = QOS_TYPE_MIN_LATENCY, .value = MIN_LATENCY },
402 };
403
404 ISocketListener listener;
405 listener.OnShutdown = SoftBusSocketListener::OnShutdown;
406 listener.OnBytes = SoftBusSocketListener::OnServerBytes;
407 listener.OnQos = SoftBusSocketListener::OnQos;
408
409 int32_t ret = SOFTBUS_INVALID_PARAM;
410 auto sleepTime = std::chrono::milliseconds(BIND_SERVICE_SLEEP_TIMES_MS);
411 for (int32_t retryTimes = 0; retryTimes < BIND_SERVICE_MAX_RETRY_TIMES; retryTimes++) {
412 ret = Bind(socketId, clientQos, QOS_LEN, &listener);
413 if (ret == SOFTBUS_OK) {
414 break;
415 }
416 std::this_thread::sleep_for(sleepTime);
417 }
418
419 if (ret != SOFTBUS_OK) {
420 IAM_LOGE("ClientSocketBind fail.");
421 return GENERAL_ERROR;
422 }
423 IAM_LOGI("ClientSocketBind success.");
424 return SUCCESS;
425 }
426
DoOpenConnectionInner(const std::string & connectionName,const uint32_t tokenId,const std::string & networkId,RemoteConnectOpenTrace & trace)427 ResultCode SoftBusManager::DoOpenConnectionInner(const std::string &connectionName, const uint32_t tokenId,
428 const std::string &networkId, RemoteConnectOpenTrace &trace)
429 {
430 trace.connectionName = connectionName;
431 trace.networkId = networkId;
432 int32_t ret = SetFirstCallerTokenID(tokenId);
433 if (ret != SUCCESS) {
434 IAM_LOGE("SetFirstCallerTokenID fail");
435 }
436
437 int32_t socketId = ClientSocketInit(connectionName, networkId);
438 if (socketId <= INVALID_SOCKET_ID) {
439 IAM_LOGE("create client socket failed.");
440 return GENERAL_ERROR;
441 }
442 trace.socketId = socketId;
443
444 auto clientSocket = SocketFactory::CreateClientSocket(socketId, connectionName, networkId);
445 if (clientSocket == nullptr) {
446 IAM_LOGE("CreateClientSocket failed, connectionName:%{public}s", connectionName.c_str());
447 return GENERAL_ERROR;
448 }
449
450 ret = ClientSocketBind(socketId);
451 if (ret != SUCCESS) {
452 IAM_LOGE("client socket bind service fail");
453 return GENERAL_ERROR;
454 }
455
456 AddConnection(connectionName, clientSocket);
457 AddSocket(socketId, clientSocket);
458 IAM_LOGI("Bind service success, connectionName:%{public}s socketId:%{public}d.", connectionName.c_str(), socketId);
459 return SUCCESS;
460 }
461
DoOpenConnection(const std::string & connectionName,const uint32_t tokenId,const std::string & networkId)462 void SoftBusManager::DoOpenConnection(const std::string &connectionName, const uint32_t tokenId,
463 const std::string &networkId)
464 {
465 IAM_LOGI("open connection %{public}s start.", connectionName.c_str());
466 RemoteConnectOpenTrace trace = {};
467 auto beginTime = std::chrono::steady_clock::now();
468 ResultCode result = DoOpenConnectionInner(connectionName, tokenId, networkId, trace);
469 auto endTime = std::chrono::steady_clock::now();
470 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - beginTime);
471 IAM_LOGI("connection %{public}s OpenConnectionDuration %{public}" PRIu64 " ms", connectionName.c_str(),
472 static_cast<uint64_t>(duration.count()));
473 trace.timeSpan = static_cast<uint64_t>(duration.count());
474 trace.operationResult = result;
475 ReportRemoteConnectOpen(trace);
476
477 if (result != SUCCESS) {
478 RemoteConnectListenerManager::GetInstance().OnConnectionDown(connectionName);
479 IAM_LOGE("open connection %{public}s fail", connectionName.c_str());
480 return;
481 }
482
483 RemoteConnectListenerManager::GetInstance().OnConnectionUp(connectionName);
484 IAM_LOGI("open connection %{public}s success.", connectionName.c_str());
485 }
486
OpenConnection(const std::string & connectionName,const uint32_t tokenId,const std::string & networkId)487 ResultCode SoftBusManager::OpenConnection(const std::string &connectionName, const uint32_t tokenId,
488 const std::string &networkId)
489 {
490 IAM_LOGD("start.");
491
492 ThreadHandlerManager::GetInstance().PostTask(connectionName, [=]() {
493 DoOpenConnection(connectionName, tokenId, networkId);
494 });
495
496 IAM_LOGI("Open connection %{public}s task added.", connectionName.c_str());
497 return SUCCESS;
498 }
499
DoCloseConnection(const std::string & connectionName)500 ResultCode SoftBusManager::DoCloseConnection(const std::string &connectionName)
501 {
502 IAM_LOGI("close connection %{public}s start.", connectionName.c_str());
503 std::shared_ptr<BaseSocket> clientSocket = FindClientSocket(connectionName);
504 if (clientSocket == nullptr) {
505 IAM_LOGE("clientSocket is nullptr");
506 return GENERAL_ERROR;
507 }
508
509 int32_t socketId = clientSocket->GetSocketId();
510 if (socketId == INVALID_SOCKET_ID) {
511 IAM_LOGE("socket id is invalid");
512 return GENERAL_ERROR;
513 }
514
515 RemoteConnectListenerManager::GetInstance().OnConnectionDown(connectionName);
516 DeleteSocket(socketId);
517 DeleteConnection(connectionName);
518 IAM_LOGI("close connection %{public}s socketId %{public}d success", connectionName.c_str(), socketId);
519 return SUCCESS;
520 }
521
CloseConnection(const std::string & connectionName)522 ResultCode SoftBusManager::CloseConnection(const std::string &connectionName)
523 {
524 IAM_LOGD("start.");
525
526 ThreadHandlerManager::GetInstance().PostTask(connectionName, [=]() {
527 DoCloseConnection(connectionName);
528 });
529
530 IAM_LOGI("Close connection %{public}s task added.", connectionName.c_str());
531 return SUCCESS;
532 }
533
SendMessage(const std::string & connectionName,const std::string & srcEndPoint,const std::string & destEndPoint,const std::shared_ptr<Attributes> & attributes,MsgCallback & callback)534 ResultCode SoftBusManager::SendMessage(const std::string &connectionName,
535 const std::string &srcEndPoint, const std::string &destEndPoint,
536 const std::shared_ptr<Attributes> &attributes, MsgCallback &callback)
537 {
538 IAM_LOGD("start.");
539 IF_FALSE_LOGE_AND_RETURN_VAL(attributes != nullptr, INVALID_PARAMETERS);
540
541 ResultCode ret = SUCCESS;
542 auto serverSocket = GetServerSocket();
543 IF_FALSE_LOGE_AND_RETURN_VAL(serverSocket != nullptr, GENERAL_ERROR);
544
545 ret = serverSocket->SendMessage(connectionName, srcEndPoint, destEndPoint, attributes, callback);
546 if (ret == SUCCESS) {
547 IAM_LOGI("SendMessage success");
548 return SUCCESS;
549 }
550 IAM_LOGI("try to send message using serverSocket fail, ret:%{public}d", ret);
551
552 std::shared_ptr<BaseSocket> clientSocket = FindClientSocket(connectionName);
553 if (clientSocket == nullptr) {
554 IAM_LOGE("failed to find clientSocket");
555 return GENERAL_ERROR;
556 }
557
558 ret = clientSocket->SendMessage(connectionName, srcEndPoint, destEndPoint, attributes, callback);
559 if (ret != SUCCESS) {
560 IAM_LOGE("clientSocket send message fail, ret:%{public}d", ret);
561 return GENERAL_ERROR;
562 }
563
564 IAM_LOGI("SendMessage success.");
565 return SUCCESS;
566 }
567
OnBind(int32_t socketId,PeerSocketInfo info)568 void SoftBusManager::OnBind(int32_t socketId, PeerSocketInfo info)
569 {
570 IAM_LOGI("socket id is %{public}d.", socketId);
571 if (socketId <= INVALID_SOCKET_ID) {
572 IAM_LOGE("socket id invalid.");
573 return;
574 }
575
576 auto serverSocket = GetServerSocket();
577 if (serverSocket == nullptr) {
578 IAM_LOGE("serverSocket is nullptr.");
579 return;
580 }
581
582 serverSocket->OnBind(socketId, info);
583 }
584
OnShutdown(int32_t socketId,ShutdownReason reason)585 void SoftBusManager::OnShutdown(int32_t socketId, ShutdownReason reason)
586 {
587 IAM_LOGI("socket id %{public}d shutdown because %{public}d.", socketId, reason);
588 if (socketId <= INVALID_SOCKET_ID) {
589 IAM_LOGE("socket id invalid.");
590 return;
591 }
592
593 auto serverSocket = GetServerSocket();
594 if (serverSocket != nullptr) {
595 serverSocket->OnShutdown(socketId, reason);
596 RemoteConnectFaultTrace serverSocketTrace = serverSocket->GetCurrTraceInfo();
597 serverSocketTrace.reason = "Shutdown:" + std::to_string(reason);
598 ReportConnectFaultTrace(serverSocketTrace);
599 }
600
601 auto clientSocket = FindSocketBySocketId(socketId);
602 if (clientSocket == nullptr) {
603 IAM_LOGI("clientSocket is nullptr.");
604 return;
605 }
606 clientSocket->OnShutdown(socketId, reason);
607 DeleteSocket(socketId);
608 DeleteConnection(clientSocket->GetConnectionName());
609 RemoteConnectFaultTrace clientSocketTrace = clientSocket->GetCurrTraceInfo();
610 clientSocketTrace.reason = "Shutdown:" + std::to_string(reason);
611 ReportConnectFaultTrace(clientSocketTrace);
612 IAM_LOGI("shutdown socket id %{public}d success.", socketId);
613 }
614
OnClientBytes(int32_t socketId,const void * data,uint32_t dataLen)615 void SoftBusManager::OnClientBytes(int32_t socketId, const void *data, uint32_t dataLen)
616 {
617 IAM_LOGI("socket fd %{public}d, recv len %{public}u.", socketId, dataLen);
618 if ((socketId <= INVALID_SOCKET_ID) || (data == nullptr) ||
619 (dataLen == 0) || (dataLen > MAX_ONBYTES_RECEIVED_DATA_LEN)) {
620 IAM_LOGE("params invalid.");
621 return;
622 }
623
624 auto serverSocket = GetServerSocket();
625 if (serverSocket == nullptr) {
626 IAM_LOGE("serverSocket is nullptr.");
627 return;
628 }
629
630 serverSocket->OnBytes(socketId, data, dataLen);
631 }
632
OnServerBytes(int32_t socketId,const void * data,uint32_t dataLen)633 void SoftBusManager::OnServerBytes(int32_t socketId, const void *data, uint32_t dataLen)
634 {
635 IAM_LOGI("socket fd %{public}d, recv len %{public}u.", socketId, dataLen);
636 if ((socketId <= INVALID_SOCKET_ID) || (data == nullptr) ||
637 (dataLen == 0) || (dataLen > MAX_ONBYTES_RECEIVED_DATA_LEN)) {
638 IAM_LOGE("params invalid.");
639 return;
640 }
641
642 auto clientSocket = FindSocketBySocketId(socketId);
643 if (clientSocket == nullptr) {
644 IAM_LOGE("clientSocket is nullptr.");
645 return;
646 }
647
648 clientSocket->OnBytes(socketId, data, dataLen);
649 }
650
AddSocket(const int32_t socketId,std::shared_ptr<BaseSocket> & socket)651 void SoftBusManager::AddSocket(const int32_t socketId, std::shared_ptr<BaseSocket> &socket)
652 {
653 IAM_LOGD("start.");
654 IF_FALSE_LOGE_AND_RETURN(socket != nullptr);
655 IF_FALSE_LOGE_AND_RETURN(socketId != INVALID_SOCKET_ID);
656
657 std::lock_guard<std::recursive_mutex> lock(socketMutex_);
658 socketMap_.insert(std::pair<int32_t, std::shared_ptr<BaseSocket>>(socketId, socket));
659 }
660
DeleteSocket(const int32_t socketId)661 void SoftBusManager::DeleteSocket(const int32_t socketId)
662 {
663 IAM_LOGD("start.");
664 IF_FALSE_LOGE_AND_RETURN(socketId != INVALID_SOCKET_ID);
665
666 std::lock_guard<std::recursive_mutex> lock(socketMutex_);
667 auto iter = socketMap_.find(socketId);
668 if (iter == socketMap_.end()) {
669 IAM_LOGE("socketId:%{public}d not found.", socketId);
670 return;
671 }
672 socketMap_.erase(socketId);
673 }
674
FindSocketBySocketId(const int32_t socketId)675 std::shared_ptr<BaseSocket> SoftBusManager::FindSocketBySocketId(const int32_t socketId)
676 {
677 IAM_LOGD("start.");
678 IF_FALSE_LOGE_AND_RETURN_VAL(socketId != INVALID_SOCKET_ID, nullptr);
679
680 std::lock_guard<std::recursive_mutex> lock(socketMutex_);
681 std::shared_ptr<BaseSocket> socket = nullptr;
682 auto iter = socketMap_.find(socketId);
683 if (iter != socketMap_.end()) {
684 socket = iter->second;
685 }
686 return socket;
687 }
688
CheckAndCopyStr(char * dest,uint32_t destLen,const std::string & src)689 bool SoftBusManager::CheckAndCopyStr(char *dest, uint32_t destLen, const std::string &src)
690 {
691 if (destLen < src.length() + 1) {
692 IAM_LOGE("Invalid src length");
693 return false;
694 }
695 if (strcpy_s(dest, destLen, src.c_str()) != EOK) {
696 IAM_LOGE("Invalid src");
697 return false;
698 }
699 return true;
700 }
701
SetServerSocket(std::shared_ptr<BaseSocket> & socket)702 void SoftBusManager::SetServerSocket(std::shared_ptr<BaseSocket> &socket)
703 {
704 IAM_LOGD("start.");
705 IF_FALSE_LOGE_AND_RETURN(socket != nullptr);
706 std::lock_guard<std::recursive_mutex> lock(ServerSocketMutex_);
707 serverSocket_ = socket;
708 }
709
ClearServerSocket()710 void SoftBusManager::ClearServerSocket()
711 {
712 IAM_LOGD("start.");
713 std::lock_guard<std::recursive_mutex> lock(ServerSocketMutex_);
714 serverSocket_ = nullptr;
715 }
716
AddConnection(const std::string & connectionName,std::shared_ptr<BaseSocket> & socket)717 void SoftBusManager::AddConnection(const std::string &connectionName, std::shared_ptr<BaseSocket> &socket)
718 {
719 IAM_LOGD("start.");
720 IF_FALSE_LOGE_AND_RETURN(socket != nullptr);
721
722 std::lock_guard<std::recursive_mutex> lock(connectionMutex_);
723 clientSocketMap_.insert(std::pair<std::string, std::shared_ptr<BaseSocket>>(connectionName, socket));
724 }
725
DeleteConnection(const std::string & connectionName)726 void SoftBusManager::DeleteConnection(const std::string &connectionName)
727 {
728 IAM_LOGD("start.");
729 std::lock_guard<std::recursive_mutex> lock(connectionMutex_);
730 auto iter = clientSocketMap_.find(connectionName);
731 if (iter == clientSocketMap_.end()) {
732 IAM_LOGE("connectionName:%{public}s not found.", connectionName.c_str());
733 return;
734 }
735 clientSocketMap_.erase(connectionName);
736 }
737
FindClientSocket(const std::string & connectionName)738 std::shared_ptr<BaseSocket> SoftBusManager::FindClientSocket(const std::string &connectionName)
739 {
740 IAM_LOGD("start.");
741 std::lock_guard<std::recursive_mutex> lock(connectionMutex_);
742 std::shared_ptr<BaseSocket> clientSocket = nullptr;
743 auto iter = clientSocketMap_.find(connectionName);
744 if (iter != clientSocketMap_.end()) {
745 clientSocket = iter->second;
746 }
747 return clientSocket;
748 }
749
GetServerSocket()750 std::shared_ptr<BaseSocket> SoftBusManager::GetServerSocket()
751 {
752 return serverSocket_;
753 }
754 } // namespace UserAuth
755 } // namespace UserIam
756 } // namespace OHOS