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