1 /*
2 * Copyright (c) 2021-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 "client_trans_session_manager.h"
17
18 #include <securec.h>
19 #include <unistd.h>
20
21 #include "anonymizer.h"
22 #include "client_bus_center_manager.h"
23 #include "client_trans_channel_manager.h"
24 #include "client_trans_file_listener.h"
25 #include "client_trans_proxy_file_manager.h"
26 #include "client_trans_socket_manager.h"
27 #include "client_trans_tcp_direct_manager.h"
28 #include "client_trans_udp_manager.h"
29 #include "session_ipc_adapter.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_app_info.h"
32 #include "softbus_def.h"
33 #include "softbus_errcode.h"
34 #include "softbus_socket.h"
35 #include "softbus_utils.h"
36 #include "trans_log.h"
37 #include "trans_server_proxy.h"
38
39 #define CAST_SESSION "CastPlusSessionName"
40 static void ClientTransSessionTimerProc(void);
41
42 static int32_t g_sessionIdNum = 0;
43 static int32_t g_sessionId = 1;
44 static int32_t g_closingIdNum = 0;
45 static SoftBusList *g_clientSessionServerList = NULL;
46
LockClientSessionServerList()47 static int32_t LockClientSessionServerList()
48 {
49 if (g_clientSessionServerList == NULL) {
50 TRANS_LOGE(TRANS_INIT, "entry list not init");
51 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
52 }
53 int32_t ret = SoftBusMutexLock(&(g_clientSessionServerList->lock));
54 if (ret != SOFTBUS_OK) {
55 return SOFTBUS_LOCK_ERR;
56 }
57 return SOFTBUS_OK;
58 }
59
UnlockClientSessionServerList()60 static void UnlockClientSessionServerList()
61 {
62 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
63 }
64
CheckPermissionState(int32_t sessionId)65 int32_t CheckPermissionState(int32_t sessionId)
66 {
67 int32_t ret = LockClientSessionServerList();
68 if (ret != SOFTBUS_OK) {
69 TRANS_LOGE(TRANS_SDK, "lock failed");
70 return ret;
71 }
72 ClientSessionServer *serverNode = NULL;
73 SessionInfo *sessionNode = NULL;
74
75 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
76 if (IsListEmpty(&serverNode->sessionList)) {
77 continue;
78 }
79 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
80 if (sessionNode->sessionId == sessionId) {
81 bool permissionState = serverNode->permissionState;
82 UnlockClientSessionServerList();
83 return permissionState ? SOFTBUS_OK : SOFTBUS_PERMISSION_DENIED;
84 }
85 }
86 }
87 UnlockClientSessionServerList();
88 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
89 }
90
PermissionStateChange(const char * pkgName,int32_t state)91 void PermissionStateChange(const char *pkgName, int32_t state)
92 {
93 if (LockClientSessionServerList() != SOFTBUS_OK) {
94 TRANS_LOGE(TRANS_SDK, "lock failed");
95 return;
96 }
97
98 ClientSessionServer *serverNode = NULL;
99 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
100 if ((strcmp(serverNode->pkgName, pkgName) == 0)) {
101 serverNode->permissionState = state > 0 ? true : false;
102 TRANS_LOGI(TRANS_SDK, "permission change, pkgName=%{public}s, state=%{public}d", pkgName, state);
103 break;
104 }
105 }
106 UnlockClientSessionServerList();
107 }
108
TransClientInit(void)109 int TransClientInit(void)
110 {
111 g_clientSessionServerList = CreateSoftBusList();
112 if (g_clientSessionServerList == NULL) {
113 TRANS_LOGE(TRANS_INIT, "entry list not init");
114 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
115 }
116
117 if (TransServerProxyInit() != SOFTBUS_OK) {
118 TRANS_LOGE(TRANS_INIT, "init trans ipc proxy failed");
119 return SOFTBUS_TRANS_SERVER_INIT_FAILED;
120 }
121
122 if (ClientTransChannelInit() != SOFTBUS_OK) {
123 TRANS_LOGE(TRANS_INIT, "init trans channel failed");
124 return SOFTBUS_TRANS_SERVER_INIT_FAILED;
125 }
126
127 if (RegisterTimeoutCallback(SOFTBUS_TRNAS_IDLE_TIMEOUT_TIMER_FUN, ClientTransSessionTimerProc) != SOFTBUS_OK) {
128 TRANS_LOGE(TRANS_INIT, "init trans idle timer failed");
129 return SOFTBUS_TRANS_SERVER_INIT_FAILED;
130 }
131
132 ClientTransRegLnnOffline();
133 TRANS_LOGI(TRANS_INIT, "init trans client success");
134 return SOFTBUS_OK;
135 }
136
SessionIdIsAvailable(int32_t sessionId)137 static bool SessionIdIsAvailable(int32_t sessionId)
138 {
139 ClientSessionServer *serverNode = NULL;
140 SessionInfo *sessionNode = NULL;
141
142 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
143 if (IsListEmpty(&serverNode->sessionList)) {
144 continue;
145 }
146 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
147 if (sessionNode->sessionId == sessionId) {
148 return false;
149 }
150 }
151 }
152
153 return true;
154 }
155
ShowAllSessionInfo(void)156 static void ShowAllSessionInfo(void)
157 {
158 TRANS_LOGI(TRANS_SDK, "g_sessionIdNum=%{public}d, g_closingIdNum=%{public}d", g_sessionIdNum, g_closingIdNum);
159 ClientSessionServer *serverNode = NULL;
160 SessionInfo *sessionNode = NULL;
161 int count = 0;
162 char *tmpName = NULL;
163 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
164 Anonymize(serverNode->sessionName, &tmpName);
165 TRANS_LOGI(
166 TRANS_SDK, "client session server is exist. count=%{public}d, sessionName=%{public}s", count, tmpName);
167 AnonymizeFree(tmpName);
168 count++;
169 if (IsListEmpty(&serverNode->sessionList)) {
170 continue;
171 }
172 int sessionCount = 0;
173 char *tmpPeerSessionName = NULL;
174 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
175 Anonymize(sessionNode->info.peerSessionName, &tmpPeerSessionName);
176 TRANS_LOGI(TRANS_SDK,
177 "client session info is exist. sessionCount=%{public}d, peerSessionName=%{public}s, "
178 "channelId=%{public}d, channelType=%{public}d",
179 sessionCount, tmpPeerSessionName, sessionNode->channelId, sessionNode->channelType);
180 AnonymizeFree(tmpPeerSessionName);
181 sessionCount++;
182 }
183 }
184 }
185
186 // need get g_clientSessionServerList->lock before call this function
GenerateSessionId(void)187 int32_t GenerateSessionId(void)
188 {
189 if (g_sessionIdNum >= g_closingIdNum && g_sessionIdNum - g_closingIdNum >= MAX_SESSION_ID) {
190 TRANS_LOGE(TRANS_SDK, "sessionid num cross the line error");
191 return INVALID_SESSION_ID;
192 }
193 int32_t cnt = MAX_SESSION_ID + g_closingIdNum + 1;
194 int32_t id = INVALID_SESSION_ID;
195
196 while (cnt) {
197 id = g_sessionId++;
198 if (g_sessionId < 0) {
199 g_sessionId = 1;
200 }
201 if (SessionIdIsAvailable(id)) {
202 g_sessionIdNum++;
203 return id;
204 }
205 cnt--;
206 }
207 TRANS_LOGE(TRANS_SDK, "generate id error");
208 return id;
209 }
210
211 // need get g_clientSessionServerList->lock before call this function
DestroySessionId(void)212 void DestroySessionId(void)
213 {
214 if (g_sessionIdNum > 0) {
215 g_sessionIdNum--;
216 }
217
218 if (g_closingIdNum > 0) {
219 g_closingIdNum--;
220 }
221 }
222
TryDeleteEmptySessionServer(const char * pkgName,const char * sessionName)223 int32_t TryDeleteEmptySessionServer(const char *pkgName, const char *sessionName)
224 {
225 if (pkgName == NULL || sessionName == NULL) {
226 TRANS_LOGE(TRANS_SDK, "invalid param.");
227 return SOFTBUS_INVALID_PARAM;
228 }
229 int32_t ret = LockClientSessionServerList();
230 if (ret != SOFTBUS_OK) {
231 TRANS_LOGE(TRANS_SDK, "lock failed");
232 return ret;
233 }
234
235 char *tmpName = NULL;
236 Anonymize(sessionName, &tmpName);
237 ClientSessionServer *serverNode = NULL;
238 ClientSessionServer *serverNodeNext = NULL;
239 ListNode destroyList;
240 ListInit(&destroyList);
241 LIST_FOR_EACH_ENTRY_SAFE(
242 serverNode, serverNodeNext, &(g_clientSessionServerList->list), ClientSessionServer, node) {
243 if (strcmp(serverNode->sessionName, sessionName) == 0 && IsListEmpty(&serverNode->sessionList) &&
244 serverNode->sessionAddingCnt == 0) {
245 ListDelete(&(serverNode->node));
246 SoftBusFree(serverNode);
247 g_clientSessionServerList->cnt--;
248 UnlockClientSessionServerList();
249 // calling the ipc interface by locking here may block other threads for a long time
250 ret = ServerIpcRemoveSessionServer(pkgName, sessionName);
251 if (ret != SOFTBUS_OK) {
252 TRANS_LOGE(TRANS_SDK, "remove session server failed, ret=%{public}d", ret);
253 AnonymizeFree(tmpName);
254 return ret;
255 }
256 TRANS_LOGI(TRANS_SDK, "delete empty session server, sessionName=%{public}s", tmpName);
257 AnonymizeFree(tmpName);
258 return SOFTBUS_OK;
259 }
260 }
261 UnlockClientSessionServerList();
262 TRANS_LOGE(TRANS_SDK, "not found session server or session list is not empty, sessionName=%{public}s", tmpName);
263 AnonymizeFree(tmpName);
264 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
265 }
266
TransClientDeinit(void)267 void TransClientDeinit(void)
268 {
269 if (LockClientSessionServerList() != SOFTBUS_OK) {
270 TRANS_LOGE(TRANS_SDK, "lock failed");
271 return;
272 }
273 ClientSessionServer *serverNode = NULL;
274 ClientSessionServer *serverNodeNext = NULL;
275 ListNode destroyList;
276 ListInit(&destroyList);
277 LIST_FOR_EACH_ENTRY_SAFE(serverNode, serverNodeNext, &(g_clientSessionServerList->list),
278 ClientSessionServer, node) {
279 DestroyClientSessionServer(serverNode, &destroyList);
280 }
281 UnlockClientSessionServerList();
282 ClientDestroySession(&destroyList, SHUTDOWN_REASON_LOCAL);
283
284 DestroySoftBusList(g_clientSessionServerList);
285 g_clientSessionServerList = NULL;
286 ClientTransChannelDeinit();
287 TransServerProxyDeInit();
288 (void)RegisterTimeoutCallback(SOFTBUS_TRNAS_IDLE_TIMEOUT_TIMER_FUN, NULL);
289 }
290
SessionServerIsExist(const char * sessionName)291 static bool SessionServerIsExist(const char *sessionName)
292 {
293 /* need get lock before */
294 ListNode *pos = NULL;
295 ListNode *tmp = NULL;
296 ClientSessionServer *node = NULL;
297 LIST_FOR_EACH_SAFE(pos, tmp, &g_clientSessionServerList->list) {
298 node = (ClientSessionServer *)pos;
299 if (strcmp(node->sessionName, sessionName) == 0) {
300 return true;
301 }
302 }
303 return false;
304 }
305
SocketServerIsExistAndUpdate(const char * sessionName)306 static bool SocketServerIsExistAndUpdate(const char *sessionName)
307 {
308 /* need get lock before */
309 ClientSessionServer *item = NULL;
310 LIST_FOR_EACH_ENTRY(item, &g_clientSessionServerList->list, ClientSessionServer, node) {
311 if (strcmp(item->sessionName, sessionName) == 0) {
312 /*
313 * this field indicates that a process is using a SessionServer,
314 * but the process has not yet added the session node to the sessionList.
315 * Other processes cannot perceive this intermediate state, so this field is added to identify this state;
316 * This field is cleared after adding the session node to the session list in the process
317 */
318 item->sessionAddingCnt++;
319 return true;
320 }
321 }
322 return false;
323 }
324
SocketServerStateUpdate(const char * sessionName)325 void SocketServerStateUpdate(const char *sessionName)
326 {
327 if (sessionName == NULL) {
328 TRANS_LOGE(TRANS_SDK, "invalid param");
329 return;
330 }
331 if (LockClientSessionServerList() != SOFTBUS_OK) {
332 TRANS_LOGE(TRANS_SDK, "lock failed");
333 return;
334 }
335 ClientSessionServer *item = NULL;
336 LIST_FOR_EACH_ENTRY(item, &g_clientSessionServerList->list, ClientSessionServer, node) {
337 if (strcmp(item->sessionName, sessionName) == 0) {
338 if (item->sessionAddingCnt > 0) {
339 item->sessionAddingCnt--;
340 }
341 UnlockClientSessionServerList();
342 return;
343 }
344 }
345 char *tmpName = NULL;
346 Anonymize(sessionName, &tmpName);
347 TRANS_LOGE(TRANS_SDK, "not found session server by sessionName=%{public}s", tmpName);
348 AnonymizeFree(tmpName);
349 UnlockClientSessionServerList();
350 }
351
ShowClientSessionServer(void)352 static void ShowClientSessionServer(void)
353 {
354 ClientSessionServer *pos = NULL;
355 ClientSessionServer *tmp = NULL;
356 int count = 0;
357 char *tmpName = NULL;
358 LIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &g_clientSessionServerList->list, ClientSessionServer, node) {
359 Anonymize(pos->sessionName, &tmpName);
360 TRANS_LOGE(TRANS_SDK,
361 "client session server is exist. count=%{public}d, sessionName=%{public}s", count, tmpName);
362 AnonymizeFree(tmpName);
363 count++;
364 }
365 }
366
ClientAddSessionServer(SoftBusSecType type,const char * pkgName,const char * sessionName,const ISessionListener * listener)367 int32_t ClientAddSessionServer(SoftBusSecType type, const char *pkgName, const char *sessionName,
368 const ISessionListener *listener)
369 {
370 if (pkgName == NULL || sessionName == NULL || listener == NULL) {
371 return SOFTBUS_INVALID_PARAM;
372 }
373
374 int32_t ret = LockClientSessionServerList();
375 if (ret != SOFTBUS_OK) {
376 TRANS_LOGE(TRANS_SDK, "lock failed");
377 return ret;
378 }
379 if (SessionServerIsExist(sessionName)) {
380 UnlockClientSessionServerList();
381 return SOFTBUS_SERVER_NAME_REPEATED;
382 }
383
384 if (g_clientSessionServerList->cnt >= MAX_SESSION_SERVER_NUMBER) {
385 ShowClientSessionServer();
386 UnlockClientSessionServerList();
387 TRANS_LOGE(TRANS_SDK, "ClientAddSessionServer: client server num reach max");
388 return SOFTBUS_INVALID_NUM;
389 }
390
391 ClientSessionServer *server = GetNewSessionServer(type, sessionName, pkgName, listener);
392 if (server == NULL) {
393 UnlockClientSessionServerList();
394 return SOFTBUS_MEM_ERR;
395 }
396 server->permissionState = true;
397 ListAdd(&g_clientSessionServerList->list, &server->node);
398 g_clientSessionServerList->cnt++;
399
400 UnlockClientSessionServerList();
401 char *tmpName = NULL;
402 char *tmpPkgName = NULL;
403 Anonymize(pkgName, &tmpPkgName);
404 Anonymize(sessionName, &tmpName);
405 TRANS_LOGI(TRANS_SDK, "sessionName=%{public}s, pkgName=%{public}s",
406 AnonymizeWrapper(tmpName), AnonymizeWrapper(tmpPkgName));
407 AnonymizeFree(tmpName);
408 AnonymizeFree(tmpPkgName);
409 return SOFTBUS_OK;
410 }
411
GetExistSession(const SessionParam * param)412 static SessionInfo *GetExistSession(const SessionParam *param)
413 {
414 /* need get lock before */
415 ClientSessionServer *serverNode = NULL;
416 SessionInfo *sessionNode = NULL;
417 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
418 if ((strcmp(serverNode->sessionName, param->sessionName) != 0) || IsListEmpty(&serverNode->sessionList)) {
419 continue;
420 }
421 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
422 if (sessionNode->isServer || (strcmp(sessionNode->info.peerSessionName, param->peerSessionName) != 0) ||
423 (strcmp(sessionNode->info.peerDeviceId, param->peerDeviceId) != 0) ||
424 (strcmp(sessionNode->info.groupId, param->groupId) != 0) ||
425 (memcmp(sessionNode->linkType, param->attr->linkType, sizeof(param->attr->linkType)) != 0) ||
426 (sessionNode->info.flag != param->attr->dataType)) {
427 continue;
428 }
429 return sessionNode;
430 }
431 }
432 return NULL;
433 }
434
GetSessionById(int32_t sessionId,ClientSessionServer ** server,SessionInfo ** session)435 static int32_t GetSessionById(int32_t sessionId, ClientSessionServer **server, SessionInfo **session)
436 {
437 /* need get lock before */
438 ClientSessionServer *serverNode = NULL;
439 SessionInfo *sessionNode = NULL;
440
441 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
442 if (IsListEmpty(&serverNode->sessionList)) {
443 continue;
444 }
445 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
446 if (sessionNode->sessionId == sessionId) {
447 *server = serverNode;
448 *session = sessionNode;
449 return SOFTBUS_OK;
450 }
451 }
452 }
453 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
454 }
455
AddSession(const char * sessionName,SessionInfo * session)456 static int32_t AddSession(const char *sessionName, SessionInfo *session)
457 {
458 /* need get lock before */
459 session->sessionId = GenerateSessionId();
460 if (session->sessionId < 0) {
461 ShowAllSessionInfo();
462 return SOFTBUS_TRANS_SESSION_CNT_EXCEEDS_LIMIT;
463 }
464 ClientSessionServer *serverNode = NULL;
465 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
466 if (strcmp(serverNode->sessionName, sessionName) != 0) {
467 continue;
468 }
469 ListAdd(&serverNode->sessionList, &session->node);
470 char *anonyDeviceId = NULL;
471 Anonymize(session->info.peerDeviceId, &anonyDeviceId);
472 TRANS_LOGI(TRANS_SDK,
473 "add, sessionId=%{public}d, channelId=%{public}d, channelType=%{public}d, routeType=%{public}d, "
474 "peerDeviceId=%{public}s",
475 session->sessionId, session->channelId, session->channelType, session->routeType,
476 AnonymizeWrapper(anonyDeviceId));
477 AnonymizeFree(anonyDeviceId);
478 return SOFTBUS_OK;
479 }
480 DestroySessionId();
481 return SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED;
482 }
483
ClientAddNewSession(const char * sessionName,SessionInfo * session)484 int32_t ClientAddNewSession(const char *sessionName, SessionInfo *session)
485 {
486 if (session == NULL) {
487 TRANS_LOGW(TRANS_SDK, "Invalid param");
488 return SOFTBUS_INVALID_PARAM;
489 }
490
491 int32_t ret = LockClientSessionServerList();
492 if (ret != SOFTBUS_OK) {
493 TRANS_LOGE(TRANS_SDK, "lock failed");
494 return ret;
495 }
496
497 ret = AddSession(sessionName, session);
498 if (ret != SOFTBUS_OK) {
499 UnlockClientSessionServerList();
500 TRANS_LOGE(TRANS_SDK, "add session failed, ret=%{public}d", ret);
501 return ret;
502 }
503 UnlockClientSessionServerList();
504 return SOFTBUS_OK;
505 }
506
ClientAddSession(const SessionParam * param,int32_t * sessionId,SessionEnableStatus * isEnabled)507 int32_t ClientAddSession(const SessionParam *param, int32_t *sessionId, SessionEnableStatus *isEnabled)
508 {
509 if (!IsValidSessionParam(param) || (sessionId == NULL) || (isEnabled == NULL)) {
510 TRANS_LOGW(TRANS_SDK, "Invalid param");
511 return SOFTBUS_INVALID_PARAM;
512 }
513
514 int32_t ret = LockClientSessionServerList();
515 if (ret != SOFTBUS_OK) {
516 TRANS_LOGE(TRANS_SDK, "lock failed");
517 return ret;
518 }
519
520 SessionInfo *session = GetExistSession(param);
521 if (session != NULL) {
522 *sessionId = session->sessionId;
523 *isEnabled = session->enableStatus;
524 UnlockClientSessionServerList();
525 return SOFTBUS_TRANS_SESSION_REPEATED;
526 }
527
528 session = CreateNewSession(param);
529 if (session == NULL) {
530 UnlockClientSessionServerList();
531 TRANS_LOGE(TRANS_SDK, "create session failed");
532 return SOFTBUS_TRANS_SESSION_CREATE_FAILED;
533 }
534
535 ret = AddSession(param->sessionName, session);
536 if (ret != SOFTBUS_OK) {
537 SoftBusFree(session);
538 UnlockClientSessionServerList();
539 TRANS_LOGE(TRANS_SDK, "Add Session failed, ret=%{public}d", ret);
540 return ret;
541 }
542
543 *sessionId = session->sessionId;
544 UnlockClientSessionServerList();
545 return SOFTBUS_OK;
546 }
547
ClientAddAuthSession(const char * sessionName,int32_t * sessionId)548 int32_t ClientAddAuthSession(const char *sessionName, int32_t *sessionId)
549 {
550 if (!IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1) || (sessionId == NULL)) {
551 TRANS_LOGW(TRANS_SDK, "Invalid param");
552 return SOFTBUS_INVALID_PARAM;
553 }
554 if (g_clientSessionServerList == NULL) {
555 TRANS_LOGE(TRANS_INIT, "entry list not init");
556 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
557 }
558 SessionInfo *session = CreateNonEncryptSessionInfo(sessionName);
559 if (session == NULL) {
560 return SOFTBUS_MALLOC_ERR;
561 }
562 int32_t ret = ClientAddNewSession(sessionName, session);
563 if (ret != SOFTBUS_OK) {
564 SoftBusFree(session);
565 TRANS_LOGE(TRANS_SDK, "client add new session failed, ret=%{public}d.", ret);
566 return ret;
567 }
568 *sessionId = session->sessionId;
569 return SOFTBUS_OK;
570 }
571
ClientDeleteSessionServer(SoftBusSecType type,const char * sessionName)572 int32_t ClientDeleteSessionServer(SoftBusSecType type, const char *sessionName)
573 {
574 if ((type == SEC_TYPE_UNKNOWN) || (sessionName == NULL)) {
575 TRANS_LOGW(TRANS_SDK, "Invalid param");
576 return SOFTBUS_INVALID_PARAM;
577 }
578
579 int32_t ret = LockClientSessionServerList();
580 if (ret != SOFTBUS_OK) {
581 TRANS_LOGE(TRANS_SDK, "lock failed");
582 return ret;
583 }
584
585 ClientSessionServer *serverNode = NULL;
586 ListNode destroyList;
587 ListInit(&destroyList);
588 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
589 if ((strcmp(serverNode->sessionName, sessionName) == 0) && (serverNode->type == type)) {
590 DestroyClientSessionServer(serverNode, &destroyList);
591 g_clientSessionServerList->cnt--;
592 break;
593 }
594 }
595 UnlockClientSessionServerList();
596 (void)ClientDestroySession(&destroyList, SHUTDOWN_REASON_LOCAL);
597 return SOFTBUS_OK;
598 }
599
ClientDeleteSession(int32_t sessionId)600 int32_t ClientDeleteSession(int32_t sessionId)
601 {
602 TRANS_LOGI(TRANS_SDK, "sessionId=%{public}d", sessionId);
603 if (sessionId < 0) {
604 return SOFTBUS_TRANS_INVALID_SESSION_ID;
605 }
606
607 int32_t ret = LockClientSessionServerList();
608 if (ret != SOFTBUS_OK) {
609 TRANS_LOGE(TRANS_SDK, "lock failed");
610 return ret;
611 }
612
613 ClientSessionServer *serverNode = NULL;
614 SessionInfo *sessionNode = NULL;
615
616 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
617 if (IsListEmpty(&serverNode->sessionList)) {
618 continue;
619 }
620 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
621 if (sessionNode->sessionId != sessionId) {
622 continue;
623 }
624 ListDelete(&(sessionNode->node));
625 TRANS_LOGI(TRANS_SDK, "delete session by sessionId=%{public}d success", sessionId);
626 DestroySessionId();
627 if (!sessionNode->lifecycle.condIsWaiting) {
628 (void)SoftBusCondDestroy(&(sessionNode->lifecycle.callbackCond));
629 } else {
630 (void)SoftBusCondSignal(&(sessionNode->lifecycle.callbackCond)); // destroy in CheckSessionEnableStatus
631 TRANS_LOGI(TRANS_SDK, "sessionId=%{public}d condition is waiting", sessionId);
632 }
633 SoftBusFree(sessionNode);
634 UnlockClientSessionServerList();
635 return SOFTBUS_OK;
636 }
637 }
638
639 UnlockClientSessionServerList();
640 TRANS_LOGE(TRANS_SDK, "not found session by sessionId=%{public}d", sessionId);
641 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
642 }
643
ClientGetSessionDataById(int32_t sessionId,char * data,uint16_t len,SessionKey key)644 int32_t ClientGetSessionDataById(int32_t sessionId, char *data, uint16_t len, SessionKey key)
645 {
646 if ((sessionId < 0) || (data == NULL) || (len == 0)) {
647 TRANS_LOGW(TRANS_SDK, "Invalid param");
648 return SOFTBUS_INVALID_PARAM;
649 }
650
651 int32_t ret = LockClientSessionServerList();
652 if (ret != SOFTBUS_OK) {
653 TRANS_LOGE(TRANS_SDK, "lock failed");
654 return ret;
655 }
656
657 ClientSessionServer *serverNode = NULL;
658 SessionInfo *sessionNode = NULL;
659 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
660 UnlockClientSessionServerList();
661 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
662 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
663 }
664 switch (key) {
665 case KEY_SESSION_NAME:
666 ret = strcpy_s(data, len, serverNode->sessionName);
667 break;
668 case KEY_PEER_SESSION_NAME:
669 ret = strcpy_s(data, len, sessionNode->info.peerSessionName);
670 break;
671 case KEY_PEER_DEVICE_ID:
672 ret = strcpy_s(data, len, sessionNode->info.peerDeviceId);
673 break;
674 case KEY_PKG_NAME:
675 ret = strcpy_s(data, len, serverNode->pkgName);
676 break;
677 default:
678 UnlockClientSessionServerList();
679 return SOFTBUS_MEM_ERR;
680 }
681
682 UnlockClientSessionServerList();
683 if (ret != EOK) {
684 TRANS_LOGE(TRANS_SDK, "strcpy_s data info failed, ret=%{public}d", ret);
685 return SOFTBUS_STRCPY_ERR;
686 }
687 return SOFTBUS_OK;
688 }
689
ClientGetSessionIntegerDataById(int32_t sessionId,int * data,SessionKey key)690 int32_t ClientGetSessionIntegerDataById(int32_t sessionId, int *data, SessionKey key)
691 {
692 if ((sessionId < 0) || (data == NULL)) {
693 TRANS_LOGW(TRANS_SDK, "Invalid param");
694 return SOFTBUS_INVALID_PARAM;
695 }
696
697 int32_t ret = LockClientSessionServerList();
698 if (ret != SOFTBUS_OK) {
699 TRANS_LOGE(TRANS_SDK, "lock failed");
700 return ret;
701 }
702
703 ClientSessionServer *serverNode = NULL;
704 SessionInfo *sessionNode = NULL;
705 ret = GetSessionById(sessionId, &serverNode, &sessionNode);
706 if (ret != SOFTBUS_OK) {
707 UnlockClientSessionServerList();
708 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
709 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
710 }
711 switch (key) {
712 case KEY_IS_SERVER:
713 *data = sessionNode->isServer;
714 break;
715 case KEY_PEER_PID:
716 *data = sessionNode->peerPid;
717 break;
718 case KEY_PEER_UID:
719 *data = sessionNode->peerUid;
720 break;
721 case KEY_ACTION_ID:
722 *data = (int32_t)sessionNode->actionId;
723 break;
724 default:
725 UnlockClientSessionServerList();
726 return SOFTBUS_NOT_FIND;
727 }
728
729 UnlockClientSessionServerList();
730 return SOFTBUS_OK;
731 }
732
ClientGetChannelBySessionId(int32_t sessionId,int32_t * channelId,int32_t * type,SessionEnableStatus * enableStatus)733 int32_t ClientGetChannelBySessionId(
734 int32_t sessionId, int32_t *channelId, int32_t *type, SessionEnableStatus *enableStatus)
735 {
736 if (sessionId < 0) {
737 return SOFTBUS_TRANS_INVALID_SESSION_ID;
738 }
739 int32_t ret = LockClientSessionServerList();
740 if (ret != SOFTBUS_OK) {
741 TRANS_LOGE(TRANS_SDK, "lock failed");
742 return ret;
743 }
744
745 ClientSessionServer *serverNode = NULL;
746 SessionInfo *sessionNode = NULL;
747 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
748 UnlockClientSessionServerList();
749 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
750 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
751 }
752
753 if (channelId != NULL) {
754 *channelId = sessionNode->channelId;
755 }
756 if (type != NULL) {
757 *type = sessionNode->channelType;
758 }
759 if (enableStatus != NULL) {
760 *enableStatus = sessionNode->enableStatus;
761 }
762 UnlockClientSessionServerList();
763 return SOFTBUS_OK;
764 }
765
ClientSetEnableStatusBySocket(int32_t socket,SessionEnableStatus enableStatus)766 int32_t ClientSetEnableStatusBySocket(int32_t socket, SessionEnableStatus enableStatus)
767 {
768 if (socket < 0) {
769 TRANS_LOGE(TRANS_INIT, "invalid socket=%{public}d", socket);
770 return SOFTBUS_TRANS_INVALID_SESSION_ID;
771 }
772
773 int32_t ret = LockClientSessionServerList();
774 if (ret != SOFTBUS_OK) {
775 TRANS_LOGE(TRANS_SDK, "lock failed");
776 return ret;
777 }
778
779 ClientSessionServer *serverNode = NULL;
780 SessionInfo *sessionNode = NULL;
781 if (GetSessionById(socket, &serverNode, &sessionNode) != SOFTBUS_OK) {
782 UnlockClientSessionServerList();
783 TRANS_LOGE(TRANS_SDK, "socket not found. socket=%{public}d", socket);
784 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
785 }
786
787 sessionNode->enableStatus = enableStatus;
788 UnlockClientSessionServerList();
789 return SOFTBUS_OK;
790 }
791
ClientGetChannelBusinessTypeBySessionId(int32_t sessionId,int32_t * businessType)792 int32_t ClientGetChannelBusinessTypeBySessionId(int32_t sessionId, int32_t *businessType)
793 {
794 if ((sessionId < 0) || (businessType == NULL)) {
795 return SOFTBUS_INVALID_PARAM;
796 }
797 int32_t ret = LockClientSessionServerList();
798 if (ret != SOFTBUS_OK) {
799 TRANS_LOGE(TRANS_SDK, "lock failed");
800 return ret;
801 }
802
803 ClientSessionServer *serverNode = NULL;
804 SessionInfo *sessionNode = NULL;
805 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
806 UnlockClientSessionServerList();
807 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
808 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
809 }
810
811 *businessType = sessionNode->businessType;
812
813 UnlockClientSessionServerList();
814 return SOFTBUS_OK;
815 }
816
ClientSetChannelBySessionId(int32_t sessionId,TransInfo * transInfo)817 int32_t ClientSetChannelBySessionId(int32_t sessionId, TransInfo *transInfo)
818 {
819 if ((sessionId < 0) || (transInfo->channelId < 0)) {
820 TRANS_LOGW(TRANS_SDK, "Invalid param");
821 return SOFTBUS_INVALID_PARAM;
822 }
823
824 int32_t ret = LockClientSessionServerList();
825 if (ret != SOFTBUS_OK) {
826 TRANS_LOGE(TRANS_SDK, "lock failed");
827 return ret;
828 }
829
830 ClientSessionServer *serverNode = NULL;
831 SessionInfo *sessionNode = NULL;
832 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
833 UnlockClientSessionServerList();
834 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
835 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
836 }
837 sessionNode->channelId = transInfo->channelId;
838 sessionNode->channelType = (ChannelType)transInfo->channelType;
839 TRANS_LOGI(TRANS_SDK, "Client set channel by sessionId success, sessionId=%{public}d, channelId=%{public}d, "
840 "channelType=%{public}d", sessionId, sessionNode->channelId, sessionNode->channelType);
841
842 UnlockClientSessionServerList();
843 return SOFTBUS_OK;
844 }
845
GetEncryptByChannelId(int32_t channelId,int32_t channelType,int32_t * data)846 int32_t GetEncryptByChannelId(int32_t channelId, int32_t channelType, int32_t *data)
847 {
848 if ((channelId < 0) || (data == NULL)) {
849 TRANS_LOGW(TRANS_SDK, "Invalid param");
850 return SOFTBUS_INVALID_PARAM;
851 }
852
853 int32_t ret = LockClientSessionServerList();
854 if (ret != SOFTBUS_OK) {
855 TRANS_LOGE(TRANS_SDK, "lock failed");
856 return ret;
857 }
858
859 ClientSessionServer *serverNode = NULL;
860 SessionInfo *sessionNode = NULL;
861
862 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
863 if (IsListEmpty(&serverNode->sessionList)) {
864 continue;
865 }
866
867 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
868 if (sessionNode->channelId == channelId && (int32_t)sessionNode->channelType == channelType) {
869 *data = (int32_t)sessionNode->isEncrypt;
870 UnlockClientSessionServerList();
871 return SOFTBUS_OK;
872 }
873 }
874 }
875
876 UnlockClientSessionServerList();
877 TRANS_LOGE(TRANS_SDK, "not found session by channelId=%{public}d", channelId);
878 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
879 }
880
ClientGetSessionStateByChannelId(int32_t channelId,int32_t channelType,SessionState * sessionState)881 int32_t ClientGetSessionStateByChannelId(int32_t channelId, int32_t channelType, SessionState *sessionState)
882 {
883 if ((channelId < 0) || (sessionState == NULL)) {
884 TRANS_LOGW(TRANS_SDK, "Invalid param, channelId=%{public}d, channelType=%{public}d", channelId, channelType);
885 return SOFTBUS_INVALID_PARAM;
886 }
887
888 int32_t ret = LockClientSessionServerList();
889 if (ret != SOFTBUS_OK) {
890 TRANS_LOGE(TRANS_SDK, "lock failed");
891 return ret;
892 }
893
894 ClientSessionServer *serverNode = NULL;
895 SessionInfo *sessionNode = NULL;
896
897 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
898 if (IsListEmpty(&serverNode->sessionList)) {
899 continue;
900 }
901
902 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
903 if (sessionNode->channelId == channelId && sessionNode->channelType == (ChannelType)channelType) {
904 *sessionState = sessionNode->lifecycle.sessionState;
905 UnlockClientSessionServerList();
906 return SOFTBUS_OK;
907 }
908 }
909 }
910
911 UnlockClientSessionServerList();
912 TRANS_LOGE(TRANS_SDK, "not found session by channelId=%{public}d", channelId);
913 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
914 }
915
ClientGetSessionIdByChannelId(int32_t channelId,int32_t channelType,int32_t * sessionId)916 int32_t ClientGetSessionIdByChannelId(int32_t channelId, int32_t channelType, int32_t *sessionId)
917 {
918 if ((channelId < 0) || (sessionId == NULL)) {
919 TRANS_LOGW(TRANS_SDK, "Invalid param");
920 return SOFTBUS_INVALID_PARAM;
921 }
922
923 int32_t ret = LockClientSessionServerList();
924 if (ret != SOFTBUS_OK) {
925 TRANS_LOGE(TRANS_SDK, "lock failed");
926 return ret;
927 }
928
929 ClientSessionServer *serverNode = NULL;
930 SessionInfo *sessionNode = NULL;
931
932 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
933 if (IsListEmpty(&serverNode->sessionList)) {
934 continue;
935 }
936
937 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
938 if (sessionNode->channelId == channelId && sessionNode->channelType == (ChannelType)channelType) {
939 *sessionId = sessionNode->sessionId;
940 UnlockClientSessionServerList();
941 return SOFTBUS_OK;
942 }
943 }
944 }
945
946 UnlockClientSessionServerList();
947 TRANS_LOGE(TRANS_SDK, "not found session by channelId=%{public}d", channelId);
948 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
949 }
950
ClientGetSessionIsAsyncBySessionId(int32_t sessionId,bool * isAsync)951 int32_t ClientGetSessionIsAsyncBySessionId(int32_t sessionId, bool *isAsync)
952 {
953 if ((sessionId < 0) || (isAsync == NULL)) {
954 TRANS_LOGW(TRANS_SDK, "Invalid param");
955 return SOFTBUS_INVALID_PARAM;
956 }
957
958 int32_t ret = LockClientSessionServerList();
959 if (ret != SOFTBUS_OK) {
960 TRANS_LOGE(TRANS_SDK, "lock failed");
961 return ret;
962 }
963 ClientSessionServer *serverNode = NULL;
964 SessionInfo *sessionNode = NULL;
965 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
966 if (IsListEmpty(&serverNode->sessionList)) {
967 continue;
968 }
969
970 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
971 if (sessionNode->sessionId == sessionId) {
972 *isAsync = sessionNode->isAsync;
973 UnlockClientSessionServerList();
974 return SOFTBUS_OK;
975 }
976 }
977 }
978
979 UnlockClientSessionServerList();
980 TRANS_LOGE(TRANS_SDK, "not found session with sessionId=%{public}d", sessionId);
981 return SOFTBUS_NOT_FIND;
982 }
983
ClientGetRouteTypeByChannelId(int32_t channelId,int32_t channelType,int32_t * routeType)984 int32_t ClientGetRouteTypeByChannelId(int32_t channelId, int32_t channelType, int32_t *routeType)
985 {
986 if ((channelId < 0) || (routeType == NULL)) {
987 TRANS_LOGW(TRANS_SDK, "Invalid param");
988 return SOFTBUS_INVALID_PARAM;
989 }
990
991 int32_t ret = LockClientSessionServerList();
992 if (ret != SOFTBUS_OK) {
993 TRANS_LOGE(TRANS_SDK, "lock failed");
994 return ret;
995 }
996
997 ClientSessionServer *serverNode = NULL;
998 SessionInfo *sessionNode = NULL;
999
1000 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1001 if (IsListEmpty(&serverNode->sessionList)) {
1002 continue;
1003 }
1004
1005 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
1006 if (sessionNode->channelId == channelId && sessionNode->channelType == (ChannelType)channelType) {
1007 *routeType = sessionNode->routeType;
1008 UnlockClientSessionServerList();
1009 return SOFTBUS_OK;
1010 }
1011 }
1012 }
1013
1014 UnlockClientSessionServerList();
1015 TRANS_LOGE(TRANS_SDK, "not found session by channelId=%{public}d", channelId);
1016 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1017 }
1018
ClientGetDataConfigByChannelId(int32_t channelId,int32_t channelType,uint32_t * dataConfig)1019 int32_t ClientGetDataConfigByChannelId(int32_t channelId, int32_t channelType, uint32_t *dataConfig)
1020 {
1021 if ((channelId < 0) || (dataConfig == NULL)) {
1022 TRANS_LOGW(TRANS_SDK, "Invalid param");
1023 return SOFTBUS_INVALID_PARAM;
1024 }
1025
1026 int32_t ret = LockClientSessionServerList();
1027 if (ret != SOFTBUS_OK) {
1028 TRANS_LOGE(TRANS_SDK, "lock failed");
1029 return ret;
1030 }
1031
1032 ClientSessionServer *serverNode = NULL;
1033 SessionInfo *sessionNode = NULL;
1034
1035 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1036 if (IsListEmpty(&serverNode->sessionList)) {
1037 continue;
1038 }
1039
1040 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
1041 if (sessionNode->channelId == channelId && sessionNode->channelType == (ChannelType)channelType) {
1042 *dataConfig = sessionNode->dataConfig;
1043 UnlockClientSessionServerList();
1044 return SOFTBUS_OK;
1045 }
1046 }
1047 }
1048
1049 UnlockClientSessionServerList();
1050 TRANS_LOGE(TRANS_SDK, "not found session by channelId=%{public}d", channelId);
1051 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1052 }
1053
1054 // Only need to operate on the action guidance ishare auth channel
ClientSetAuthSessionTimer(const ClientSessionServer * serverNode,SessionInfo * sessionNode)1055 static void ClientSetAuthSessionTimer(const ClientSessionServer *serverNode, SessionInfo *sessionNode)
1056 {
1057 if (strcmp(serverNode->sessionName, ISHARE_AUTH_SESSION) == 0 && sessionNode->channelType == CHANNEL_TYPE_AUTH &&
1058 sessionNode->actionId != 0) {
1059 sessionNode->lifecycle.maxWaitTime = ISHARE_AUTH_SESSION_MAX_IDLE_TIME;
1060 sessionNode->lifecycle.waitTime = 0;
1061 TRANS_LOGI(TRANS_SDK, "set auth sessionId=%{public}d waitTime success.", sessionNode->sessionId);
1062 }
1063 }
1064
ClientEnableSessionByChannelId(const ChannelInfo * channel,int32_t * sessionId)1065 int32_t ClientEnableSessionByChannelId(const ChannelInfo *channel, int32_t *sessionId)
1066 {
1067 TRANS_CHECK_AND_RETURN_RET_LOGE(
1068 (channel != NULL && sessionId != NULL), SOFTBUS_INVALID_PARAM, TRANS_SDK, "Invalid param");
1069
1070 int32_t ret = LockClientSessionServerList();
1071 if (ret != SOFTBUS_OK) {
1072 TRANS_LOGE(TRANS_SDK, "lock failed");
1073 return ret;
1074 }
1075
1076 ClientSessionServer *serverNode = NULL;
1077 SessionInfo *sessionNode = NULL;
1078
1079 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1080 if (IsListEmpty(&serverNode->sessionList)) {
1081 continue;
1082 }
1083
1084 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
1085 if ((sessionNode->channelId == channel->channelId) &&
1086 (sessionNode->channelType == (ChannelType)(channel->channelType))) {
1087 sessionNode->peerPid = channel->peerPid;
1088 sessionNode->peerUid = channel->peerUid;
1089 sessionNode->isServer = channel->isServer;
1090 sessionNode->enableStatus = ENABLE_STATUS_SUCCESS;
1091 sessionNode->routeType = channel->routeType;
1092 sessionNode->businessType = channel->businessType;
1093 sessionNode->fileEncrypt = channel->fileEncrypt;
1094 sessionNode->dataConfig = channel->dataConfig;
1095 sessionNode->algorithm = channel->algorithm;
1096 sessionNode->crc = channel->crc;
1097 sessionNode->isEncrypt = channel->isEncrypt;
1098 sessionNode->osType = channel->osType;
1099 *sessionId = sessionNode->sessionId;
1100 if (channel->channelType == CHANNEL_TYPE_AUTH || !sessionNode->isEncrypt) {
1101 ClientSetAuthSessionTimer(serverNode, sessionNode);
1102 if (memcpy_s(sessionNode->info.peerDeviceId, DEVICE_ID_SIZE_MAX,
1103 channel->peerDeviceId, DEVICE_ID_SIZE_MAX) != EOK) {
1104 UnlockClientSessionServerList();
1105 return SOFTBUS_MEM_ERR;
1106 }
1107 }
1108 UnlockClientSessionServerList();
1109 return SOFTBUS_OK;
1110 }
1111 }
1112 }
1113
1114 UnlockClientSessionServerList();
1115 TRANS_LOGE(TRANS_SDK, "not found session by channelId=%{public}d, channelType=%{public}d",
1116 channel->channelId, channel->channelType);
1117 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1118 }
1119
ClientGetSessionCallbackById(int32_t sessionId,ISessionListener * callback)1120 int32_t ClientGetSessionCallbackById(int32_t sessionId, ISessionListener *callback)
1121 {
1122 if (sessionId < 0 || callback == NULL) {
1123 TRANS_LOGW(TRANS_SDK, "Invalid param");
1124 return SOFTBUS_INVALID_PARAM;
1125 }
1126
1127 int32_t ret = LockClientSessionServerList();
1128 if (ret != SOFTBUS_OK) {
1129 TRANS_LOGE(TRANS_SDK, "lock failed");
1130 return ret;
1131 }
1132
1133 ClientSessionServer *serverNode = NULL;
1134 SessionInfo *sessionNode = NULL;
1135 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
1136 UnlockClientSessionServerList();
1137 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
1138 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1139 }
1140
1141 ret = memcpy_s(callback, sizeof(ISessionListener), &serverNode->listener.session, sizeof(ISessionListener));
1142 UnlockClientSessionServerList();
1143 if (ret != EOK) {
1144 return SOFTBUS_MEM_ERR;
1145 }
1146 return SOFTBUS_OK;
1147 }
1148
ClientGetSessionCallbackByName(const char * sessionName,ISessionListener * callback)1149 int32_t ClientGetSessionCallbackByName(const char *sessionName, ISessionListener *callback)
1150 {
1151 if (sessionName == NULL || callback == NULL) {
1152 TRANS_LOGW(TRANS_SDK, "Invalid param");
1153 return SOFTBUS_INVALID_PARAM;
1154 }
1155
1156 int32_t ret = LockClientSessionServerList();
1157 if (ret != SOFTBUS_OK) {
1158 TRANS_LOGE(TRANS_SDK, "lock failed");
1159 return ret;
1160 }
1161
1162 ClientSessionServer *serverNode = NULL;
1163
1164 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1165 if (strcmp(serverNode->sessionName, sessionName) != 0) {
1166 continue;
1167 }
1168
1169 ret = memcpy_s(callback, sizeof(ISessionListener), &serverNode->listener.session, sizeof(ISessionListener));
1170 UnlockClientSessionServerList();
1171 if (ret != EOK) {
1172 return SOFTBUS_MEM_ERR;
1173 }
1174 return SOFTBUS_OK;
1175 }
1176
1177 UnlockClientSessionServerList();
1178 char *tmpName = NULL;
1179 Anonymize(sessionName, &tmpName);
1180 TRANS_LOGE(TRANS_SDK, "not found session by sessionName=%{public}s", tmpName);
1181 AnonymizeFree(tmpName);
1182 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1183 }
1184
ClientGetSessionSide(int32_t sessionId)1185 int32_t ClientGetSessionSide(int32_t sessionId)
1186 {
1187 int32_t ret = LockClientSessionServerList();
1188 if (ret != SOFTBUS_OK) {
1189 TRANS_LOGE(TRANS_SDK, "lock failed");
1190 return ret;
1191 }
1192
1193 int32_t side = -1;
1194 ClientSessionServer *serverNode = NULL;
1195 SessionInfo *sessionNode = NULL;
1196
1197 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1198 if (IsListEmpty(&serverNode->sessionList)) {
1199 continue;
1200 }
1201 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
1202 if (sessionNode->sessionId != sessionId) {
1203 continue;
1204 }
1205 side = sessionNode->isServer ? IS_SERVER : IS_CLIENT;
1206 UnlockClientSessionServerList();
1207 return side;
1208 }
1209 }
1210 UnlockClientSessionServerList();
1211 return side;
1212 }
1213
ClientTransLnnOfflineProc(NodeBasicInfo * info)1214 static void ClientTransLnnOfflineProc(NodeBasicInfo *info)
1215 {
1216 TRANS_LOGD(TRANS_SDK, "device offline callback enter.");
1217 if (info == NULL) {
1218 return;
1219 }
1220 if (LockClientSessionServerList() != SOFTBUS_OK) {
1221 TRANS_LOGE(TRANS_SDK, "lock failed");
1222 return;
1223 }
1224
1225 ClientSessionServer *serverNode = NULL;
1226 ListNode destroyList;
1227 ListInit(&destroyList);
1228 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1229 DestroyClientSessionByNetworkId(serverNode, info->networkId, ROUTE_TYPE_ALL, &destroyList);
1230 }
1231 UnlockClientSessionServerList();
1232 (void)ClientDestroySession(&destroyList, SHUTDOWN_REASON_LNN_OFFLINE);
1233 return;
1234 }
1235
1236 static INodeStateCb g_transLnnCb = {
1237 .events = EVENT_NODE_STATE_OFFLINE,
1238 .onNodeOffline = ClientTransLnnOfflineProc,
1239 };
1240
ClientTransRegLnnOffline(void)1241 void ClientTransRegLnnOffline(void)
1242 {
1243 int32_t ret;
1244 ret = RegNodeDeviceStateCbInner("trans", &g_transLnnCb);
1245 if (ret != SOFTBUS_OK) {
1246 TRANS_LOGE(TRANS_SDK, "reg lnn offline fail");
1247 }
1248 }
1249
ClientTransOnLinkDown(const char * networkId,int32_t routeType)1250 void ClientTransOnLinkDown(const char *networkId, int32_t routeType)
1251 {
1252 if (networkId == NULL) {
1253 return;
1254 }
1255 if (LockClientSessionServerList() != SOFTBUS_OK) {
1256 TRANS_LOGE(TRANS_SDK, "lock failed");
1257 return;
1258 }
1259 char *anonyNetworkId = NULL;
1260 Anonymize(networkId, &anonyNetworkId);
1261 TRANS_LOGD(TRANS_SDK, "routeType=%{public}d, networkId=%{public}s", routeType, anonyNetworkId);
1262 AnonymizeFree(anonyNetworkId);
1263
1264 ClientSessionServer *serverNode = NULL;
1265 ListNode destroyList;
1266 ListInit(&destroyList);
1267 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1268 if (strcmp(CAST_SESSION, serverNode->sessionName) == 0 && CheckIsSystemService()) {
1269 TRANS_LOGD(TRANS_SDK, "cast plus sessionname is different");
1270 continue;
1271 }
1272 DestroyClientSessionByNetworkId(serverNode, networkId, routeType, &destroyList);
1273 }
1274 UnlockClientSessionServerList();
1275 (void)ClientDestroySession(&destroyList, SHUTDOWN_REASON_LINK_DOWN);
1276 return;
1277 }
1278
ClientGetFileConfigInfoById(int32_t sessionId,int32_t * fileEncrypt,int32_t * algorithm,int32_t * crc)1279 int32_t ClientGetFileConfigInfoById(int32_t sessionId, int32_t *fileEncrypt, int32_t *algorithm, int32_t *crc)
1280 {
1281 if (sessionId < 0 || fileEncrypt == NULL || algorithm == NULL || crc == NULL) {
1282 TRANS_LOGW(TRANS_SDK, "Invalid param");
1283 return SOFTBUS_INVALID_PARAM;
1284 }
1285
1286 int32_t ret = LockClientSessionServerList();
1287 if (ret != SOFTBUS_OK) {
1288 TRANS_LOGE(TRANS_SDK, "lock failed");
1289 return ret;
1290 }
1291
1292 ClientSessionServer *serverNode = NULL;
1293 SessionInfo *sessionNode = NULL;
1294 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
1295 UnlockClientSessionServerList();
1296 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
1297 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1298 }
1299 *fileEncrypt = sessionNode->fileEncrypt;
1300 *algorithm = sessionNode->algorithm;
1301 *crc = sessionNode->crc;
1302 UnlockClientSessionServerList();
1303 return SOFTBUS_OK;
1304 }
1305
ClientCleanAllSessionWhenServerDeath(ListNode * sessionServerInfoList)1306 void ClientCleanAllSessionWhenServerDeath(ListNode *sessionServerInfoList)
1307 {
1308 if (sessionServerInfoList == NULL) {
1309 TRANS_LOGE(TRANS_SDK, "invalid param.");
1310 return;
1311 }
1312
1313 if (LockClientSessionServerList() != SOFTBUS_OK) {
1314 TRANS_LOGE(TRANS_SDK, "lock failed");
1315 return;
1316 }
1317 uint32_t destroyCnt = 0;
1318 ListNode destroyList;
1319 ListInit(&destroyList);
1320 ClientSessionServer *serverNode = NULL;
1321 SessionInfo *sessionNode = NULL;
1322 SessionInfo *nextSessionNode = NULL;
1323 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1324 serverNode->sessionAddingCnt = 0;
1325 SessionServerInfo *info = CreateSessionServerInfoNode(serverNode);
1326 if (info != NULL) {
1327 ListAdd(sessionServerInfoList, &info->node);
1328 }
1329 if (IsListEmpty(&serverNode->sessionList)) {
1330 continue;
1331 }
1332 LIST_FOR_EACH_ENTRY_SAFE(sessionNode, nextSessionNode, &(serverNode->sessionList), SessionInfo, node) {
1333 if (sessionNode->role == SESSION_ROLE_SERVER) {
1334 TRANS_LOGD(TRANS_SDK, "cannot delete socket for listening, socket=%{public}d", sessionNode->sessionId);
1335 continue;
1336 }
1337 DestroySessionInfo *destroyNode = CreateDestroySessionNode(sessionNode, serverNode);
1338 if (destroyNode == NULL) {
1339 continue;
1340 }
1341 ListAdd(&destroyList, &(destroyNode->node));
1342 DestroySessionId();
1343 ListDelete(&sessionNode->node);
1344 SoftBusFree(sessionNode);
1345 ++destroyCnt;
1346 }
1347 }
1348 UnlockClientSessionServerList();
1349 (void)ClientDestroySession(&destroyList, SHUTDOWN_REASON_SERVICE_DIED);
1350 TRANS_LOGI(TRANS_SDK, "client destroy session cnt=%{public}d.", destroyCnt);
1351 }
1352
ClientAddSocketServer(SoftBusSecType type,const char * pkgName,const char * sessionName)1353 int32_t ClientAddSocketServer(SoftBusSecType type, const char *pkgName, const char *sessionName)
1354 {
1355 if (pkgName == NULL || sessionName == NULL) {
1356 return SOFTBUS_INVALID_PARAM;
1357 }
1358
1359 int32_t ret = LockClientSessionServerList();
1360 if (ret != SOFTBUS_OK) {
1361 TRANS_LOGE(TRANS_SDK, "lock failed");
1362 return ret;
1363 }
1364 if (SocketServerIsExistAndUpdate(sessionName)) {
1365 UnlockClientSessionServerList();
1366 return SOFTBUS_SERVER_NAME_REPEATED;
1367 }
1368
1369 if (g_clientSessionServerList->cnt >= MAX_SESSION_SERVER_NUMBER) {
1370 ShowClientSessionServer();
1371 UnlockClientSessionServerList();
1372 TRANS_LOGE(TRANS_SDK, "ClientAddSocketServer: client server num reach max");
1373 return SOFTBUS_INVALID_NUM;
1374 }
1375
1376 ClientSessionServer *server = GetNewSocketServer(type, sessionName, pkgName);
1377 if (server == NULL) {
1378 UnlockClientSessionServerList();
1379 return SOFTBUS_MEM_ERR;
1380 }
1381 server->permissionState = true;
1382 ListAdd(&g_clientSessionServerList->list, &server->node);
1383 g_clientSessionServerList->cnt++;
1384
1385 UnlockClientSessionServerList();
1386 char *anonymizePkgName = NULL;
1387 char *tmpName = NULL;
1388 Anonymize(pkgName, &anonymizePkgName);
1389 Anonymize(sessionName, &tmpName);
1390 TRANS_LOGE(TRANS_SDK, "sessionName=%{public}s, pkgName=%{public}s", tmpName, anonymizePkgName);
1391 AnonymizeFree(anonymizePkgName);
1392 AnonymizeFree(tmpName);
1393 return SOFTBUS_OK;
1394 }
1395
DeleteSocketSession(int32_t sessionId,char * pkgName,char * sessionName)1396 int32_t DeleteSocketSession(int32_t sessionId, char *pkgName, char *sessionName)
1397 {
1398 int32_t ret = LockClientSessionServerList();
1399 if (ret != SOFTBUS_OK) {
1400 TRANS_LOGE(TRANS_SDK, "lock failed");
1401 return ret;
1402 }
1403
1404 ClientSessionServer *serverNode = NULL;
1405 SessionInfo *sessionNode = NULL;
1406 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
1407 UnlockClientSessionServerList();
1408 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
1409 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1410 }
1411
1412 if (strcpy_s(pkgName, PKG_NAME_SIZE_MAX, serverNode->pkgName) != EOK) {
1413 UnlockClientSessionServerList();
1414 TRANS_LOGE(TRANS_SDK, "strcpy pkgName failed");
1415 return SOFTBUS_STRCPY_ERR;
1416 }
1417
1418 if (strcpy_s(sessionName, SESSION_NAME_SIZE_MAX, serverNode->sessionName) != EOK) {
1419 UnlockClientSessionServerList();
1420 TRANS_LOGE(TRANS_SDK, "strcpy sessionName failed");
1421 return SOFTBUS_STRCPY_ERR;
1422 }
1423 ListDelete(&(sessionNode->node));
1424 TRANS_LOGI(TRANS_SDK, "delete session, sessionId=%{public}d", sessionId);
1425 DestroySessionId();
1426 if (!sessionNode->lifecycle.condIsWaiting) {
1427 (void)SoftBusCondDestroy(&(sessionNode->lifecycle.callbackCond));
1428 } else {
1429 (void)SoftBusCondSignal(&(sessionNode->lifecycle.callbackCond)); // destroy in CheckSessionEnableStatus
1430 TRANS_LOGI(TRANS_SDK, "sessionId=%{public}d condition is waiting", sessionId);
1431 }
1432 SoftBusFree(sessionNode);
1433 UnlockClientSessionServerList();
1434 return SOFTBUS_OK;
1435 }
1436
GetSocketExistSession(const SessionParam * param,bool isEncyptedRawStream)1437 static SessionInfo *GetSocketExistSession(const SessionParam *param, bool isEncyptedRawStream)
1438 {
1439 ClientSessionServer *serverNode = NULL;
1440 SessionInfo *sessionInfo = NULL;
1441 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1442 // distributeddata module can create different socket of whether the SocketInfo is same or not
1443 if ((strcmp(serverNode->sessionName, param->sessionName) != 0) || IsListEmpty(&serverNode->sessionList) ||
1444 IsDistributedDataSession(param->sessionName)) {
1445 continue;
1446 }
1447 LIST_FOR_EACH_ENTRY(sessionInfo, &(serverNode->sessionList), SessionInfo, node) {
1448 if (sessionInfo->isServer || (strcmp(sessionInfo->info.peerSessionName, param->peerSessionName) != 0) ||
1449 (strcmp(sessionInfo->info.peerDeviceId, param->peerDeviceId) != 0) ||
1450 (strcmp(sessionInfo->info.groupId, param->groupId) != 0) ||
1451 IsDifferentDataType(sessionInfo, param->attr->dataType, isEncyptedRawStream)) {
1452 continue;
1453 }
1454 return sessionInfo;
1455 }
1456 }
1457 return NULL;
1458 }
1459
ClientAddSocketSession(const SessionParam * param,bool isEncyptedRawStream,int32_t * sessionId,SessionEnableStatus * isEnabled)1460 int32_t ClientAddSocketSession(
1461 const SessionParam *param, bool isEncyptedRawStream, int32_t *sessionId, SessionEnableStatus *isEnabled)
1462 {
1463 if (param == NULL || param->sessionName == NULL || param->groupId == NULL || param->attr == NULL ||
1464 sessionId == NULL) {
1465 TRANS_LOGE(TRANS_SDK, "Invalid param");
1466 return SOFTBUS_INVALID_PARAM;
1467 }
1468 int32_t ret = LockClientSessionServerList();
1469 if (ret != SOFTBUS_OK) {
1470 TRANS_LOGE(TRANS_SDK, "lock failed");
1471 return ret;
1472 }
1473
1474 SessionInfo *session = GetSocketExistSession(param, isEncyptedRawStream);
1475 if (session != NULL) {
1476 if (session->lifecycle.bindErrCode != SOFTBUS_TRANS_STOP_BIND_BY_CANCEL) {
1477 *sessionId = session->sessionId;
1478 *isEnabled = session->enableStatus;
1479 UnlockClientSessionServerList();
1480 return SOFTBUS_TRANS_SESSION_REPEATED;
1481 }
1482 TRANS_LOGI(TRANS_SDK, "socket=%{public}d is shutdown", session->sessionId);
1483 }
1484
1485 session = CreateNewSocketSession(param);
1486 if (session == NULL) {
1487 UnlockClientSessionServerList();
1488 TRANS_LOGE(TRANS_SDK, "create session failed");
1489 return SOFTBUS_TRANS_SESSION_CREATE_FAILED;
1490 }
1491 session->isEncyptedRawStream = isEncyptedRawStream;
1492 ret = AddSession(param->sessionName, session);
1493 if (ret != SOFTBUS_OK) {
1494 SoftBusFree(session);
1495 UnlockClientSessionServerList();
1496 TRANS_LOGE(TRANS_SDK, "Add Session failed, ret=%{public}d", ret);
1497 return ret;
1498 }
1499
1500 *sessionId = session->sessionId;
1501 UnlockClientSessionServerList();
1502 return SOFTBUS_OK;
1503 }
1504
ClientSetListenerBySessionId(int32_t sessionId,const ISocketListener * listener,bool isServer)1505 int32_t ClientSetListenerBySessionId(int32_t sessionId, const ISocketListener *listener, bool isServer)
1506 {
1507 if ((sessionId < 0) || listener == NULL) {
1508 TRANS_LOGE(TRANS_SDK, "Invalid param");
1509 return SOFTBUS_INVALID_PARAM;
1510 }
1511 int32_t ret = LockClientSessionServerList();
1512 if (ret != SOFTBUS_OK) {
1513 TRANS_LOGE(TRANS_SDK, "lock failed");
1514 return ret;
1515 }
1516
1517 ClientSessionServer *serverNode = NULL;
1518 SessionInfo *sessionNode = NULL;
1519 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
1520 UnlockClientSessionServerList();
1521 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
1522 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1523 }
1524
1525 if (sessionNode->role != SESSION_ROLE_INIT) {
1526 TRANS_LOGE(TRANS_SDK, "socket in use, currentRole=%{public}d", sessionNode->role);
1527 UnlockClientSessionServerList();
1528 return SOFTBUS_TRANS_SOCKET_IN_USE;
1529 }
1530 ISocketListener *socketListener = isServer ? &(serverNode->listener.socketServer) :
1531 &(serverNode->listener.socketClient);
1532 ret = memcpy_s(socketListener, sizeof(ISocketListener), listener, sizeof(ISocketListener));
1533 if (ret != EOK) {
1534 UnlockClientSessionServerList();
1535 TRANS_LOGE(TRANS_SDK, "memcpy_s socketListener failed, ret=%{public}d", ret);
1536 return SOFTBUS_MEM_ERR;
1537 }
1538 serverNode->listener.isSocketListener = true;
1539 if (socketListener->OnFile == NULL) {
1540 UnlockClientSessionServerList();
1541 return SOFTBUS_OK;
1542 }
1543 ret = TransSetSocketFileListener(serverNode->sessionName, socketListener->OnFile, isServer);
1544 if (ret != SOFTBUS_OK) {
1545 UnlockClientSessionServerList();
1546 TRANS_LOGE(TRANS_SDK, "register socket file listener failed");
1547 return ret;
1548 }
1549 UnlockClientSessionServerList();
1550 return SOFTBUS_OK;
1551 }
1552
ClientIpcOpenSession(int32_t sessionId,const QosTV * qos,uint32_t qosCount,TransInfo * transInfo,bool isAsync)1553 int32_t ClientIpcOpenSession(int32_t sessionId, const QosTV *qos, uint32_t qosCount, TransInfo *transInfo, bool isAsync)
1554 {
1555 if (sessionId < 0 || transInfo == NULL) {
1556 TRANS_LOGE(TRANS_SDK, "Invalid param");
1557 return SOFTBUS_INVALID_PARAM;
1558 }
1559
1560 int32_t ret = LockClientSessionServerList();
1561 if (ret != SOFTBUS_OK) {
1562 TRANS_LOGE(TRANS_SDK, "lock failed");
1563 return ret;
1564 }
1565
1566 ClientSessionServer *serverNode = NULL;
1567 SessionInfo *sessionNode = NULL;
1568 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
1569 UnlockClientSessionServerList();
1570 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
1571 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1572 }
1573 ret = CheckBindSocketInfo(sessionNode);
1574 if (ret != SOFTBUS_OK) {
1575 UnlockClientSessionServerList();
1576 TRANS_LOGE(TRANS_SDK, "check socekt info failed, ret=%{public}d", ret);
1577 return ret;
1578 }
1579
1580 SessionAttribute tmpAttr;
1581 (void)memset_s(&tmpAttr, sizeof(SessionAttribute), 0, sizeof(SessionAttribute));
1582 SessionParam param;
1583 FillSessionParam(¶m, &tmpAttr, serverNode, sessionNode);
1584 UnlockClientSessionServerList();
1585
1586 param.qosCount = qosCount;
1587 if (param.qosCount > 0 && memcpy_s(param.qos, sizeof(param.qos), qos, sizeof(QosTV) * qosCount) != EOK) {
1588 TRANS_LOGE(TRANS_SDK, "memcpy qos failed");
1589 return SOFTBUS_MEM_ERR;
1590 }
1591 param.isAsync = isAsync;
1592 param.sessionId = sessionId;
1593 ret = SetSessionStateBySessionId(param.sessionId, SESSION_STATE_OPENING, 0);
1594 TRANS_CHECK_AND_RETURN_RET_LOGE(
1595 ret == SOFTBUS_OK, ret, TRANS_SDK, "set session state failed, maybe cancel, ret=%{public}d", ret);
1596 ret = ServerIpcOpenSession(¶m, transInfo);
1597 if (ret != SOFTBUS_OK) {
1598 ClientConvertRetVal(sessionId, &ret);
1599 TRANS_LOGE(TRANS_SDK, "open session ipc err: ret=%{public}d", ret);
1600 return ret;
1601 }
1602 return SOFTBUS_OK;
1603 }
1604
ClientSetActionIdBySessionId(int32_t sessionId,uint32_t actionId)1605 int32_t ClientSetActionIdBySessionId(int32_t sessionId, uint32_t actionId)
1606 {
1607 if ((sessionId < 0) || actionId == 0) {
1608 TRANS_LOGE(TRANS_SDK, "Invalid param");
1609 return SOFTBUS_INVALID_PARAM;
1610 }
1611 if (g_clientSessionServerList == NULL) {
1612 TRANS_LOGE(TRANS_SDK, "not init");
1613 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
1614 }
1615 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
1616 TRANS_LOGE(TRANS_SDK, "lock failed");
1617 return SOFTBUS_LOCK_ERR;
1618 }
1619
1620 ClientSessionServer *serverNode = NULL;
1621 SessionInfo *sessionNode = NULL;
1622
1623 int32_t ret = GetSessionById(sessionId, &serverNode, &sessionNode);
1624 if (ret != SOFTBUS_OK) {
1625 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1626 TRANS_LOGE(TRANS_SDK, "not found");
1627 return ret;
1628 }
1629
1630 if (sessionNode->role != SESSION_ROLE_INIT) {
1631 TRANS_LOGE(TRANS_SDK, "socket in use, currentRole=%{public}d", sessionNode->role);
1632 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1633 return SOFTBUS_TRANS_SOCKET_IN_USE;
1634 }
1635
1636 sessionNode->actionId = actionId;
1637 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1638 return SOFTBUS_OK;
1639 }
1640
ClientHandleBindWaitTimer(int32_t socket,uint32_t maxWaitTime,TimerAction action)1641 int32_t ClientHandleBindWaitTimer(int32_t socket, uint32_t maxWaitTime, TimerAction action)
1642 {
1643 if (socket <= 0) {
1644 TRANS_LOGE(TRANS_SDK, "Invalid socket=%{public}d", socket);
1645 return SOFTBUS_INVALID_PARAM;
1646 }
1647
1648 if (action < TIMER_ACTION_START || action >= TIMER_ACTION_BUTT) {
1649 TRANS_LOGE(TRANS_SDK, "Invalid action=%{public}d", action);
1650 return SOFTBUS_INVALID_PARAM;
1651 }
1652
1653 int32_t ret = LockClientSessionServerList();
1654 if (ret != SOFTBUS_OK) {
1655 TRANS_LOGE(TRANS_SDK, "lock failed");
1656 return ret;
1657 }
1658
1659 ClientSessionServer *serverNode = NULL;
1660 SessionInfo *sessionNode = NULL;
1661 if (GetSessionById(socket, &serverNode, &sessionNode) != SOFTBUS_OK) {
1662 UnlockClientSessionServerList();
1663 TRANS_LOGE(TRANS_SDK, "socket not found. socket=%{public}d", socket);
1664 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1665 }
1666 if (action == TIMER_ACTION_START) {
1667 TRANS_LOGI(TRANS_SDK,
1668 "socket=%{public}d, inputMaxWaitTime=%{public}u, maxWaitTime=%{public}u, enableStatus=%{public}d",
1669 socket, maxWaitTime, sessionNode->lifecycle.maxWaitTime, sessionNode->enableStatus);
1670 bool binding = (sessionNode->lifecycle.maxWaitTime != 0);
1671 bool bindSuccess =
1672 (sessionNode->lifecycle.maxWaitTime == 0 && sessionNode->enableStatus == ENABLE_STATUS_SUCCESS);
1673 if (binding) {
1674 UnlockClientSessionServerList();
1675 TRANS_LOGE(TRANS_SDK, "socket=%{public}d The socket is binding", socket);
1676 return SOFTBUS_TRANS_SOCKET_IN_USE;
1677 }
1678 if (bindSuccess) {
1679 UnlockClientSessionServerList();
1680 TRANS_LOGW(TRANS_SDK, "socket=%{public}d The socket was bound successfully", socket);
1681 return SOFTBUS_ALREADY_TRIGGERED;
1682 }
1683 }
1684
1685 sessionNode->lifecycle.maxWaitTime = (action == TIMER_ACTION_START) ? maxWaitTime : 0;
1686 sessionNode->lifecycle.waitTime = 0;
1687 UnlockClientSessionServerList();
1688 return SOFTBUS_OK;
1689 }
1690
ClientSetSocketState(int32_t socket,uint32_t maxIdleTimeout,SessionRole role)1691 int32_t ClientSetSocketState(int32_t socket, uint32_t maxIdleTimeout, SessionRole role)
1692 {
1693 if (socket < 0) {
1694 TRANS_LOGE(TRANS_SDK, "Invalid param");
1695 return SOFTBUS_INVALID_PARAM;
1696 }
1697
1698 int32_t ret = LockClientSessionServerList();
1699 if (ret != SOFTBUS_OK) {
1700 TRANS_LOGE(TRANS_SDK, "lock failed");
1701 return ret;
1702 }
1703
1704 ClientSessionServer *serverNode = NULL;
1705 SessionInfo *sessionNode = NULL;
1706 if (GetSessionById(socket, &serverNode, &sessionNode) != SOFTBUS_OK) {
1707 UnlockClientSessionServerList();
1708 TRANS_LOGE(TRANS_SDK, "socket not found. socketFd=%{public}d", socket);
1709 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1710 }
1711
1712 sessionNode->role = role;
1713 if (sessionNode->role == SESSION_ROLE_CLIENT) {
1714 sessionNode->maxIdleTime = maxIdleTimeout;
1715 }
1716 if (sessionNode->role == SESSION_ROLE_SERVER) {
1717 serverNode->isSrvEncryptedRawStream = sessionNode->isEncyptedRawStream;
1718 }
1719 UnlockClientSessionServerList();
1720 return SOFTBUS_OK;
1721 }
1722
ClientDfsIpcOpenSession(int32_t sessionId,TransInfo * transInfo)1723 int32_t ClientDfsIpcOpenSession(int32_t sessionId, TransInfo *transInfo)
1724 {
1725 if (sessionId < 0 || transInfo == NULL) {
1726 TRANS_LOGE(TRANS_SDK, "Invalid param");
1727 return SOFTBUS_INVALID_PARAM;
1728 }
1729
1730 int32_t ret = LockClientSessionServerList();
1731 if (ret != SOFTBUS_OK) {
1732 TRANS_LOGE(TRANS_SDK, "lock failed");
1733 return ret;
1734 }
1735
1736 ClientSessionServer *serverNode = NULL;
1737 SessionInfo *sessionNode = NULL;
1738 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
1739 UnlockClientSessionServerList();
1740 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
1741 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1742 }
1743 ret = CheckBindSocketInfo(sessionNode);
1744 if (ret != SOFTBUS_OK) {
1745 UnlockClientSessionServerList();
1746 TRANS_LOGE(TRANS_SDK, "check socekt info failed, ret=%{public}d", ret);
1747 return ret;
1748 }
1749
1750 SessionAttribute tmpAttr;
1751 (void)memset_s(&tmpAttr, sizeof(SessionAttribute), 0, sizeof(SessionAttribute));
1752 SessionParam param;
1753 FillDfsSocketParam(¶m, &tmpAttr, serverNode, sessionNode);
1754 UnlockClientSessionServerList();
1755
1756 param.sessionId = sessionId;
1757 ret = SetSessionStateBySessionId(param.sessionId, SESSION_STATE_OPENING, 0);
1758 TRANS_CHECK_AND_RETURN_RET_LOGE(
1759 ret == SOFTBUS_OK, ret, TRANS_SDK, "set session state failed, maybe cancel, ret=%{public}d", ret);
1760 ret = ServerIpcOpenSession(¶m, transInfo);
1761 if (ret != SOFTBUS_OK) {
1762 ClientConvertRetVal(sessionId, &ret);
1763 TRANS_LOGE(TRANS_SDK, "open session ipc err: ret=%{public}d", ret);
1764 return ret;
1765 }
1766 return SOFTBUS_OK;
1767 }
1768
ClientGetSessionCallbackAdapterByName(const char * sessionName,SessionListenerAdapter * callbackAdapter)1769 int32_t ClientGetSessionCallbackAdapterByName(const char *sessionName, SessionListenerAdapter *callbackAdapter)
1770 {
1771 if (sessionName == NULL || callbackAdapter == NULL) {
1772 TRANS_LOGE(TRANS_SDK, "Invalid param");
1773 return SOFTBUS_INVALID_PARAM;
1774 }
1775
1776 int32_t ret = LockClientSessionServerList();
1777 if (ret != SOFTBUS_OK) {
1778 TRANS_LOGE(TRANS_SDK, "lock failed");
1779 return ret;
1780 }
1781
1782 ClientSessionServer *serverNode = NULL;
1783
1784 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1785 if (strcmp(serverNode->sessionName, sessionName) != 0) {
1786 continue;
1787 }
1788
1789 ret = memcpy_s(callbackAdapter, sizeof(SessionListenerAdapter),
1790 &serverNode->listener, sizeof(SessionListenerAdapter));
1791 UnlockClientSessionServerList();
1792 if (ret != EOK) {
1793 char *tmpName = NULL;
1794 Anonymize(sessionName, &tmpName);
1795 TRANS_LOGE(TRANS_SDK,
1796 "memcpy SessionListenerAdapter failed, sessionName=%{public}s, ret=%{public}d",
1797 AnonymizeWrapper(tmpName), ret);
1798 AnonymizeFree(tmpName);
1799 return SOFTBUS_MEM_ERR;
1800 }
1801 return SOFTBUS_OK;
1802 }
1803
1804 UnlockClientSessionServerList();
1805 char *tmpName = NULL;
1806 Anonymize(sessionName, &tmpName);
1807 TRANS_LOGE(TRANS_SDK, "SessionCallbackAdapter not found, sessionName=%{public}s", AnonymizeWrapper(tmpName));
1808 AnonymizeFree(tmpName);
1809 return SOFTBUS_NOT_FIND;
1810 }
1811
ClientGetSessionCallbackAdapterById(int32_t sessionId,SessionListenerAdapter * callbackAdapter,bool * isServer)1812 int32_t ClientGetSessionCallbackAdapterById(int32_t sessionId, SessionListenerAdapter *callbackAdapter, bool *isServer)
1813 {
1814 if (sessionId < 0 || callbackAdapter == NULL) {
1815 TRANS_LOGE(TRANS_SDK, "Invalid param");
1816 return SOFTBUS_INVALID_PARAM;
1817 }
1818
1819 int32_t ret = LockClientSessionServerList();
1820 if (ret != SOFTBUS_OK) {
1821 TRANS_LOGE(TRANS_SDK, "lock failed");
1822 return ret;
1823 }
1824
1825 ClientSessionServer *serverNode = NULL;
1826 SessionInfo *sessionNode = NULL;
1827 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
1828 UnlockClientSessionServerList();
1829 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
1830 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1831 }
1832
1833 ret = memcpy_s(callbackAdapter, sizeof(SessionListenerAdapter), &serverNode->listener,
1834 sizeof(SessionListenerAdapter));
1835 *isServer = sessionNode->isServer;
1836 UnlockClientSessionServerList();
1837 if (ret != EOK) {
1838 TRANS_LOGE(TRANS_SDK,
1839 "memcpy SessionListenerAdapter failed, socket=%{public}d, ret=%{public}d", sessionId, ret);
1840 return SOFTBUS_MEM_ERR;
1841 }
1842 return SOFTBUS_OK;
1843 }
1844
ClientGetPeerSocketInfoById(int32_t socket,PeerSocketInfo * peerSocketInfo)1845 int32_t ClientGetPeerSocketInfoById(int32_t socket, PeerSocketInfo *peerSocketInfo)
1846 {
1847 if (socket < 0 || peerSocketInfo == NULL) {
1848 TRANS_LOGE(TRANS_SDK, "Invalid param");
1849 return SOFTBUS_INVALID_PARAM;
1850 }
1851
1852 int32_t ret = LockClientSessionServerList();
1853 if (ret != SOFTBUS_OK) {
1854 TRANS_LOGE(TRANS_SDK, "lock failed");
1855 return ret;
1856 }
1857
1858 ClientSessionServer *serverNode = NULL;
1859 SessionInfo *sessionNode = NULL;
1860 if (GetSessionById(socket, &serverNode, &sessionNode) != SOFTBUS_OK) {
1861 UnlockClientSessionServerList();
1862 TRANS_LOGE(TRANS_SDK, "socket not found. socketFd=%{public}d", socket);
1863 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1864 }
1865
1866 peerSocketInfo->name = sessionNode->info.peerSessionName;
1867 peerSocketInfo->networkId = sessionNode->info.peerDeviceId;
1868 peerSocketInfo->pkgName = serverNode->pkgName;
1869 peerSocketInfo->dataType = (TransDataType)sessionNode->info.flag;
1870 UnlockClientSessionServerList();
1871 return SOFTBUS_OK;
1872 }
1873
IsSessionExceedLimit(void)1874 bool IsSessionExceedLimit(void)
1875 {
1876 if (LockClientSessionServerList() != SOFTBUS_OK) {
1877 TRANS_LOGE(TRANS_SDK, "lock failed");
1878 return true;
1879 }
1880 if (g_sessionIdNum >= MAX_SESSION_ID) {
1881 UnlockClientSessionServerList();
1882 TRANS_LOGE(TRANS_SDK, "sessionId num exceed limit.");
1883 return true;
1884 }
1885 UnlockClientSessionServerList();
1886 return false;
1887 }
1888
ClientTransSessionTimerProc(void)1889 static void ClientTransSessionTimerProc(void)
1890 {
1891 if (LockClientSessionServerList() != SOFTBUS_OK) {
1892 TRANS_LOGE(TRANS_SDK, "lock failed");
1893 return;
1894 }
1895
1896 ClientSessionServer *serverNode = NULL;
1897 SessionInfo *sessionNode = NULL;
1898 SessionInfo *nextSessionNode = NULL;
1899 ListNode destroyList;
1900 ListInit(&destroyList);
1901 int32_t waitOutSocket[MAX_SESSION_ID] = { 0 };
1902 uint32_t waitOutNum = 0;
1903 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1904 if (IsListEmpty(&serverNode->sessionList)) {
1905 continue;
1906 }
1907 LIST_FOR_EACH_ENTRY_SAFE(sessionNode, nextSessionNode, &(serverNode->sessionList), SessionInfo, node) {
1908 ClientUpdateIdleTimeout(serverNode, sessionNode, &destroyList);
1909 ClientCheckWaitTimeOut(serverNode, sessionNode, waitOutSocket, MAX_SESSION_ID, &waitOutNum);
1910 }
1911 }
1912 UnlockClientSessionServerList();
1913 (void)ClientCleanUpIdleTimeoutSocket(&destroyList);
1914 (void)ClientCleanUpWaitTimeoutSocket(waitOutSocket, waitOutNum);
1915 }
1916
ClientResetIdleTimeoutById(int32_t sessionId)1917 int32_t ClientResetIdleTimeoutById(int32_t sessionId)
1918 {
1919 if (sessionId <= 0) {
1920 TRANS_LOGE(TRANS_SDK, "invalid sessionId");
1921 return SOFTBUS_TRANS_INVALID_SESSION_ID;
1922 }
1923
1924 int32_t ret = LockClientSessionServerList();
1925 if (ret != SOFTBUS_OK) {
1926 TRANS_LOGE(TRANS_SDK, "lock failed");
1927 return ret;
1928 }
1929
1930 ClientSessionServer *serverNode = NULL;
1931 SessionInfo *sessionNode = NULL;
1932 SessionInfo *nextSessionNode = NULL;
1933 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1934 if (IsListEmpty(&serverNode->sessionList)) {
1935 continue;
1936 }
1937 LIST_FOR_EACH_ENTRY_SAFE(sessionNode, nextSessionNode, &(serverNode->sessionList), SessionInfo, node) {
1938 if (sessionNode->sessionId == sessionId) {
1939 sessionNode->timeout = 0;
1940 UnlockClientSessionServerList();
1941 TRANS_LOGD(TRANS_SDK, "reset timeout of sessionId=%{public}d", sessionId);
1942 return SOFTBUS_OK;
1943 }
1944 }
1945 }
1946 UnlockClientSessionServerList();
1947 TRANS_LOGE(TRANS_SDK, "not found session by sessionId=%{public}d", sessionId);
1948 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1949 }
1950
ClientGetSessionNameByChannelId(int32_t channelId,int32_t channelType,char * sessionName,int32_t len)1951 int32_t ClientGetSessionNameByChannelId(int32_t channelId, int32_t channelType, char *sessionName, int32_t len)
1952 {
1953 if (channelId < 0 || sessionName == NULL || len <= 0 || len > SESSION_NAME_SIZE_MAX) {
1954 TRANS_LOGW(TRANS_SDK, "Invalid param");
1955 return SOFTBUS_INVALID_PARAM;
1956 }
1957
1958 int32_t ret = LockClientSessionServerList();
1959 if (ret != SOFTBUS_OK) {
1960 TRANS_LOGE(TRANS_SDK, "lock failed");
1961 return ret;
1962 }
1963
1964 ClientSessionServer *serverNode = NULL;
1965 SessionInfo *sessionNode = NULL;
1966
1967 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1968 if (IsListEmpty(&serverNode->sessionList)) {
1969 continue;
1970 }
1971
1972 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
1973 if (sessionNode->channelId == channelId && sessionNode->channelType == (ChannelType)channelType) {
1974 (void)memcpy_s(sessionName, len, serverNode->sessionName, len);
1975 UnlockClientSessionServerList();
1976 return SOFTBUS_OK;
1977 }
1978 }
1979 }
1980
1981 UnlockClientSessionServerList();
1982 TRANS_LOGE(TRANS_SDK, "not found session with channelId=%{public}d", channelId);
1983 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
1984 }
1985
ClientRawStreamEncryptDefOptGet(const char * sessionName,bool * isEncrypt)1986 int32_t ClientRawStreamEncryptDefOptGet(const char *sessionName, bool *isEncrypt)
1987 {
1988 if (sessionName == NULL || isEncrypt == NULL) {
1989 TRANS_LOGE(TRANS_SDK, "Invalid param");
1990 return SOFTBUS_INVALID_PARAM;
1991 }
1992
1993 int32_t ret = LockClientSessionServerList();
1994 if (ret != SOFTBUS_OK) {
1995 TRANS_LOGE(TRANS_SDK, "lock failed");
1996 return ret;
1997 }
1998
1999 ClientSessionServer *serverNode = NULL;
2000 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
2001 if (strcmp(serverNode->sessionName, sessionName) == 0) {
2002 *isEncrypt = serverNode->isSrvEncryptedRawStream;
2003 UnlockClientSessionServerList();
2004 return SOFTBUS_OK;
2005 }
2006 }
2007 UnlockClientSessionServerList();
2008 char *tmpName = NULL;
2009 Anonymize(sessionName, &tmpName);
2010 TRANS_LOGE(TRANS_SDK, "not found ClientSessionServer by sessionName=%{public}s", tmpName);
2011 AnonymizeFree(tmpName);
2012 return SOFTBUS_TRANS_SESSION_SERVER_NOT_FOUND;
2013 }
2014
ClientRawStreamEncryptOptGet(int32_t channelId,int32_t channelType,bool * isEncrypt)2015 int32_t ClientRawStreamEncryptOptGet(int32_t channelId, int32_t channelType, bool *isEncrypt)
2016 {
2017 if (channelId < 0 || isEncrypt == NULL) {
2018 TRANS_LOGE(TRANS_SDK, "Invalid param");
2019 return SOFTBUS_INVALID_PARAM;
2020 }
2021
2022 int32_t ret = LockClientSessionServerList();
2023 if (ret != SOFTBUS_OK) {
2024 TRANS_LOGE(TRANS_SDK, "lock failed");
2025 return ret;
2026 }
2027
2028 ClientSessionServer *serverNode = NULL;
2029 SessionInfo *sessionNode = NULL;
2030 SessionInfo *nextSessionNode = NULL;
2031 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
2032 if (IsListEmpty(&serverNode->sessionList)) {
2033 continue;
2034 }
2035 LIST_FOR_EACH_ENTRY_SAFE(sessionNode, nextSessionNode, &(serverNode->sessionList), SessionInfo, node) {
2036 if (sessionNode->channelId == channelId && sessionNode->channelType == (ChannelType)channelType) {
2037 *isEncrypt = sessionNode->isEncyptedRawStream;
2038 UnlockClientSessionServerList();
2039 return SOFTBUS_OK;
2040 }
2041 }
2042 }
2043 UnlockClientSessionServerList();
2044 TRANS_LOGE(TRANS_SDK, "not found session by channelId=%{public}d", channelId);
2045 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2046 }
2047
SetSessionIsAsyncById(int32_t sessionId,bool isAsync)2048 int32_t SetSessionIsAsyncById(int32_t sessionId, bool isAsync)
2049 {
2050 if (sessionId <= 0) {
2051 TRANS_LOGE(TRANS_SDK, "invalid sessionId");
2052 return SOFTBUS_INVALID_PARAM;
2053 }
2054
2055 int32_t ret = LockClientSessionServerList();
2056 if (ret != SOFTBUS_OK) {
2057 TRANS_LOGE(TRANS_SDK, "lock failed");
2058 return ret;
2059 }
2060
2061 ClientSessionServer *serverNode = NULL;
2062 SessionInfo *sessionNode = NULL;
2063 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
2064 if (IsListEmpty(&serverNode->sessionList)) {
2065 continue;
2066 }
2067 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
2068 if (sessionNode->sessionId == sessionId) {
2069 sessionNode->isAsync = isAsync;
2070 UnlockClientSessionServerList();
2071 return SOFTBUS_OK;
2072 }
2073 }
2074 }
2075 UnlockClientSessionServerList();
2076 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2077 }
2078
SetSessionInitInfoById(int32_t sessionId)2079 int32_t SetSessionInitInfoById(int32_t sessionId)
2080 {
2081 if (sessionId <= 0) {
2082 TRANS_LOGE(TRANS_SDK, "invalid sessionId");
2083 return SOFTBUS_TRANS_INVALID_SESSION_ID;
2084 }
2085
2086 int32_t ret = LockClientSessionServerList();
2087 if (ret != SOFTBUS_OK) {
2088 TRANS_LOGE(TRANS_SDK, "lock failed");
2089 return ret;
2090 }
2091
2092 ClientSessionServer *serverNode = NULL;
2093 SessionInfo *sessionNode = NULL;
2094 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
2095 if (IsListEmpty(&serverNode->sessionList)) {
2096 continue;
2097 }
2098 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
2099 if (sessionNode->sessionId == sessionId) {
2100 sessionNode->enableStatus = ENABLE_STATUS_INIT;
2101 sessionNode->channelId = INVALID_CHANNEL_ID;
2102 sessionNode->channelType = CHANNEL_TYPE_BUTT;
2103 sessionNode->lifecycle.sessionState = SESSION_STATE_INIT;
2104 UnlockClientSessionServerList();
2105 return SOFTBUS_OK;
2106 }
2107 }
2108 }
2109 UnlockClientSessionServerList();
2110 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2111 }
2112
ClientTransSetChannelInfo(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType)2113 int32_t ClientTransSetChannelInfo(const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)
2114 {
2115 if (sessionName == NULL || sessionId <= 0) {
2116 TRANS_LOGE(TRANS_SDK, "invalid session info");
2117 return SOFTBUS_INVALID_PARAM;
2118 }
2119
2120 int32_t ret = LockClientSessionServerList();
2121 if (ret != SOFTBUS_OK) {
2122 TRANS_LOGE(TRANS_SDK, "lock failed");
2123 return ret;
2124 }
2125 ClientSessionServer *serverNode = NULL;
2126 SessionInfo *sessionNode = NULL;
2127 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
2128 UnlockClientSessionServerList();
2129 TRANS_LOGE(TRANS_SDK, "socket not found. socketFd=%{public}d", sessionId);
2130 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2131 }
2132 if (sessionNode->lifecycle.sessionState == SESSION_STATE_CANCELLING) {
2133 TRANS_LOGW(TRANS_SDK, "this socket already in cancelling state. socketFd=%{public}d", sessionId);
2134 UnlockClientSessionServerList();
2135 return sessionNode->lifecycle.bindErrCode;
2136 }
2137 sessionNode->channelId = channelId;
2138 sessionNode->channelType = (ChannelType)channelType;
2139 sessionNode->lifecycle.sessionState = SESSION_STATE_OPENED;
2140 UnlockClientSessionServerList();
2141 return SOFTBUS_OK;
2142 }
2143
GetSocketLifecycleAndSessionNameBySessionId(int32_t sessionId,char * sessionName,SocketLifecycleData * lifecycle)2144 int32_t GetSocketLifecycleAndSessionNameBySessionId(
2145 int32_t sessionId, char *sessionName, SocketLifecycleData *lifecycle)
2146 {
2147 if (sessionId <= 0 || lifecycle == NULL) {
2148 TRANS_LOGE(TRANS_SDK, "invalid param, sessionId =%{public}d", sessionId);
2149 return SOFTBUS_INVALID_PARAM;
2150 }
2151
2152 int32_t ret = LockClientSessionServerList();
2153 if (ret != SOFTBUS_OK) {
2154 TRANS_LOGE(TRANS_SDK, "lock failed");
2155 return ret;
2156 }
2157
2158 ClientSessionServer *serverNode = NULL;
2159 SessionInfo *sessionNode = NULL;
2160 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
2161 UnlockClientSessionServerList();
2162 TRANS_LOGE(TRANS_SDK, "socket not found. socketFd=%{public}d", sessionId);
2163 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2164 }
2165 *lifecycle = sessionNode->lifecycle;
2166 if (sessionName != NULL && strcpy_s(sessionName, SESSION_NAME_SIZE_MAX, serverNode->sessionName) != EOK) {
2167 UnlockClientSessionServerList();
2168 return SOFTBUS_STRCPY_ERR;
2169 }
2170 UnlockClientSessionServerList();
2171 return SOFTBUS_OK;
2172 }
2173
AddSessionStateClosing(void)2174 void AddSessionStateClosing(void)
2175 {
2176 if (LockClientSessionServerList() != SOFTBUS_OK) {
2177 TRANS_LOGE(TRANS_SDK, "lock failed");
2178 return;
2179 }
2180 g_closingIdNum++;
2181 UnlockClientSessionServerList();
2182 }
2183
DelSessionStateClosing(void)2184 void DelSessionStateClosing(void)
2185 {
2186 if (LockClientSessionServerList() != SOFTBUS_OK) {
2187 TRANS_LOGE(TRANS_SDK, "lock failed");
2188 return;
2189 }
2190 if (g_closingIdNum > 0) {
2191 g_closingIdNum--;
2192 }
2193 UnlockClientSessionServerList();
2194 }
2195
SetSessionStateBySessionId(int32_t sessionId,SessionState sessionState,int32_t optional)2196 int32_t SetSessionStateBySessionId(int32_t sessionId, SessionState sessionState, int32_t optional)
2197 {
2198 if (sessionId <= 0) {
2199 TRANS_LOGE(TRANS_SDK, "invalid sessionId =%{public}d", sessionId);
2200 return SOFTBUS_TRANS_INVALID_SESSION_ID;
2201 }
2202
2203 int32_t ret = LockClientSessionServerList();
2204 if (ret != SOFTBUS_OK) {
2205 TRANS_LOGE(TRANS_SDK, "lock failed");
2206 return ret;
2207 }
2208
2209 ClientSessionServer *serverNode = NULL;
2210 SessionInfo *sessionNode = NULL;
2211 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
2212 UnlockClientSessionServerList();
2213 TRANS_LOGE(TRANS_SDK, "socket not found. socketFd=%{public}d", sessionId);
2214 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2215 }
2216
2217 TRANS_LOGI(TRANS_SDK, "socket state change:%{public}d -> %{public}d. socket=%{public}d",
2218 sessionNode->lifecycle.sessionState, sessionState, sessionId);
2219 sessionNode->lifecycle.sessionState = sessionState;
2220 if (sessionState == SESSION_STATE_CANCELLING) {
2221 TRANS_LOGW(TRANS_SDK, "set socket to cancelling, socket=%{public}d, errCode=%{public}d", sessionId, optional);
2222 sessionNode->lifecycle.bindErrCode = optional;
2223 }
2224 UnlockClientSessionServerList();
2225 return SOFTBUS_OK;
2226 }
2227
CheckSessionEnableStatus(int32_t socket,SoftBusCond * callbackCond)2228 static int32_t CheckSessionEnableStatus(int32_t socket, SoftBusCond *callbackCond)
2229 {
2230 int32_t ret = LockClientSessionServerList();
2231 if (ret != SOFTBUS_OK) {
2232 TRANS_LOGE(TRANS_SDK, "lock failed socket=%{public}d", socket);
2233 return ret;
2234 }
2235
2236 ClientSessionServer *serverNode = NULL;
2237 SessionInfo *sessionNode = NULL;
2238 if (GetSessionById(socket, &serverNode, &sessionNode) != SOFTBUS_OK) {
2239 UnlockClientSessionServerList();
2240 (void)SoftBusCondDestroy(callbackCond);
2241 TRANS_LOGE(TRANS_SDK, "socket=%{public}d not found, destroy condition", socket);
2242 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2243 }
2244 sessionNode->lifecycle.condIsWaiting = false;
2245 ret = sessionNode->lifecycle.bindErrCode;
2246 if (sessionNode->enableStatus != ENABLE_STATUS_SUCCESS) {
2247 UnlockClientSessionServerList();
2248 // enableStatus=false and ret=SOFTBUS_OK, is an unexpected state
2249 if (ret == SOFTBUS_OK) {
2250 TRANS_LOGE(TRANS_SDK, "invalid bindErrCode, socket=%{public}d, ret=%{public}d", socket, ret);
2251 return SOFTBUS_TRANS_SESSION_NO_ENABLE;
2252 }
2253 TRANS_LOGE(TRANS_SDK, "Bind fail, socket=%{public}d, ret=%{public}d", socket, ret);
2254 return ret;
2255 }
2256 UnlockClientSessionServerList();
2257 TRANS_LOGI(TRANS_SDK, "socket=%{public}d is enable, ret=%{public}d", socket, ret);
2258 return ret;
2259 }
2260
ClientWaitSyncBind(int32_t socket)2261 int32_t ClientWaitSyncBind(int32_t socket)
2262 {
2263 if (socket <= 0) {
2264 TRANS_LOGE(TRANS_SDK, "invalid param sessionId =%{public}d", socket);
2265 return SOFTBUS_TRANS_INVALID_SESSION_ID;
2266 }
2267
2268 int32_t ret = LockClientSessionServerList();
2269 if (ret != SOFTBUS_OK) {
2270 TRANS_LOGE(TRANS_SDK, "lock failed");
2271 return ret;
2272 }
2273
2274 ClientSessionServer *serverNode = NULL;
2275 SessionInfo *sessionNode = NULL;
2276 if (GetSessionById(socket, &serverNode, &sessionNode) != SOFTBUS_OK) {
2277 UnlockClientSessionServerList();
2278 TRANS_LOGE(TRANS_SDK, "socket not found. socket=%{public}d", socket);
2279 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2280 }
2281
2282 if (sessionNode->lifecycle.sessionState == SESSION_STATE_CANCELLING) {
2283 UnlockClientSessionServerList();
2284 TRANS_LOGW(TRANS_SDK, "session is cancelling socket=%{public}d", socket);
2285 return sessionNode->lifecycle.bindErrCode;
2286 }
2287 SoftBusCond *callbackCond = &(sessionNode->lifecycle.callbackCond);
2288 sessionNode->lifecycle.condIsWaiting = true;
2289 ret = SoftBusCondWait(callbackCond, &(g_clientSessionServerList->lock), NULL);
2290 if (ret != SOFTBUS_OK) {
2291 UnlockClientSessionServerList();
2292 TRANS_LOGE(TRANS_SDK, "cond wait failed, socket=%{public}d", socket);
2293 return ret;
2294 }
2295 UnlockClientSessionServerList();
2296 return CheckSessionEnableStatus(socket, callbackCond);
2297 }
2298
TransWaitForBindReturn(int32_t socket)2299 static void TransWaitForBindReturn(int32_t socket)
2300 {
2301 #define RETRY_GET_BIND_RESULT_TIMES 3
2302 #define RETRY_WAIT_TIME 5000 // 5ms
2303
2304 SocketLifecycleData lifecycle;
2305 (void)memset_s(&lifecycle, sizeof(SocketLifecycleData), 0, sizeof(SocketLifecycleData));
2306 int32_t ret;
2307
2308 for (int32_t retryTimes = 0; retryTimes < RETRY_GET_BIND_RESULT_TIMES; ++retryTimes) {
2309 ret = GetSocketLifecycleAndSessionNameBySessionId(socket, NULL, &lifecycle);
2310 if (ret != SOFTBUS_OK) {
2311 TRANS_LOGE(TRANS_SDK, "Get session lifecycle failed, ret=%{public}d", ret);
2312 return;
2313 }
2314
2315 if (lifecycle.maxWaitTime == 0) {
2316 return;
2317 }
2318 TRANS_LOGW(TRANS_SDK, "wait for bind return, socket=%{public}d, retryTimes=%{public}d", socket, retryTimes);
2319 usleep(RETRY_WAIT_TIME);
2320 }
2321 }
2322
ClientSignalSyncBind(int32_t socket,int32_t errCode)2323 int32_t ClientSignalSyncBind(int32_t socket, int32_t errCode)
2324 {
2325 if (socket <= 0) {
2326 TRANS_LOGE(TRANS_SDK, "invalid param sessionId =%{public}d", socket);
2327 return SOFTBUS_TRANS_INVALID_SESSION_ID;
2328 }
2329
2330 int32_t ret = LockClientSessionServerList();
2331 if (ret != SOFTBUS_OK) {
2332 TRANS_LOGE(TRANS_SDK, "lock failed");
2333 return ret;
2334 }
2335
2336 ClientSessionServer *serverNode = NULL;
2337 SessionInfo *sessionNode = NULL;
2338 if (GetSessionById(socket, &serverNode, &sessionNode) != SOFTBUS_OK) {
2339 UnlockClientSessionServerList();
2340 TRANS_LOGE(TRANS_SDK, "socket not found. socket=%{public}d", socket);
2341 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2342 }
2343
2344 if (sessionNode->isAsync) {
2345 UnlockClientSessionServerList();
2346 TRANS_LOGW(TRANS_SDK, "socket is async, do not need signal. socket=%{public}d", socket);
2347 return SOFTBUS_OK;
2348 }
2349
2350 sessionNode->lifecycle.bindErrCode = errCode;
2351 ret = SoftBusCondSignal(&(sessionNode->lifecycle.callbackCond));
2352 if (ret != SOFTBUS_OK) {
2353 UnlockClientSessionServerList();
2354 TRANS_LOGE(TRANS_SDK, "cond single failed, socket=%{public}d", socket);
2355 return ret;
2356 }
2357
2358 UnlockClientSessionServerList();
2359 TRANS_LOGI(TRANS_SDK, "socket=%{public}d signal success", socket);
2360 TransWaitForBindReturn(socket);
2361 return SOFTBUS_OK;
2362 }
2363
ClientUpdateAuthSessionTimer(SessionInfo * sessionNode,int32_t sessionId)2364 static int32_t ClientUpdateAuthSessionTimer(SessionInfo *sessionNode, int32_t sessionId)
2365 {
2366 // Only need to operate on the action guidance channel
2367 if (sessionNode->actionId == 0) {
2368 return SOFTBUS_OK;
2369 }
2370 if (sessionNode->lifecycle.maxWaitTime == 0) {
2371 TRANS_LOGE(TRANS_SDK, "sessionId=%{public}d is not need update.", sessionId);
2372 return SOFTBUS_NOT_NEED_UPDATE;
2373 }
2374 sessionNode->lifecycle.maxWaitTime = 0;
2375 return SOFTBUS_OK;
2376 }
2377
ClientCancelAuthSessionTimer(int32_t sessionId)2378 int32_t ClientCancelAuthSessionTimer(int32_t sessionId)
2379 {
2380 if (sessionId <= 0) {
2381 TRANS_LOGE(TRANS_SDK, "invalid sessionId");
2382 return SOFTBUS_TRANS_INVALID_SESSION_ID;
2383 }
2384
2385 int32_t ret = LockClientSessionServerList();
2386 if (ret != SOFTBUS_OK) {
2387 TRANS_LOGE(TRANS_SDK, "lock failed");
2388 return ret;
2389 }
2390
2391 ClientSessionServer *serverNode = NULL;
2392 SessionInfo *sessionNode = NULL;
2393 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
2394 if (IsListEmpty(&serverNode->sessionList) || strcmp(serverNode->sessionName, ISHARE_AUTH_SESSION) != 0) {
2395 continue;
2396 }
2397 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
2398 if (sessionNode->sessionId != sessionId ||
2399 (sessionNode->channelType != CHANNEL_TYPE_PROXY && sessionNode->channelType != CHANNEL_TYPE_AUTH)) {
2400 continue;
2401 }
2402 ret = ClientUpdateAuthSessionTimer(sessionNode, sessionId);
2403 UnlockClientSessionServerList();
2404 return ret;
2405 }
2406 }
2407 UnlockClientSessionServerList();
2408 TRANS_LOGE(TRANS_SDK, "not found ishare auth session by sessionId=%{public}d", sessionId);
2409 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2410 }
2411
ClientGetChannelOsTypeBySessionId(int32_t sessionId,int32_t * osType)2412 int32_t ClientGetChannelOsTypeBySessionId(int32_t sessionId, int32_t *osType)
2413 {
2414 if ((sessionId < 0) || (osType == NULL)) {
2415 return SOFTBUS_INVALID_PARAM;
2416 }
2417 int32_t ret = LockClientSessionServerList();
2418 if (ret != SOFTBUS_OK) {
2419 TRANS_LOGE(TRANS_SDK, "lock failed");
2420 return ret;
2421 }
2422
2423 ClientSessionServer *serverNode = NULL;
2424 SessionInfo *sessionNode = NULL;
2425 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
2426 UnlockClientSessionServerList();
2427 TRANS_LOGE(TRANS_SDK, "session not found. sessionId=%{public}d", sessionId);
2428 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
2429 }
2430
2431 *osType = sessionNode->osType;
2432
2433 UnlockClientSessionServerList();
2434 return SOFTBUS_OK;
2435 }