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