1 /*
2 * Copyright (c) 2021 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 "client_bus_center_manager.h"
21 #include "client_trans_channel_manager.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_app_info.h"
24 #include "softbus_def.h"
25 #include "softbus_errcode.h"
26 #include "softbus_log.h"
27 #include "softbus_utils.h"
28 #include "trans_server_proxy.h"
29
30 static int32_t g_sessionIdNum = 0;
31 static int32_t g_sessionId = 1;
32 static SoftBusList *g_clientSessionServerList = NULL;
33
34 typedef struct {
35 ListNode node;
36 int32_t sessionId;
37 int32_t channelId;
38 ChannelType channelType;
39 void (*OnSessionClosed)(int sessionId);
40 } DestroySessionInfo;
41
CheckPermissionState(int32_t sessionId)42 int32_t CheckPermissionState(int32_t sessionId)
43 {
44 if (g_clientSessionServerList == NULL) {
45 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
46 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
47 }
48 ClientSessionServer *serverNode = NULL;
49 SessionInfo *sessionNode = NULL;
50 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
51 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
52 return SOFTBUS_LOCK_ERR;
53 }
54 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
55 if (IsListEmpty(&serverNode->sessionList)) {
56 continue;
57 }
58 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
59 if (sessionNode->sessionId == sessionId) {
60 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
61 return serverNode->permissionState ? SOFTBUS_OK : SOFTBUS_PERMISSION_DENIED;
62 }
63 }
64 }
65 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
66 return SOFTBUS_TRANS_INVALID_SESSION_ID;
67 }
68
PermissionStateChange(const char * pkgName,int32_t state)69 void PermissionStateChange(const char *pkgName, int32_t state)
70 {
71 if (g_clientSessionServerList == NULL) {
72 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
73 return;
74 }
75 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
76 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
77 return;
78 }
79 ClientSessionServer *serverNode = NULL;
80 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
81 if ((strcmp(serverNode->pkgName, pkgName) == 0)) {
82 serverNode->permissionState = state > 0 ? true : false;
83 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "%s permission change, state = %d", pkgName, state);
84 break;
85 }
86 }
87 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
88 }
89
TransClientInit(void)90 int TransClientInit(void)
91 {
92 g_clientSessionServerList = CreateSoftBusList();
93 if (g_clientSessionServerList == NULL) {
94 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "init list failed");
95 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
96 }
97
98 if (TransServerProxyInit() != SOFTBUS_OK) {
99 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "init trans ipc proxy failed");
100 return SOFTBUS_ERR;
101 }
102
103 if (ClientTransChannelInit() != SOFTBUS_OK) {
104 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "init trans channel failed");
105 return SOFTBUS_ERR;
106 }
107
108 ClientTransRegLnnOffline();
109 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "init trans client success");
110 return SOFTBUS_OK;
111 }
112
SessionIdIsAvailable(int32_t sessionId)113 static bool SessionIdIsAvailable(int32_t sessionId)
114 {
115 ClientSessionServer *serverNode = NULL;
116 SessionInfo *sessionNode = NULL;
117
118 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
119 if (IsListEmpty(&serverNode->sessionList)) {
120 continue;
121 }
122 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
123 if (sessionNode->sessionId == sessionId) {
124 return false;
125 }
126 }
127 }
128
129 return true;
130 }
131
GenerateSessionId(void)132 static int32_t GenerateSessionId(void)
133 {
134 if (g_sessionIdNum >= MAX_SESSION_ID) {
135 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "sessionid num cross the line error");
136 return INVALID_SESSION_ID;
137 }
138 int32_t cnt = MAX_SESSION_ID + 1;
139 int32_t id = INVALID_SESSION_ID;
140
141 while (cnt) {
142 id = g_sessionId++;
143 if (g_sessionId < 0) {
144 g_sessionId = 1;
145 }
146 if (SessionIdIsAvailable(id)) {
147 g_sessionIdNum++;
148 return id;
149 }
150 cnt--;
151 }
152 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "generate id error");
153 return id;
154 }
155
DestroySessionId(void)156 static void DestroySessionId(void)
157 {
158 if (g_sessionIdNum > 0) {
159 g_sessionIdNum--;
160 }
161 return;
162 }
163
CreateDestroySessionNode(SessionInfo * sessionNode,const ClientSessionServer * server)164 static DestroySessionInfo *CreateDestroySessionNode(SessionInfo *sessionNode, const ClientSessionServer *server)
165 {
166 DestroySessionInfo *destroyNode = (DestroySessionInfo *)SoftBusMalloc(sizeof(DestroySessionInfo));
167 if (destroyNode == NULL) {
168 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "destroyList malloc fail.");
169 return NULL;
170 }
171 destroyNode->sessionId = sessionNode->sessionId;
172 destroyNode->channelId = sessionNode->channelId;
173 destroyNode->channelType = sessionNode->channelType;
174 destroyNode->OnSessionClosed = server->listener.session.OnSessionClosed;
175 return destroyNode;
176 }
177
ClientDestroySession(const ListNode * destroyList)178 NO_SANITIZE("cfi") static void ClientDestroySession(const ListNode *destroyList)
179 {
180 if (IsListEmpty(destroyList)) {
181 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "destroyList is empty fail.");
182 return;
183 }
184 DestroySessionInfo *destroyNode = NULL;
185 DestroySessionInfo *destroyNodeNext = NULL;
186 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "DestroyClientSession start");
187 LIST_FOR_EACH_ENTRY_SAFE(destroyNode, destroyNodeNext, destroyList, DestroySessionInfo, node) {
188 int32_t id = destroyNode->sessionId;
189 (void)ClientTransCloseChannel(destroyNode->channelId, destroyNode->channelType);
190 if (destroyNode->OnSessionClosed != NULL) {
191 destroyNode->OnSessionClosed(id);
192 }
193 ListDelete(&(destroyNode->node));
194 SoftBusFree(destroyNode);
195 }
196 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "DestroyClientSession end");
197 }
198
DestroyClientSessionServer(ClientSessionServer * server,ListNode * destroyList)199 static void DestroyClientSessionServer(ClientSessionServer *server, ListNode *destroyList)
200 {
201 if (server == NULL) {
202 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid param");
203 return;
204 }
205
206 if (!IsListEmpty(&(server->sessionList))) {
207 SessionInfo *sessionNode = NULL;
208 SessionInfo *sessionNodeNext = NULL;
209 LIST_FOR_EACH_ENTRY_SAFE(sessionNode, sessionNodeNext, &(server->sessionList), SessionInfo, node) {
210 DestroySessionInfo *destroyNode = CreateDestroySessionNode(sessionNode, server);
211 if (destroyNode == NULL) {
212 continue;
213 }
214 DestroySessionId();
215 ListDelete(&sessionNode->node);
216 ListAdd(destroyList, &(destroyNode->node));
217 SoftBusFree(sessionNode);
218 }
219 }
220
221 ListDelete(&(server->node));
222 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "destroy session server [%s]", server->sessionName);
223 SoftBusFree(server);
224 }
225
TransClientDeinit(void)226 void TransClientDeinit(void)
227 {
228 if (g_clientSessionServerList == NULL) {
229 return;
230 }
231 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
232 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
233 return;
234 }
235 ClientSessionServer *serverNode = NULL;
236 ClientSessionServer *serverNodeNext = NULL;
237 ListNode destroyList;
238 ListInit(&destroyList);
239 LIST_FOR_EACH_ENTRY_SAFE(serverNode, serverNodeNext, &(g_clientSessionServerList->list),
240 ClientSessionServer, node) {
241 DestroyClientSessionServer(serverNode, &destroyList);
242 }
243 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
244 ClientDestroySession(&destroyList);
245
246 DestroySoftBusList(g_clientSessionServerList);
247 g_clientSessionServerList = NULL;
248 ClientTransChannelDeinit();
249 TransServerProxyDeInit();
250 }
251
SessionServerIsExist(const char * sessionName)252 static bool SessionServerIsExist(const char *sessionName)
253 {
254 /* need get lock before */
255 ListNode *pos = NULL;
256 ListNode *tmp = NULL;
257 ClientSessionServer *node = NULL;
258 LIST_FOR_EACH_SAFE(pos, tmp, &g_clientSessionServerList->list) {
259 node = (ClientSessionServer *)pos;
260 if (strcmp(node->sessionName, sessionName) == 0) {
261 return true;
262 }
263 }
264 return false;
265 }
266
GetNewSessionServer(SoftBusSecType type,const char * sessionName,const char * pkgName,const ISessionListener * listener)267 static ClientSessionServer *GetNewSessionServer(SoftBusSecType type, const char *sessionName,
268 const char *pkgName, const ISessionListener *listener)
269 {
270 ClientSessionServer *server = (ClientSessionServer *)SoftBusCalloc(sizeof(ClientSessionServer));
271 if (server == NULL) {
272 return NULL;
273 }
274 server->type = type;
275 if (strcpy_s(server->pkgName, sizeof(server->pkgName), pkgName) != EOK) {
276 goto EXIT_ERR;
277 }
278 if (strcpy_s(server->sessionName, sizeof(server->sessionName), sessionName) != EOK) {
279 goto EXIT_ERR;
280 }
281 if (memcpy_s(&server->listener.session, sizeof(ISessionListener), listener, sizeof(ISessionListener)) != EOK) {
282 goto EXIT_ERR;
283 }
284
285 ListInit(&server->node);
286 ListInit(&server->sessionList);
287 return server;
288 EXIT_ERR:
289 if (server != NULL) {
290 SoftBusFree(server);
291 }
292 return NULL;
293 }
294
ClientAddSessionServer(SoftBusSecType type,const char * pkgName,const char * sessionName,const ISessionListener * listener)295 int32_t ClientAddSessionServer(SoftBusSecType type, const char *pkgName, const char *sessionName,
296 const ISessionListener *listener)
297 {
298 if (pkgName == NULL || sessionName == NULL || listener == NULL) {
299 return SOFTBUS_INVALID_PARAM;
300 }
301
302 if (g_clientSessionServerList == NULL) {
303 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
304 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
305 }
306 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
307 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
308 return SOFTBUS_LOCK_ERR;
309 }
310 if (SessionServerIsExist(sessionName)) {
311 (void)SoftBusMutexUnlock(&g_clientSessionServerList->lock);
312 return SOFTBUS_SERVER_NAME_REPEATED;
313 }
314
315 if (g_clientSessionServerList->cnt >= MAX_SESSION_SERVER_NUMBER) {
316 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
317 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "server num reach max");
318 return SOFTBUS_INVALID_NUM;
319 }
320
321 ClientSessionServer *server = GetNewSessionServer(type, sessionName, pkgName, listener);
322 if (server == NULL) {
323 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
324 return SOFTBUS_MEM_ERR;
325 }
326 server->permissionState = true;
327 ListAdd(&g_clientSessionServerList->list, &server->node);
328 g_clientSessionServerList->cnt++;
329
330 (void)SoftBusMutexUnlock(&g_clientSessionServerList->lock);
331 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "session name [%s], pkg name [%s]",
332 server->sessionName, server->pkgName);
333 return SOFTBUS_OK;
334 }
335
IsValidSessionParam(const SessionParam * param)336 static bool IsValidSessionParam(const SessionParam *param)
337 {
338 if ((param == NULL) ||
339 (param->sessionName == NULL) ||
340 (param->peerSessionName == NULL) ||
341 (param->peerDeviceId == NULL) ||
342 (param->groupId == NULL) ||
343 (param->attr == NULL)) {
344 return false;
345 }
346 return true;
347 }
348
CreateNewSession(const SessionParam * param)349 static SessionInfo *CreateNewSession(const SessionParam *param)
350 {
351 SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
352 if (session == NULL) {
353 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "calloc failed");
354 return NULL;
355 }
356
357 if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
358 strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
359 strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK ||
360 memcpy_s(session->linkType, sizeof(param->attr->linkType), param->attr->linkType,
361 sizeof(param->attr->linkType)) != EOK) {
362 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "strcpy failed");
363 SoftBusFree(session);
364 return NULL;
365 }
366
367 session->sessionId = INVALID_SESSION_ID;
368 session->channelId = INVALID_CHANNEL_ID;
369 session->channelType = CHANNEL_TYPE_BUTT;
370 session->isServer = false;
371 session->isEnable = false;
372 session->info.flag = param->attr->dataType;
373 session->isEncrypt = true;
374
375 return session;
376 }
377
GetExistSession(const SessionParam * param)378 static SessionInfo *GetExistSession(const SessionParam *param)
379 {
380 /* need get lock before */
381 ClientSessionServer *serverNode = NULL;
382 SessionInfo *sessionNode = NULL;
383 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
384 if ((strcmp(serverNode->sessionName, param->sessionName) != 0) || IsListEmpty(&serverNode->sessionList)) {
385 continue;
386 }
387 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
388 if (sessionNode->isServer ||
389 (strcmp(sessionNode->info.peerSessionName, param->peerSessionName) != 0) ||
390 (strcmp(sessionNode->info.peerDeviceId, param->peerDeviceId) != 0) ||
391 (strcmp(sessionNode->info.groupId, param->groupId) != 0) ||
392 (memcmp(sessionNode->linkType, param->attr->linkType, sizeof(param->attr->linkType)) != 0) ||
393 (sessionNode->info.flag != param->attr->dataType)) {
394 continue;
395 }
396 return sessionNode;
397 }
398 }
399 return NULL;
400 }
401
GetSessionById(int32_t sessionId,ClientSessionServer ** server,SessionInfo ** session)402 static int32_t GetSessionById(int32_t sessionId, ClientSessionServer **server, SessionInfo **session)
403 {
404 /* need get lock before */
405 ClientSessionServer *serverNode = NULL;
406 SessionInfo *sessionNode = NULL;
407
408 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
409 if (IsListEmpty(&serverNode->sessionList)) {
410 continue;
411 }
412 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
413 if (sessionNode->sessionId == sessionId) {
414 *server = serverNode;
415 *session = sessionNode;
416 return SOFTBUS_OK;
417 }
418 }
419 }
420 return SOFTBUS_ERR;
421 }
422
AddSession(const char * sessionName,SessionInfo * session)423 static int32_t AddSession(const char *sessionName, SessionInfo *session)
424 {
425 /* need get lock before */
426 session->sessionId = GenerateSessionId();
427 if (session->sessionId < 0) {
428 return SOFTBUS_TRANS_SESSION_CNT_EXCEEDS_LIMIT;
429 }
430 ClientSessionServer *serverNode = NULL;
431 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
432 if (strcmp(serverNode->sessionName, sessionName) != 0) {
433 continue;
434 }
435 ListAdd(&serverNode->sessionList, &session->node);
436 return SOFTBUS_OK;
437 }
438 DestroySessionId();
439 return SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED;
440 }
441
ClientAddNewSession(const char * sessionName,SessionInfo * session)442 int32_t ClientAddNewSession(const char *sessionName, SessionInfo *session)
443 {
444 if (session == NULL) {
445 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
446 return SOFTBUS_INVALID_PARAM;
447 }
448
449 if (g_clientSessionServerList == NULL) {
450 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
451 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
452 }
453
454 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
455 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
456 return SOFTBUS_LOCK_ERR;
457 }
458
459 int32_t ret = AddSession(sessionName, session);
460 if (ret != SOFTBUS_OK) {
461 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
462 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "add session failed, ret [%d]", ret);
463 return ret;
464 }
465 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
466 return SOFTBUS_OK;
467 }
468
ClientAddSession(const SessionParam * param,int32_t * sessionId,bool * isEnabled)469 int32_t ClientAddSession(const SessionParam *param, int32_t *sessionId, bool *isEnabled)
470 {
471 if (!IsValidSessionParam(param) || (sessionId == NULL) || (isEnabled == NULL)) {
472 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
473 return SOFTBUS_INVALID_PARAM;
474 }
475
476 if (g_clientSessionServerList == NULL) {
477 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
478 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
479 }
480
481 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
482 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
483 return SOFTBUS_LOCK_ERR;
484 }
485
486 SessionInfo *session = GetExistSession(param);
487 if (session != NULL) {
488 *sessionId = session->sessionId;
489 *isEnabled = session->isEnable;
490 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
491 return SOFTBUS_TRANS_SESSION_REPEATED;
492 }
493
494 session = CreateNewSession(param);
495 if (session == NULL) {
496 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
497 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "create session failed");
498 return SOFTBUS_TRANS_SESSION_CREATE_FAILED;
499 }
500
501 int32_t ret = AddSession(param->sessionName, session);
502 if (ret != SOFTBUS_OK) {
503 SoftBusFree(session);
504 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
505 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Add Session failed, ret [%d]", ret);
506 return ret;
507 }
508
509 *sessionId = session->sessionId;
510 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
511 return SOFTBUS_OK;
512 }
513
CreateNonEncryptSessionInfo(const char * sessionName)514 static SessionInfo *CreateNonEncryptSessionInfo(const char *sessionName)
515 {
516 if (!IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
517 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
518 return NULL;
519 }
520 SessionInfo *session = (SessionInfo *)SoftBusCalloc(sizeof(SessionInfo));
521 if (session == NULL) {
522 return NULL;
523 }
524 session->channelType = CHANNEL_TYPE_AUTH;
525 session->isEncrypt = false;
526 if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK) {
527 SoftBusFree(session);
528 return NULL;
529 }
530 return session;
531 }
532
ClientAddAuthSession(const char * sessionName,int32_t * sessionId)533 int32_t ClientAddAuthSession(const char *sessionName, int32_t *sessionId)
534 {
535 if (!IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1) || (sessionId == NULL)) {
536 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
537 return SOFTBUS_INVALID_PARAM;
538 }
539 if (g_clientSessionServerList == NULL) {
540 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
541 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
542 }
543 SessionInfo *session = CreateNonEncryptSessionInfo(sessionName);
544 if (session == NULL) {
545 return SOFTBUS_MALLOC_ERR;
546 }
547 int32_t ret = ClientAddNewSession(sessionName, session);
548 if (ret != SOFTBUS_OK) {
549 SoftBusFree(session);
550 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "client add new session failed, ret=%d.", ret);
551 return ret;
552 }
553 *sessionId = session->sessionId;
554 return SOFTBUS_OK;
555 }
556
ClientDeleteSessionServer(SoftBusSecType type,const char * sessionName)557 int32_t ClientDeleteSessionServer(SoftBusSecType type, const char *sessionName)
558 {
559 if ((type == SEC_TYPE_UNKNOWN) || (sessionName == NULL)) {
560 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
561 return SOFTBUS_INVALID_PARAM;
562 }
563
564 if (g_clientSessionServerList == NULL) {
565 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
566 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
567 }
568
569 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
570 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
571 return SOFTBUS_LOCK_ERR;
572 }
573
574 ClientSessionServer *serverNode = NULL;
575 ListNode destroyList;
576 ListInit(&destroyList);
577 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
578 if ((strcmp(serverNode->sessionName, sessionName) == 0) && (serverNode->type == type)) {
579 DestroyClientSessionServer(serverNode, &destroyList);
580 g_clientSessionServerList->cnt--;
581 break;
582 }
583 }
584 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
585 (void)ClientDestroySession(&destroyList);
586 return SOFTBUS_OK;
587 }
588
ClientDeleteSession(int32_t sessionId)589 int32_t ClientDeleteSession(int32_t sessionId)
590 {
591 if (sessionId < 0) {
592 return SOFTBUS_ERR;
593 }
594
595 if (g_clientSessionServerList == NULL) {
596 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
597 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
598 }
599
600 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
601 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
602 return SOFTBUS_LOCK_ERR;
603 }
604
605 ClientSessionServer *serverNode = NULL;
606 SessionInfo *sessionNode = NULL;
607
608 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
609 if (IsListEmpty(&serverNode->sessionList)) {
610 continue;
611 }
612 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
613 if (sessionNode->sessionId != sessionId) {
614 continue;
615 }
616 ListDelete(&(sessionNode->node));
617 DestroySessionId();
618 SoftBusFree(sessionNode);
619 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
620 return SOFTBUS_OK;
621 }
622 }
623
624 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
625 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s:not found", __func__);
626 return SOFTBUS_ERR;
627 }
628
ClientGetSessionDataById(int32_t sessionId,char * data,uint16_t len,SessionKey key)629 int32_t ClientGetSessionDataById(int32_t sessionId, char *data, uint16_t len, SessionKey key)
630 {
631 if ((sessionId < 0) || (data == NULL) || (len == 0)) {
632 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
633 return SOFTBUS_INVALID_PARAM;
634 }
635
636 if (g_clientSessionServerList == NULL) {
637 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
638 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
639 }
640
641 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
642 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
643 return SOFTBUS_LOCK_ERR;
644 }
645
646 ClientSessionServer *serverNode = NULL;
647 SessionInfo *sessionNode = NULL;
648 int32_t ret = GetSessionById(sessionId, &serverNode, &sessionNode);
649 if (ret != SOFTBUS_OK) {
650 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
651 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s: sid[%d] not found", __func__, sessionId);
652 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
653 }
654
655 switch (key) {
656 case KEY_SESSION_NAME:
657 ret = strcpy_s(data, len, serverNode->sessionName);
658 break;
659 case KEY_PEER_SESSION_NAME:
660 ret = strcpy_s(data, len, sessionNode->info.peerSessionName);
661 break;
662 case KEY_PEER_DEVICE_ID:
663 ret = strcpy_s(data, len, sessionNode->info.peerDeviceId);
664 break;
665 case KEY_PKG_NAME:
666 ret = strcpy_s(data, len, serverNode->pkgName);
667 break;
668 default:
669 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
670 return SOFTBUS_ERR;
671 }
672
673 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
674 if (ret != EOK) {
675 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "copy data failed");
676 return SOFTBUS_ERR;
677 }
678 return SOFTBUS_OK;
679 }
680
ClientGetSessionIntegerDataById(int32_t sessionId,int * data,SessionKey key)681 int32_t ClientGetSessionIntegerDataById(int32_t sessionId, int *data, SessionKey key)
682 {
683 if ((sessionId < 0) || (data == NULL)) {
684 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
685 return SOFTBUS_INVALID_PARAM;
686 }
687
688 if (g_clientSessionServerList == NULL) {
689 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
690 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
691 }
692
693 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
694 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
695 return SOFTBUS_LOCK_ERR;
696 }
697
698 ClientSessionServer *serverNode = NULL;
699 SessionInfo *sessionNode = NULL;
700 int32_t ret = GetSessionById(sessionId, &serverNode, &sessionNode);
701 if (ret != SOFTBUS_OK) {
702 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
703 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s:not found", __func__);
704 return SOFTBUS_ERR;
705 }
706 switch (key) {
707 case KEY_IS_SERVER:
708 *data = sessionNode->isServer;
709 break;
710 case KEY_PEER_PID:
711 *data = sessionNode->peerPid;
712 break;
713 case KEY_PEER_UID:
714 *data = sessionNode->peerUid;
715 break;
716 default:
717 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
718 return SOFTBUS_ERR;
719 }
720
721 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
722 if (ret != EOK) {
723 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "copy data failed");
724 return SOFTBUS_ERR;
725 }
726 return SOFTBUS_OK;
727 }
728
ClientGetChannelBySessionId(int32_t sessionId,int32_t * channelId,int32_t * type,bool * isEnable)729 int32_t ClientGetChannelBySessionId(int32_t sessionId, int32_t *channelId, int32_t *type, bool *isEnable)
730 {
731 if (sessionId < 0) {
732 return SOFTBUS_INVALID_PARAM;
733 }
734 if (g_clientSessionServerList == NULL) {
735 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
736 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
737 }
738 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
739 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
740 return SOFTBUS_LOCK_ERR;
741 }
742
743 ClientSessionServer *serverNode = NULL;
744 SessionInfo *sessionNode = NULL;
745 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
746 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
747 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s:not found", __func__);
748 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
749 }
750
751 if (channelId != NULL) {
752 *channelId = sessionNode->channelId;
753 }
754 if (type != NULL) {
755 *type = sessionNode->channelType;
756 }
757 if (isEnable != NULL) {
758 *isEnable = sessionNode->isEnable;
759 }
760 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
761 return SOFTBUS_OK;
762 }
763
ClientGetChannelBusinessTypeBySessionId(int32_t sessionId,int32_t * businessType)764 int32_t ClientGetChannelBusinessTypeBySessionId(int32_t sessionId, int32_t *businessType)
765 {
766 if ((sessionId < 0) || (businessType == NULL)) {
767 return SOFTBUS_INVALID_PARAM;
768 }
769 if (g_clientSessionServerList == NULL) {
770 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
771 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
772 }
773 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
774 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
775 return SOFTBUS_LOCK_ERR;
776 }
777
778 ClientSessionServer *serverNode = NULL;
779 SessionInfo *sessionNode = NULL;
780 if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) {
781 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
782 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s:not found", __func__);
783 return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
784 }
785
786 *businessType = sessionNode->businessType;
787
788 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
789 return SOFTBUS_OK;
790 }
791
792
ClientSetChannelBySessionId(int32_t sessionId,TransInfo * transInfo)793 int32_t ClientSetChannelBySessionId(int32_t sessionId, TransInfo *transInfo)
794 {
795 if ((sessionId < 0) || (transInfo->channelId < 0)) {
796 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
797 return SOFTBUS_INVALID_PARAM;
798 }
799
800 if (g_clientSessionServerList == NULL) {
801 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
802 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
803 }
804
805 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
806 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
807 return SOFTBUS_LOCK_ERR;
808 }
809
810 ClientSessionServer *serverNode = NULL;
811 SessionInfo *sessionNode = NULL;
812
813 int32_t ret = GetSessionById(sessionId, &serverNode, &sessionNode);
814 if (ret != SOFTBUS_OK) {
815 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
816 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s:not found", __func__);
817 return ret;
818 }
819 sessionNode->channelId = transInfo->channelId;
820 sessionNode->channelType = (ChannelType)transInfo->channelType;
821
822 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
823 return SOFTBUS_OK;
824 }
825
GetEncryptByChannelId(int32_t channelId,int32_t channelType,int32_t * data)826 int32_t GetEncryptByChannelId(int32_t channelId, int32_t channelType, int32_t *data)
827 {
828 if ((channelId < 0) || (data == NULL)) {
829 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
830 return SOFTBUS_INVALID_PARAM;
831 }
832
833 if (g_clientSessionServerList == NULL) {
834 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
835 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
836 }
837
838 ClientSessionServer *serverNode = NULL;
839 SessionInfo *sessionNode = NULL;
840
841 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
842 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
843 return SOFTBUS_LOCK_ERR;
844 }
845
846 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
847 if (IsListEmpty(&serverNode->sessionList)) {
848 continue;
849 }
850
851 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
852 if (sessionNode->channelId == channelId && (int32_t)sessionNode->channelType == channelType) {
853 *data = (int32_t)sessionNode->isEncrypt;
854 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
855 return SOFTBUS_OK;
856 }
857 }
858 }
859
860 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
861 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not found session with channelId [%d]", channelId);
862 return SOFTBUS_ERR;
863 }
864
ClientGetSessionIdByChannelId(int32_t channelId,int32_t channelType,int32_t * sessionId)865 int32_t ClientGetSessionIdByChannelId(int32_t channelId, int32_t channelType, int32_t *sessionId)
866 {
867 if ((channelId < 0) || (sessionId == NULL)) {
868 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
869 return SOFTBUS_INVALID_PARAM;
870 }
871
872 if (g_clientSessionServerList == NULL) {
873 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
874 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
875 }
876
877 ClientSessionServer *serverNode = NULL;
878 SessionInfo *sessionNode = NULL;
879
880 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
881 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
882 return SOFTBUS_LOCK_ERR;
883 }
884
885 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
886 if (IsListEmpty(&serverNode->sessionList)) {
887 continue;
888 }
889
890 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
891 if (sessionNode->channelId == channelId && sessionNode->channelType == (ChannelType)channelType) {
892 *sessionId = sessionNode->sessionId;
893 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
894 return SOFTBUS_OK;
895 }
896 }
897 }
898
899 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
900 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not found session with channelId [%d]", channelId);
901 return SOFTBUS_ERR;
902 }
903
ClientGetRouteTypeByChannelId(int32_t channelId,int32_t channelType,int32_t * routeType)904 int32_t ClientGetRouteTypeByChannelId(int32_t channelId, int32_t channelType, int32_t *routeType)
905 {
906 if ((channelId < 0) || (routeType == NULL)) {
907 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
908 return SOFTBUS_INVALID_PARAM;
909 }
910
911 if (g_clientSessionServerList == NULL) {
912 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
913 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
914 }
915
916 ClientSessionServer *serverNode = NULL;
917 SessionInfo *sessionNode = NULL;
918
919 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
920 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
921 return SOFTBUS_LOCK_ERR;
922 }
923
924 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
925 if (IsListEmpty(&serverNode->sessionList)) {
926 continue;
927 }
928
929 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
930 if (sessionNode->channelId == channelId && sessionNode->channelType == (ChannelType)channelType) {
931 *routeType = sessionNode->routeType;
932 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
933 return SOFTBUS_OK;
934 }
935 }
936 }
937
938 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
939 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not found routeType with channelId [%d]", channelId);
940 return SOFTBUS_ERR;
941 }
942
ClientGetDataConfigByChannelId(int32_t channelId,int32_t channelType,uint32_t * dataConfig)943 int32_t ClientGetDataConfigByChannelId(int32_t channelId, int32_t channelType, uint32_t *dataConfig)
944 {
945 if ((channelId < 0) || (dataConfig == NULL)) {
946 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
947 return SOFTBUS_INVALID_PARAM;
948 }
949
950 if (g_clientSessionServerList == NULL) {
951 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
952 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
953 }
954
955 ClientSessionServer *serverNode = NULL;
956 SessionInfo *sessionNode = NULL;
957
958 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
959 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
960 return SOFTBUS_LOCK_ERR;
961 }
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 && sessionNode->channelType == (ChannelType)channelType) {
970 *dataConfig = sessionNode->dataConfig;
971 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
972 return SOFTBUS_OK;
973 }
974 }
975 }
976
977 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
978 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not found dataConfig with channelId [%d]", channelId);
979 return SOFTBUS_ERR;
980 }
981
ClientEnableSessionByChannelId(const ChannelInfo * channel,int32_t * sessionId)982 int32_t ClientEnableSessionByChannelId(const ChannelInfo *channel, int32_t *sessionId)
983 {
984 if ((channel == NULL) || (sessionId == NULL)) {
985 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
986 return SOFTBUS_INVALID_PARAM;
987 }
988
989 if (g_clientSessionServerList == NULL) {
990 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
991 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
992 }
993
994 ClientSessionServer *serverNode = NULL;
995 SessionInfo *sessionNode = NULL;
996
997 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
998 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
999 return SOFTBUS_LOCK_ERR;
1000 }
1001
1002 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1003 if (IsListEmpty(&serverNode->sessionList)) {
1004 continue;
1005 }
1006
1007 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
1008 if ((sessionNode->channelId == channel->channelId) &&
1009 (sessionNode->channelType == (ChannelType)(channel->channelType))) {
1010 sessionNode->peerPid = channel->peerPid;
1011 sessionNode->peerUid = channel->peerUid;
1012 sessionNode->isServer = channel->isServer;
1013 sessionNode->isEnable = true;
1014 sessionNode->routeType = channel->routeType;
1015 sessionNode->businessType = channel->businessType;
1016 sessionNode->fileEncrypt = channel->fileEncrypt;
1017 sessionNode->dataConfig = channel->dataConfig;
1018 sessionNode->algorithm = channel->algorithm;
1019 sessionNode->crc = channel->crc;
1020 sessionNode->isEncrypt = channel->isEncrypt;
1021 *sessionId = sessionNode->sessionId;
1022 if (channel->channelType == CHANNEL_TYPE_AUTH || !sessionNode->isEncrypt) {
1023 if (memcpy_s(sessionNode->info.peerDeviceId, DEVICE_ID_SIZE_MAX,
1024 channel->peerDeviceId, DEVICE_ID_SIZE_MAX) != EOK) {
1025 (void)SoftBusMutexUnlock(&g_clientSessionServerList->lock);
1026 return SOFTBUS_MEM_ERR;
1027 }
1028 }
1029 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1030 return SOFTBUS_OK;
1031 }
1032 }
1033 }
1034
1035 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1036 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not found session with channelId [%d], channelType [%d]",
1037 channel->channelId, channel->channelType);
1038 return SOFTBUS_ERR;
1039 }
1040
ClientGetSessionCallbackById(int32_t sessionId,ISessionListener * callback)1041 int32_t ClientGetSessionCallbackById(int32_t sessionId, ISessionListener *callback)
1042 {
1043 if (sessionId < 0 || callback == NULL) {
1044 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
1045 return SOFTBUS_INVALID_PARAM;
1046 }
1047
1048 if (g_clientSessionServerList == NULL) {
1049 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
1050 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
1051 }
1052
1053 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
1054 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
1055 return SOFTBUS_LOCK_ERR;
1056 }
1057
1058 ClientSessionServer *serverNode = NULL;
1059 SessionInfo *sessionNode = NULL;
1060 int32_t ret = GetSessionById(sessionId, &serverNode, &sessionNode);
1061 if (ret != SOFTBUS_OK) {
1062 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1063 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s:not found", __func__);
1064 return SOFTBUS_ERR;
1065 }
1066
1067 ret = memcpy_s(callback, sizeof(ISessionListener), &serverNode->listener.session, sizeof(ISessionListener));
1068
1069 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1070 if (ret != EOK) {
1071 return SOFTBUS_ERR;
1072 }
1073 return SOFTBUS_OK;
1074 }
1075
ClientGetSessionCallbackByName(const char * sessionName,ISessionListener * callback)1076 int32_t ClientGetSessionCallbackByName(const char *sessionName, ISessionListener *callback)
1077 {
1078 if (sessionName == NULL || callback == NULL) {
1079 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
1080 return SOFTBUS_INVALID_PARAM;
1081 }
1082
1083 if (g_clientSessionServerList == NULL) {
1084 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
1085 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
1086 }
1087
1088 ClientSessionServer *serverNode = NULL;
1089
1090 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
1091 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
1092 return SOFTBUS_LOCK_ERR;
1093 }
1094
1095 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1096 if (strcmp(serverNode->sessionName, sessionName) != 0) {
1097 continue;
1098 }
1099
1100 int32_t ret = memcpy_s(callback, sizeof(ISessionListener),
1101 &serverNode->listener.session, sizeof(ISessionListener));
1102 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1103 if (ret != EOK) {
1104 return SOFTBUS_ERR;
1105 }
1106 return SOFTBUS_OK;
1107 }
1108
1109 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1110 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s:not found", __func__);
1111 return SOFTBUS_ERR;
1112 }
1113
ClientGetSessionSide(int32_t sessionId)1114 int32_t ClientGetSessionSide(int32_t sessionId)
1115 {
1116 if (g_clientSessionServerList == NULL) {
1117 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
1118 return SOFTBUS_TRANS_SESSION_SERVER_NOINIT;
1119 }
1120
1121 int32_t side = -1;
1122 ClientSessionServer *serverNode = NULL;
1123 SessionInfo *sessionNode = NULL;
1124
1125 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
1126 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
1127 return SOFTBUS_LOCK_ERR;
1128 }
1129
1130 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1131 if (IsListEmpty(&serverNode->sessionList)) {
1132 continue;
1133 }
1134 LIST_FOR_EACH_ENTRY(sessionNode, &(serverNode->sessionList), SessionInfo, node) {
1135 if (sessionNode->sessionId != sessionId) {
1136 continue;
1137 }
1138 side = sessionNode->isServer ? IS_SERVER : IS_CLIENT;
1139 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1140 return side;
1141 }
1142 }
1143 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1144 return side;
1145 }
1146
DestroyClientSessionByNetworkId(const ClientSessionServer * server,const char * networkId,int32_t routeType,ListNode * destroyList)1147 static void DestroyClientSessionByNetworkId(const ClientSessionServer *server,
1148 const char *networkId, int32_t routeType, ListNode *destroyList)
1149 {
1150 SessionInfo *sessionNode = NULL;
1151 SessionInfo *sessionNodeNext = NULL;
1152
1153 LIST_FOR_EACH_ENTRY_SAFE(sessionNode, sessionNodeNext, &(server->sessionList), SessionInfo, node) {
1154 if (strcmp(sessionNode->info.peerDeviceId, networkId) != 0) {
1155 continue;
1156 }
1157 if (routeType != ROUTE_TYPE_ALL && sessionNode->routeType != routeType) {
1158 continue;
1159 }
1160
1161 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "DestroyClientSessionByNetworkId info={%d, %d, %d}",
1162 sessionNode->channelId, sessionNode->channelType, sessionNode->routeType);
1163 DestroySessionInfo *destroyNode = CreateDestroySessionNode(sessionNode, server);
1164 if (destroyNode == NULL) {
1165 continue;
1166 }
1167 DestroySessionId();
1168 ListDelete(&sessionNode->node);
1169 ListAdd(destroyList, &(destroyNode->node));
1170 SoftBusFree(sessionNode);
1171 }
1172 }
1173
ClientTransLnnOfflineProc(NodeBasicInfo * info)1174 static void ClientTransLnnOfflineProc(NodeBasicInfo *info)
1175 {
1176 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "device offline callback enter.");
1177 if (info == NULL) {
1178 return;
1179 }
1180 if (g_clientSessionServerList == NULL) {
1181 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
1182 return;
1183 }
1184
1185 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
1186 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
1187 return;
1188 }
1189
1190 ClientSessionServer *serverNode = NULL;
1191 ListNode destroyList;
1192 ListInit(&destroyList);
1193 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1194 DestroyClientSessionByNetworkId(serverNode, info->networkId, ROUTE_TYPE_ALL, &destroyList);
1195 }
1196 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1197 (void)ClientDestroySession(&destroyList);
1198 return;
1199 }
1200
1201 static INodeStateCb g_transLnnCb = {
1202 .events = EVENT_NODE_STATE_OFFLINE,
1203 .onNodeOffline = ClientTransLnnOfflineProc,
1204 };
1205
ReCreateSessionServerToServer(void)1206 int32_t ReCreateSessionServerToServer(void)
1207 {
1208 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "ReCreateSessionServerToServer");
1209 if (g_clientSessionServerList == NULL) {
1210 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
1211 return SOFTBUS_ERR;
1212 }
1213 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
1214 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
1215 return SOFTBUS_LOCK_ERR;
1216 }
1217
1218 ClientSessionServer *serverNode = NULL;
1219 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1220 int32_t ret = ServerIpcCreateSessionServer(serverNode->pkgName, serverNode->sessionName);
1221 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "session name [%s], pkg name [%s], ret [%d]",
1222 serverNode->sessionName, serverNode->pkgName, ret);
1223 }
1224
1225 (void)SoftBusMutexUnlock(&g_clientSessionServerList->lock);
1226 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "ReCreateSessionServerToServer ok");
1227 return SOFTBUS_OK;
1228 }
1229
1230
ClientTransRegLnnOffline(void)1231 void ClientTransRegLnnOffline(void)
1232 {
1233 int32_t ret;
1234 ret = RegNodeDeviceStateCbInner("trans", &g_transLnnCb);
1235 if (ret != SOFTBUS_OK) {
1236 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "reg lnn offline fail");
1237 }
1238 }
1239
ClientTransOnLinkDown(const char * networkId,int32_t routeType)1240 void ClientTransOnLinkDown(const char *networkId, int32_t routeType)
1241 {
1242 if (networkId == NULL || g_clientSessionServerList == NULL) {
1243 return;
1244 }
1245 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "ClientTransOnLinkDown: routeType=%d", routeType);
1246
1247 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
1248 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
1249 return;
1250 }
1251 ClientSessionServer *serverNode = NULL;
1252 ListNode destroyList;
1253 ListInit(&destroyList);
1254 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1255 DestroyClientSessionByNetworkId(serverNode, networkId, routeType, &destroyList);
1256 }
1257 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1258 (void)ClientDestroySession(&destroyList);
1259 return;
1260 }
1261
ClientGrantPermission(int uid,int pid,const char * busName)1262 int32_t ClientGrantPermission(int uid, int pid, const char *busName)
1263 {
1264 if (uid < 0 || pid < 0 || busName == NULL) {
1265 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid parameter");
1266 return SOFTBUS_ERR;
1267 }
1268 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "ClientGrantPermission: sessionName=%s", busName);
1269
1270 int32_t ret = ServerIpcGrantPermission(uid, pid, busName);
1271 if (ret != SOFTBUS_OK) {
1272 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "server grant permission failed, ret=%d", ret);
1273 }
1274 return ret;
1275 }
1276
ClientRemovePermission(const char * busName)1277 int32_t ClientRemovePermission(const char *busName)
1278 {
1279 if (busName == NULL) {
1280 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid parameter");
1281 return SOFTBUS_ERR;
1282 }
1283 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "ClientRemovePermission: sessionName=%s", busName);
1284
1285 int32_t ret = ServerIpcRemovePermission(busName);
1286 if (ret != SOFTBUS_OK) {
1287 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "server remove permission failed, ret=%d", ret);
1288 }
1289 return ret;
1290 }
1291
ClientGetFileConfigInfoById(int32_t sessionId,int32_t * fileEncrypt,int32_t * algorithm,int32_t * crc)1292 int32_t ClientGetFileConfigInfoById(int32_t sessionId, int32_t *fileEncrypt, int32_t *algorithm, int32_t *crc)
1293 {
1294 if (sessionId < 0 || fileEncrypt == NULL || algorithm == NULL || crc == NULL) {
1295 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "Invalid param");
1296 return SOFTBUS_INVALID_PARAM;
1297 }
1298
1299 if (g_clientSessionServerList == NULL) {
1300 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "not init");
1301 return SOFTBUS_ERR;
1302 }
1303
1304 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) {
1305 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "lock failed");
1306 return SOFTBUS_LOCK_ERR;
1307 }
1308
1309 ClientSessionServer *serverNode = NULL;
1310 SessionInfo *sessionNode = NULL;
1311 int32_t ret = GetSessionById(sessionId, &serverNode, &sessionNode);
1312 if (ret != SOFTBUS_OK) {
1313 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1314 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "%s:not found", __func__);
1315 return SOFTBUS_NOT_FIND;
1316 }
1317 *fileEncrypt = sessionNode->fileEncrypt;
1318 *algorithm = sessionNode->algorithm;
1319 *crc = sessionNode->crc;
1320 (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock));
1321 return SOFTBUS_OK;
1322 }
1323
ClientCleanAllSessionWhenServerDeath(void)1324 void ClientCleanAllSessionWhenServerDeath(void)
1325 {
1326 if (g_clientSessionServerList == NULL) {
1327 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "client session server list not init.");
1328 return;
1329 }
1330 uint32_t destroyCnt = 0;
1331 ListNode destroyList;
1332 ListInit(&destroyList);
1333 if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != SOFTBUS_OK) {
1334 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "client get session server list lock failed.");
1335 return;
1336 }
1337 ClientSessionServer *serverNode = NULL;
1338 SessionInfo *sessionNode = NULL;
1339 SessionInfo *nextSessionNode = NULL;
1340 LIST_FOR_EACH_ENTRY(serverNode, &(g_clientSessionServerList->list), ClientSessionServer, node) {
1341 if (IsListEmpty(&serverNode->sessionList)) {
1342 continue;
1343 }
1344 LIST_FOR_EACH_ENTRY_SAFE(sessionNode, nextSessionNode, &(serverNode->sessionList), SessionInfo, node) {
1345 DestroySessionInfo *destroyNode = CreateDestroySessionNode(sessionNode, serverNode);
1346 if (destroyNode == NULL) {
1347 continue;
1348 }
1349 ListAdd(&destroyList, &(destroyNode->node));
1350 DestroySessionId();
1351 ListDelete(&sessionNode->node);
1352 SoftBusFree(sessionNode);
1353 ++destroyCnt;
1354 }
1355 }
1356 (void)SoftBusMutexUnlock(&g_clientSessionServerList->lock);
1357 (void)ClientDestroySession(&destroyList);
1358 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "client destroy session cnt[%d].", destroyCnt);
1359 }
1360