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