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_ == true) {
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_ == false) {
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 LISTEN_SOCKET_FAILED;
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 CREATE_SOCKET_FAILED;
308     }
309 
310     int ret = ServiceSocketListen(socketId);
311     if (ret != SUCCESS) {
312         IAM_LOGE("socket listen failed, ret is %{public}d.", ret);
313         return LISTEN_SOCKET_FAILED;
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         for (const auto &iter : socketMap_) {
343             socketIds.push_back(iter.first);
344         }
345     }
346     for (int32_t socketId : socketIds) {
347         IAM_LOGI("service down shutdown socket %{public}d", socketId);
348         OnShutdown(socketId, SHUTDOWN_REASON_SERVICE_DIED);
349     }
350 
351     IAM_LOGI("UnInitialize success");
352 }
353 
ClientSocketInit(const std::string & connectionName,const std::string & networkId)354 int32_t SoftBusManager::ClientSocketInit(const std::string &connectionName, const std::string &networkId)
355 {
356     IAM_LOGD("start.");
357     std::string clientName = USER_AUTH_SOCKET_NAME + connectionName;
358     char name[SOCKET_NAME_MAX_LEN + 1];
359     if (!CheckAndCopyStr(name, SOCKET_NAME_MAX_LEN, clientName)) {
360         IAM_LOGE("copy socket name fail");
361         return INVALID_SOCKET_ID;
362     }
363 
364     std::string serviceName = USER_AUTH_SOCKET_NAME + "service";
365     char peerName[SOCKET_NAME_MAX_LEN + 1];
366     if (!CheckAndCopyStr(peerName, SOCKET_NAME_MAX_LEN, serviceName)) {
367         IAM_LOGE("copy peer name fail");
368         return INVALID_SOCKET_ID;
369     }
370 
371     char peerNetworkId[SOCKET_NAME_MAX_LEN + 1];
372     if (!CheckAndCopyStr(peerNetworkId, SOCKET_NAME_MAX_LEN, networkId)) {
373         IAM_LOGE("copy peer networkId name fail");
374         return INVALID_SOCKET_ID;
375     }
376 
377     char pkgName[PACKAGE_NAME_MAX_LEN + 1];
378     if (!CheckAndCopyStr(pkgName, PACKAGE_NAME_MAX_LEN, USER_AUTH_PACKAGE_NAME)) {
379         IAM_LOGE("copy pkg name fail");
380         return INVALID_SOCKET_ID;
381     }
382 
383     SocketInfo info = {
384         .name = name,
385         .peerName = peerName,
386         .peerNetworkId = peerNetworkId,
387         .pkgName = pkgName,
388         .dataType = DATA_TYPE_BYTES
389     };
390 
391     return Socket(info);
392 }
393 
ClientSocketBind(const int32_t socketId)394 ResultCode SoftBusManager::ClientSocketBind(const int32_t socketId)
395 {
396     IAM_LOGD("start.");
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     ISocketListener listener;
404     listener.OnShutdown = SoftBusSocketListener::OnShutdown;
405     listener.OnBytes = SoftBusSocketListener::OnServerBytes;
406     listener.OnQos = SoftBusSocketListener::OnQos;
407 
408     int32_t ret = SOFTBUS_INVALID_PARAM;
409     auto sleepTime = std::chrono::milliseconds(BIND_SERVICE_SLEEP_TIMES_MS);
410     for (int32_t retryTimes = 0; retryTimes < BIND_SERVICE_MAX_RETRY_TIMES; retryTimes++) {
411         ret = Bind(socketId, clientQos, QOS_LEN, &listener);
412         if (ret == SOFTBUS_OK) {
413             break;
414         }
415         std::this_thread::sleep_for(sleepTime);
416     }
417 
418     if (ret != SOFTBUS_OK) {
419         IAM_LOGE("ClientSocketBind fail.");
420         return GENERAL_ERROR;
421     }
422     IAM_LOGI("ClientSocketBind success.");
423     return SUCCESS;
424 }
425 
DoOpenConnectionInner(const std::string & connectionName,const uint32_t tokenId,const std::string & networkId)426 ResultCode SoftBusManager::DoOpenConnectionInner(const std::string &connectionName, const uint32_t tokenId,
427     const std::string &networkId)
428 {
429     int32_t ret = SetFirstCallerTokenID(tokenId);
430     if (ret != SUCCESS) {
431         IAM_LOGE("SetFirstCallerTokenID fail");
432     }
433 
434     int32_t socketId = ClientSocketInit(connectionName, networkId);
435     if (socketId <= INVALID_SOCKET_ID) {
436         IAM_LOGE("create client socket failed.");
437         return GENERAL_ERROR;
438     }
439 
440     auto clientSocket = SocketFactory::CreateClientSocket(socketId, connectionName, networkId);
441     if (clientSocket == nullptr) {
442         IAM_LOGE("CreateClientSocket failed, connectionName:%{public}s", connectionName.c_str());
443         return GENERAL_ERROR;
444     }
445 
446     ret = ClientSocketBind(socketId);
447     if (ret != SUCCESS) {
448         IAM_LOGE("client socket bind service fail");
449         return GENERAL_ERROR;
450     }
451 
452     AddConnection(connectionName, clientSocket);
453     AddSocket(socketId, clientSocket);
454     IAM_LOGI("Bind service success, connectionName:%{public}s socketId:%{public}d.", connectionName.c_str(), socketId);
455     return SUCCESS;
456 }
457 
DoOpenConnection(const std::string & connectionName,const uint32_t tokenId,const std::string & networkId)458 void SoftBusManager::DoOpenConnection(const std::string &connectionName, const uint32_t tokenId,
459     const std::string &networkId)
460 {
461     IAM_LOGI("open connection %{public}s start.", connectionName.c_str());
462     auto beginTime = std::chrono::steady_clock::now();
463     ResultCode result = DoOpenConnectionInner(connectionName, tokenId, networkId);
464     auto endTime = std::chrono::steady_clock::now();
465     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - beginTime);
466     IAM_LOGI("connection %{public}s OpenConnectionDuration %{public}" PRIu64 " ms", connectionName.c_str(),
467         static_cast<uint64_t>(duration.count()));
468     if (result != SUCCESS) {
469         RemoteConnectListenerManager::GetInstance().OnConnectionDown(connectionName);
470         IAM_LOGE("open connection %{public}s fail", connectionName.c_str());
471         return;
472     }
473 
474     RemoteConnectListenerManager::GetInstance().OnConnectionUp(connectionName);
475     IAM_LOGI("open connection %{public}s success.", connectionName.c_str());
476 }
477 
OpenConnection(const std::string & connectionName,const uint32_t tokenId,const std::string & networkId)478 ResultCode SoftBusManager::OpenConnection(const std::string &connectionName, const uint32_t tokenId,
479     const std::string &networkId)
480 {
481     IAM_LOGD("start.");
482 
483     ThreadHandlerManager::GetInstance().PostTask(connectionName, [=]() {
484         DoOpenConnection(connectionName, tokenId, networkId);
485     });
486 
487     IAM_LOGI("Open connection %{public}s task added.", connectionName.c_str());
488     return SUCCESS;
489 }
490 
DoCloseConnection(const std::string & connectionName)491 ResultCode SoftBusManager::DoCloseConnection(const std::string &connectionName)
492 {
493     IAM_LOGI("close connection %{public}s start.", connectionName.c_str());
494     std::shared_ptr<BaseSocket> clientSocket = FindClientSocket(connectionName);
495     if (clientSocket == nullptr) {
496         IAM_LOGE("clientSocket is nullptr");
497         return GENERAL_ERROR;
498     }
499 
500     int32_t socketId = clientSocket->GetSocketId();
501     if (socketId == INVALID_SOCKET_ID) {
502         IAM_LOGE("socket id is invalid");
503         return GENERAL_ERROR;
504     }
505 
506     RemoteConnectListenerManager::GetInstance().OnConnectionDown(connectionName);
507     DeleteSocket(socketId);
508     DeleteConnection(connectionName);
509     IAM_LOGI("close connection %{public}s socketId %{public}d success", connectionName.c_str(), socketId);
510     return SUCCESS;
511 }
512 
CloseConnection(const std::string & connectionName)513 ResultCode SoftBusManager::CloseConnection(const std::string &connectionName)
514 {
515     IAM_LOGD("start.");
516 
517     ThreadHandlerManager::GetInstance().PostTask(connectionName, [=]() {
518         DoCloseConnection(connectionName);
519     });
520 
521     IAM_LOGI("Close connection %{public}s task added.", connectionName.c_str());
522     return SUCCESS;
523 }
524 
SendMessage(const std::string & connectionName,const std::string & srcEndPoint,const std::string & destEndPoint,const std::shared_ptr<Attributes> & attributes,MsgCallback & callback)525 ResultCode SoftBusManager::SendMessage(const std::string &connectionName,
526     const std::string &srcEndPoint, const std::string &destEndPoint,
527     const std::shared_ptr<Attributes> &attributes, MsgCallback &callback)
528 {
529     IAM_LOGD("start.");
530     IF_FALSE_LOGE_AND_RETURN_VAL(attributes != nullptr, INVALID_PARAMETERS);
531 
532     ResultCode ret = SUCCESS;
533     auto serverSocket = GetServerSocket();
534     IF_FALSE_LOGE_AND_RETURN_VAL(serverSocket != nullptr, GENERAL_ERROR);
535 
536     ret = serverSocket->SendMessage(connectionName, srcEndPoint, destEndPoint, attributes, callback);
537     if (ret == SUCCESS) {
538         IAM_LOGI("SendMessage success");
539         return SUCCESS;
540     }
541     IAM_LOGI("try to send message using serverSocket fail, ret:%{public}d", ret);
542 
543     std::shared_ptr<BaseSocket> clientSocket = FindClientSocket(connectionName);
544     if (clientSocket == nullptr) {
545         IAM_LOGE("failed to find clientSocket");
546         return GENERAL_ERROR;
547     }
548 
549     ret = clientSocket->SendMessage(connectionName, srcEndPoint, destEndPoint, attributes, callback);
550     if (ret != SUCCESS) {
551         IAM_LOGE("clientSocket send message fail, ret:%{public}d", ret);
552         return GENERAL_ERROR;
553     }
554 
555     IAM_LOGI("SendMessage success.");
556     return SUCCESS;
557 }
558 
OnBind(int32_t socketId,PeerSocketInfo info)559 void SoftBusManager::OnBind(int32_t socketId, PeerSocketInfo info)
560 {
561     IAM_LOGI("socket id is %{public}d.", socketId);
562     if (socketId <= INVALID_SOCKET_ID) {
563         IAM_LOGE("socket id invalid.");
564         return;
565     }
566 
567     auto serverSocket = GetServerSocket();
568     if (serverSocket == nullptr) {
569         IAM_LOGE("serverSocket is nullptr.");
570         return;
571     }
572 
573     serverSocket->OnBind(socketId, info);
574 }
575 
OnShutdown(int32_t socketId,ShutdownReason reason)576 void SoftBusManager::OnShutdown(int32_t socketId, ShutdownReason reason)
577 {
578     IAM_LOGI("socket id %{public}d shutdown because %{public}d.", socketId, reason);
579     if (socketId <= INVALID_SOCKET_ID) {
580         IAM_LOGE("socket id invalid.");
581         return;
582     }
583 
584     auto serverSocket = GetServerSocket();
585     if (serverSocket != nullptr) {
586         serverSocket->OnShutdown(socketId, reason);
587     }
588 
589     auto clientSocket = FindSocketBySocketId(socketId);
590     if (clientSocket == nullptr) {
591         IAM_LOGI("clientSocket is nullptr.");
592         return;
593     }
594     clientSocket->OnShutdown(socketId, reason);
595     DeleteSocket(socketId);
596     DeleteConnection(clientSocket->GetConnectionName());
597     IAM_LOGI("shutdown socket id %{public}d success.", socketId);
598 }
599 
OnClientBytes(int32_t socketId,const void * data,uint32_t dataLen)600 void SoftBusManager::OnClientBytes(int32_t socketId, const void *data, uint32_t dataLen)
601 {
602     IAM_LOGI("socket fd %{public}d, recv len %{public}u.", socketId, dataLen);
603     if ((socketId <= INVALID_SOCKET_ID) || (data == nullptr) ||
604         (dataLen == 0) || (dataLen > MAX_ONBYTES_RECEIVED_DATA_LEN)) {
605         IAM_LOGE("params invalid.");
606         return;
607     }
608 
609     auto serverSocket = GetServerSocket();
610     if (serverSocket == nullptr) {
611         IAM_LOGE("serverSocket is nullptr.");
612         return;
613     }
614 
615     serverSocket->OnBytes(socketId, data, dataLen);
616 }
617 
OnServerBytes(int32_t socketId,const void * data,uint32_t dataLen)618 void SoftBusManager::OnServerBytes(int32_t socketId, const void *data, uint32_t dataLen)
619 {
620     IAM_LOGI("socket fd %{public}d, recv len %{public}u.", socketId, dataLen);
621     if ((socketId <= INVALID_SOCKET_ID) || (data == nullptr) ||
622         (dataLen == 0) || (dataLen > MAX_ONBYTES_RECEIVED_DATA_LEN)) {
623         IAM_LOGE("params invalid.");
624         return;
625     }
626 
627     auto clientSocket = FindSocketBySocketId(socketId);
628     if (clientSocket == nullptr) {
629         IAM_LOGE("clientSocket is nullptr.");
630         return;
631     }
632 
633     clientSocket->OnBytes(socketId, data, dataLen);
634 }
635 
AddSocket(const int32_t socketId,std::shared_ptr<BaseSocket> & socket)636 void SoftBusManager::AddSocket(const int32_t socketId, std::shared_ptr<BaseSocket> &socket)
637 {
638     IAM_LOGD("start.");
639     IF_FALSE_LOGE_AND_RETURN(socket != nullptr);
640     IF_FALSE_LOGE_AND_RETURN(socketId != INVALID_SOCKET_ID);
641 
642     std::lock_guard<std::recursive_mutex> lock(socketMutex_);
643     socketMap_.insert(std::pair<int32_t, std::shared_ptr<BaseSocket>>(socketId, socket));
644 }
645 
DeleteSocket(const int32_t socketId)646 void SoftBusManager::DeleteSocket(const int32_t socketId)
647 {
648     IAM_LOGD("start.");
649     IF_FALSE_LOGE_AND_RETURN(socketId != INVALID_SOCKET_ID);
650 
651     std::lock_guard<std::recursive_mutex> lock(socketMutex_);
652     auto iter = socketMap_.find(socketId);
653     if (iter == socketMap_.end()) {
654         IAM_LOGE("socketId:%{public}d not found.", socketId);
655         return;
656     }
657     socketMap_.erase(socketId);
658 }
659 
FindSocketBySocketId(const int32_t socketId)660 std::shared_ptr<BaseSocket> SoftBusManager::FindSocketBySocketId(const int32_t socketId)
661 {
662     IAM_LOGD("start.");
663     IF_FALSE_LOGE_AND_RETURN_VAL(socketId != INVALID_SOCKET_ID, nullptr);
664 
665     std::lock_guard<std::recursive_mutex> lock(socketMutex_);
666     std::shared_ptr<BaseSocket> socket = nullptr;
667     auto iter = socketMap_.find(socketId);
668     if (iter != socketMap_.end()) {
669         socket = iter->second;
670     }
671     return socket;
672 }
673 
CheckAndCopyStr(char * dest,uint32_t destLen,const std::string & src)674 bool SoftBusManager::CheckAndCopyStr(char *dest, uint32_t destLen, const std::string &src)
675 {
676     if (destLen < src.length() + 1) {
677         IAM_LOGE("Invalid src length");
678         return false;
679     }
680     if (strcpy_s(dest, destLen, src.c_str()) != EOK) {
681         IAM_LOGE("Invalid src");
682         return false;
683     }
684     return true;
685 }
686 
SetServerSocket(std::shared_ptr<BaseSocket> & socket)687 void SoftBusManager::SetServerSocket(std::shared_ptr<BaseSocket> &socket)
688 {
689     IAM_LOGD("start.");
690     IF_FALSE_LOGE_AND_RETURN(socket != nullptr);
691     std::lock_guard<std::recursive_mutex> lock(ServerSocketMutex_);
692     serverSocket_ = socket;
693 }
694 
ClearServerSocket()695 void SoftBusManager::ClearServerSocket()
696 {
697     IAM_LOGD("start.");
698     std::lock_guard<std::recursive_mutex> lock(ServerSocketMutex_);
699     serverSocket_ = nullptr;
700 }
701 
AddConnection(const std::string & connectionName,std::shared_ptr<BaseSocket> & socket)702 void SoftBusManager::AddConnection(const std::string &connectionName, std::shared_ptr<BaseSocket> &socket)
703 {
704     IAM_LOGD("start.");
705     IF_FALSE_LOGE_AND_RETURN(socket != nullptr);
706 
707     std::lock_guard<std::recursive_mutex> lock(connectionMutex_);
708     clientSocketMap_.insert(std::pair<std::string, std::shared_ptr<BaseSocket>>(connectionName, socket));
709 }
710 
DeleteConnection(const std::string & connectionName)711 void SoftBusManager::DeleteConnection(const std::string &connectionName)
712 {
713     IAM_LOGD("start.");
714     std::lock_guard<std::recursive_mutex> lock(connectionMutex_);
715     auto iter = clientSocketMap_.find(connectionName);
716     if (iter == clientSocketMap_.end()) {
717         IAM_LOGE("connectionName:%{public}s not found.", connectionName.c_str());
718         return;
719     }
720     clientSocketMap_.erase(connectionName);
721 }
722 
FindClientSocket(const std::string & connectionName)723 std::shared_ptr<BaseSocket> SoftBusManager::FindClientSocket(const std::string &connectionName)
724 {
725     IAM_LOGD("start.");
726     std::lock_guard<std::recursive_mutex> lock(connectionMutex_);
727     std::shared_ptr<BaseSocket> clientSocket = nullptr;
728     auto iter = clientSocketMap_.find(connectionName);
729     if (iter != clientSocketMap_.end()) {
730         clientSocket = iter->second;
731     }
732     return clientSocket;
733 }
734 
GetServerSocket()735 std::shared_ptr<BaseSocket> SoftBusManager::GetServerSocket()
736 {
737     return serverSocket_;
738 }
739 } // namespace UserAuth
740 } // namespace UserIam
741 } // namespace OHOS