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 "trans_lane_manager.h"
17
18 #include <securec.h>
19
20 #include "common_list.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_adapter_thread.h"
23 #include "softbus_def.h"
24 #include "softbus_error_code.h"
25 #include "softbus_utils.h"
26 #include "trans_channel_manager.h"
27 #include "trans_lane_pending_ctl.h"
28 #include "trans_log.h"
29 #include "legacy/softbus_hidumper_trans.h"
30 #include "trans_session_manager.h"
31
32 #define CMD_CONCURRENT_SESSION_LIST "concurrent_sessionlist"
33
34 typedef struct {
35 ListNode node;
36 char sessionName[SESSION_NAME_SIZE_MAX];
37 pid_t pid;
38 int32_t sessionId;
39 int32_t channelId;
40 int32_t channelType;
41 uint32_t laneHandle;
42 CoreSessionState state;
43 bool isAsync;
44 bool isQosLane;
45 } SocketWithChannelInfo;
46
47 static SoftBusList *g_channelLaneList = NULL;
48
49 static SoftBusList *g_socketChannelList = NULL;
50
GetTransSessionInfoByLane(TransLaneInfo * laneItem,AppInfo * appInfo)51 static void GetTransSessionInfoByLane(TransLaneInfo * laneItem, AppInfo *appInfo)
52 {
53 if (TransGetAppInfoByChanId(laneItem->channelId, laneItem->channelType, appInfo) != SOFTBUS_OK) {
54 TRANS_LOGE(TRANS_SVC, "TransGetAppInfoByChanId get appInfo failed");
55 }
56 }
57
ConvertLaneLinkTypeToDumper(LaneLinkType type)58 static TransDumpLaneLinkType ConvertLaneLinkTypeToDumper(LaneLinkType type)
59 {
60 switch (type) {
61 case LANE_BR:
62 return DUMPER_LANE_BR;
63 case LANE_BLE:
64 return DUMPER_LANE_BLE;
65 case LANE_SLE:
66 return DUMPER_LANE_SLE;
67 case LANE_P2P:
68 return DUMPER_LANE_P2P;
69 case LANE_WLAN_2P4G:
70 return DUMPER_LANE_WLAN;
71 case LANE_WLAN_5G:
72 return DUMPER_LANE_WLAN;
73 case LANE_ETH:
74 return DUMPER_LANE_ETH;
75 default:
76 break;
77 }
78 return DUMPER_LANE_LINK_TYPE_BUTT;
79 }
80
TransLaneChannelForEachShowInfo(int32_t fd)81 static int32_t TransLaneChannelForEachShowInfo(int32_t fd)
82 {
83 if (g_channelLaneList == NULL) {
84 TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
85 return SOFTBUS_NO_INIT;
86 }
87 AppInfo *appInfo = (AppInfo *)SoftBusMalloc(sizeof(AppInfo));
88 if (appInfo == NULL) {
89 TRANS_LOGE(TRANS_SVC, "TransSessionInfoForEach malloc appInfo failed");
90 return SOFTBUS_MALLOC_ERR;
91 }
92 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
93 TRANS_LOGE(TRANS_SVC, "lock failed");
94 SoftBusFree(appInfo);
95 return SOFTBUS_LOCK_ERR;
96 }
97
98 TransLaneInfo *laneItem = NULL;
99 LIST_FOR_EACH_ENTRY(laneItem, &(g_channelLaneList->list), TransLaneInfo, node) {
100 GetTransSessionInfoByLane(laneItem, appInfo);
101 SoftBusTransDumpRunningSession(fd,
102 ConvertLaneLinkTypeToDumper(laneItem->laneConnInfo.type), appInfo);
103 }
104
105 (void)memset_s(appInfo->sessionKey, sizeof(appInfo->sessionKey), 0, sizeof(appInfo->sessionKey));
106 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
107 SoftBusFree(appInfo);
108 return SOFTBUS_OK;
109 }
110
TransLaneMgrInit(void)111 int32_t TransLaneMgrInit(void)
112 {
113 if (g_channelLaneList != NULL) {
114 TRANS_LOGI(TRANS_INIT, "trans lane info manager has init.");
115 return SOFTBUS_OK;
116 }
117 g_channelLaneList = CreateSoftBusList();
118 if (g_channelLaneList == NULL) {
119 TRANS_LOGE(TRANS_INIT, "trans lane info manager init failed.");
120 return SOFTBUS_MALLOC_ERR;
121 }
122
123 return SoftBusRegTransVarDump(CMD_CONCURRENT_SESSION_LIST, TransLaneChannelForEachShowInfo);
124 }
125
TransSocketLaneMgrInit(void)126 int32_t TransSocketLaneMgrInit(void)
127 {
128 if (g_socketChannelList != NULL) {
129 TRANS_LOGI(TRANS_INIT, "trans lane info manager has init.");
130 return SOFTBUS_OK;
131 }
132 g_socketChannelList = CreateSoftBusList();
133 if (g_socketChannelList == NULL) {
134 TRANS_LOGE(TRANS_INIT, "trans lane info manager init failed.");
135 return SOFTBUS_MALLOC_ERR;
136 }
137 return SOFTBUS_OK;
138 }
139
TransLaneMgrDeinit(void)140 void TransLaneMgrDeinit(void)
141 {
142 TRANS_LOGI(TRANS_CTRL, "enter.");
143 if (g_channelLaneList == NULL) {
144 return;
145 }
146
147 if (SoftBusMutexLock(&g_channelLaneList->lock) != SOFTBUS_OK) {
148 TRANS_LOGE(TRANS_SVC, "lock failed");
149 return;
150 }
151 TransLaneInfo *laneItem = NULL;
152 TransLaneInfo *nextLaneItem = NULL;
153 LIST_FOR_EACH_ENTRY_SAFE(laneItem, nextLaneItem, &g_channelLaneList->list, TransLaneInfo, node) {
154 ListDelete(&(laneItem->node));
155 if (laneItem->isQosLane) {
156 TransFreeLaneByLaneHandle(laneItem->laneHandle, true);
157 } else {
158 LnnFreeLane(laneItem->laneHandle);
159 }
160 SoftBusFree(laneItem);
161 }
162 g_channelLaneList->cnt = 0;
163 (void)SoftBusMutexUnlock(&g_channelLaneList->lock);
164 DestroySoftBusList(g_channelLaneList);
165 g_channelLaneList = NULL;
166 }
167
TransSocketLaneMgrDeinit(void)168 void TransSocketLaneMgrDeinit(void)
169 {
170 TRANS_LOGI(TRANS_CTRL, "enter.");
171 if (g_socketChannelList == NULL) {
172 return;
173 }
174 if (SoftBusMutexLock(&g_socketChannelList->lock) != SOFTBUS_OK) {
175 TRANS_LOGE(TRANS_SVC, "lock failed");
176 return;
177 }
178 SocketWithChannelInfo *socketItem = NULL;
179 SocketWithChannelInfo *nextSocketItem = NULL;
180 LIST_FOR_EACH_ENTRY_SAFE(socketItem, nextSocketItem, &g_socketChannelList->list, SocketWithChannelInfo, node) {
181 ListDelete(&(socketItem->node));
182 SoftBusFree(socketItem);
183 }
184 g_socketChannelList->cnt = 0;
185 (void)SoftBusMutexUnlock(&g_socketChannelList->lock);
186 DestroySoftBusList(g_socketChannelList);
187 g_socketChannelList = NULL;
188 }
189
TransLaneMgrAddLane(const TransInfo * transInfo,const LaneConnInfo * connInfo,uint32_t laneHandle,bool isQosLane,AppInfoData * myData)190 int32_t TransLaneMgrAddLane(
191 const TransInfo *transInfo, const LaneConnInfo *connInfo, uint32_t laneHandle, bool isQosLane, AppInfoData *myData)
192 {
193 if (transInfo == NULL || g_channelLaneList == NULL || connInfo == NULL || myData == NULL) {
194 return SOFTBUS_INVALID_PARAM;
195 }
196 TransLaneInfo *newLane = (TransLaneInfo *)SoftBusCalloc(sizeof(TransLaneInfo));
197 TRANS_CHECK_AND_RETURN_RET_LOGE(newLane != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "calloc laneInfo failed.");
198 newLane->channelId = transInfo->channelId;
199 newLane->channelType = transInfo->channelType;
200 newLane->laneHandle = laneHandle;
201 newLane->isQosLane = isQosLane;
202 newLane->pid = myData->pid;
203 if (memcpy_s(&(newLane->laneConnInfo), sizeof(LaneConnInfo), connInfo, sizeof(LaneConnInfo)) != EOK) {
204 SoftBusFree(newLane);
205 TRANS_LOGE(TRANS_SVC, "memcpy connInfo failed");
206 return SOFTBUS_MEM_ERR;
207 }
208 if (strcpy_s(newLane->pkgName, sizeof(newLane->pkgName), myData->pkgName) != EOK) {
209 SoftBusFree(newLane);
210 TRANS_LOGE(TRANS_SVC, "strcpy failed.");
211 return SOFTBUS_STRCPY_ERR;
212 }
213 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
214 SoftBusFree(newLane);
215 TRANS_LOGE(TRANS_SVC, "lock failed");
216 return SOFTBUS_LOCK_ERR;
217 }
218
219 TransLaneInfo *laneItem = NULL;
220 LIST_FOR_EACH_ENTRY(laneItem, &(g_channelLaneList->list), TransLaneInfo, node) {
221 if (laneItem->channelId == transInfo->channelId && laneItem->channelType == transInfo->channelType) {
222 SoftBusFree(newLane);
223 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
224 TRANS_LOGI(TRANS_SVC, "trans lane info has existed. channelId=%{public}d, channelType=%{public}d",
225 transInfo->channelId, transInfo->channelType);
226 return SOFTBUS_ALREADY_EXISTED;
227 }
228 }
229 ListInit(&(newLane->node));
230 ListAdd(&(g_channelLaneList->list), &(newLane->node));
231 TRANS_LOGI(TRANS_CTRL, "add channelId=%{public}d", newLane->channelId);
232 g_channelLaneList->cnt++;
233 TRANS_LOGI(TRANS_SVC, "lane count is cnt=%{public}d", g_channelLaneList->cnt);
234 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
235 return SOFTBUS_OK;
236 }
237
TransLaneMgrDelLane(int32_t channelId,int32_t channelType,bool isAsync)238 int32_t TransLaneMgrDelLane(int32_t channelId, int32_t channelType, bool isAsync)
239 {
240 if (g_channelLaneList == NULL) {
241 TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
242 return SOFTBUS_NO_INIT;
243 }
244 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
245 TRANS_LOGE(TRANS_SVC, "lock failed");
246 return SOFTBUS_LOCK_ERR;
247 }
248 TransLaneInfo *laneItem = NULL;
249 TransLaneInfo *next = NULL;
250 int32_t ret = SOFTBUS_TRANS_NODE_NOT_FOUND;
251 uint32_t laneHandle = 0;
252 bool isQos = false;
253 LIST_FOR_EACH_ENTRY_SAFE(laneItem, next, &(g_channelLaneList->list), TransLaneInfo, node) {
254 if (laneItem->channelId == channelId && laneItem->channelType == channelType) {
255 ListDelete(&(laneItem->node));
256 TRANS_LOGI(TRANS_CTRL, "delete channelId=%{public}d, channelType = %{public}d",
257 laneItem->channelId, laneItem->channelType);
258 g_channelLaneList->cnt--;
259 laneHandle = laneItem->laneHandle;
260 if (laneItem->isQosLane) {
261 isQos = true;
262 }
263 SoftBusFree(laneItem);
264 ret = SOFTBUS_OK;
265 break;
266 }
267 }
268 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
269 if (ret != SOFTBUS_OK) {
270 TRANS_LOGW(TRANS_SVC, "No lane to be is found. channelId=%{public}d.", channelId);
271 return ret;
272 }
273 if (isQos) {
274 TransFreeLaneByLaneHandle(laneHandle, isAsync);
275 } else {
276 LnnFreeLane(laneHandle);
277 }
278 return ret;
279 }
280
TransLaneMgrDeathCallback(const char * pkgName,int32_t pid)281 void TransLaneMgrDeathCallback(const char *pkgName, int32_t pid)
282 {
283 (void)TransDeleteSocketChannelInfoByPid(pid);
284 if (pkgName == NULL || g_channelLaneList == NULL) {
285 TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
286 return;
287 }
288 char *anonymizePkgName = NULL;
289 Anonymize(pkgName, &anonymizePkgName);
290 TRANS_LOGW(TRANS_CTRL, "pkgName=%{public}s, pid=%{public}d", AnonymizeWrapper(anonymizePkgName), pid);
291 AnonymizeFree(anonymizePkgName);
292 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
293 TRANS_LOGE(TRANS_SVC, "lock failed");
294 return;
295 }
296 TransLaneInfo *laneItem = NULL;
297 TransLaneInfo *next = NULL;
298 LIST_FOR_EACH_ENTRY_SAFE(laneItem, next, &(g_channelLaneList->list), TransLaneInfo, node) {
299 if ((strcmp(laneItem->pkgName, pkgName) == 0) && (laneItem->pid == pid)) {
300 ListDelete(&(laneItem->node));
301 g_channelLaneList->cnt--;
302 TRANS_LOGI(TRANS_SVC, "death del lane. channelId=%{public}d, channelType=%{public}d",
303 laneItem->channelId, laneItem->channelType);
304 if (laneItem->isQosLane) {
305 TransFreeLaneByLaneHandle(laneItem->laneHandle, true);
306 } else {
307 LnnFreeLane(laneItem->laneHandle);
308 }
309 SoftBusFree(laneItem);
310 }
311 }
312 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
313 return;
314 }
315
TransGetLaneHandleByChannelId(int32_t channelId,uint32_t * laneHandle)316 int32_t TransGetLaneHandleByChannelId(int32_t channelId, uint32_t *laneHandle)
317 {
318 if (g_channelLaneList == NULL || laneHandle == NULL) {
319 return SOFTBUS_INVALID_PARAM;
320 }
321 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
322 return SOFTBUS_LOCK_ERR;
323 }
324 TransLaneInfo *item = NULL;
325 LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
326 if (item->channelId == channelId) {
327 *laneHandle = item->laneHandle;
328 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
329 return SOFTBUS_OK;
330 }
331 }
332 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
333 return SOFTBUS_TRANS_NODE_NOT_FOUND;
334 }
335
TransGetLaneIdByChannelId(int32_t channelId,uint64_t * laneId)336 int32_t TransGetLaneIdByChannelId(int32_t channelId, uint64_t *laneId)
337 {
338 if (g_channelLaneList == NULL || laneId == NULL) {
339 return SOFTBUS_INVALID_PARAM;
340 }
341 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != 0) {
342 return SOFTBUS_LOCK_ERR;
343 }
344 TransLaneInfo *item = NULL;
345 LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
346 if (item->channelId == channelId) {
347 *laneId = item->laneConnInfo.laneId;
348 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
349 return SOFTBUS_OK;
350 }
351 }
352 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
353 return SOFTBUS_NOT_FIND;
354 }
355
TransGetChannelInfoByLaneHandle(uint32_t laneHandle,int32_t * channelId,int32_t * channelType)356 int32_t TransGetChannelInfoByLaneHandle(uint32_t laneHandle, int32_t *channelId, int32_t *channelType)
357 {
358 if (g_channelLaneList == NULL || channelId == NULL || channelType == NULL) {
359 return SOFTBUS_INVALID_PARAM;
360 }
361 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
362 return SOFTBUS_LOCK_ERR;
363 }
364 TransLaneInfo *item = NULL;
365 LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
366 if (item->laneHandle == laneHandle) {
367 *channelId = item->channelId;
368 *channelType = item->channelType;
369 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
370 return SOFTBUS_OK;
371 }
372 }
373 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
374 return SOFTBUS_TRANS_NODE_NOT_FOUND;
375 }
376
GetSocketWithChannelInfoBySession(const char * sessionName,int32_t sessionId)377 static SocketWithChannelInfo *GetSocketWithChannelInfoBySession(const char *sessionName, int32_t sessionId)
378 {
379 // need get lock before
380 SocketWithChannelInfo *socketItem = NULL;
381 LIST_FOR_EACH_ENTRY(socketItem, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
382 if (strcmp(socketItem->sessionName, sessionName) == 0 && socketItem->sessionId == sessionId) {
383 return socketItem;
384 }
385 }
386 return NULL;
387 }
388
AnonymizeLogSessionNameWhenNotFound(const char * sessionName,int32_t sessionId)389 static void AnonymizeLogSessionNameWhenNotFound(const char *sessionName, int32_t sessionId)
390 {
391 char *tmpName = NULL;
392 Anonymize(sessionName, &tmpName);
393 TRANS_LOGE(
394 TRANS_SVC, "socket info not found. sessionName=%{public}s, sessionId=%{public}d",
395 AnonymizeWrapper(tmpName), sessionId);
396 AnonymizeFree(tmpName);
397 }
398
TransAddSocketChannelInfo(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType,CoreSessionState state)399 int32_t TransAddSocketChannelInfo(
400 const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType, CoreSessionState state)
401 {
402 if (sessionName == NULL) {
403 TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null");
404 return SOFTBUS_TRANS_INVALID_SESSION_NAME;
405 }
406 if (sessionId <= 0) {
407 TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId);
408 return SOFTBUS_TRANS_INVALID_SESSION_ID;
409 }
410 TRANS_CHECK_AND_RETURN_RET_LOGE(
411 g_socketChannelList != NULL, SOFTBUS_NO_INIT, TRANS_INIT, "socket info manager hasn't init.");
412
413 SocketWithChannelInfo *newSocket = (SocketWithChannelInfo *)SoftBusCalloc(sizeof(SocketWithChannelInfo));
414 TRANS_CHECK_AND_RETURN_RET_LOGE(newSocket != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "socket info calloc failed.");
415 if (strcpy_s(newSocket->sessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK) {
416 SoftBusFree(newSocket);
417 return SOFTBUS_STRCPY_ERR;
418 }
419 newSocket->sessionId = sessionId;
420 newSocket->channelId = channelId;
421 newSocket->channelType = channelType;
422 newSocket->state = state;
423 newSocket->laneHandle = INVALID_LANE_REQ_ID;
424 newSocket->isQosLane = false;
425 newSocket->isAsync = false;
426 int32_t tmpUid;
427 TransGetUidAndPid(sessionName, &tmpUid, &(newSocket->pid));
428
429 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
430 TRANS_LOGE(TRANS_SVC, "lock failed");
431 SoftBusFree(newSocket);
432 return SOFTBUS_LOCK_ERR;
433 }
434
435 SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
436 if (socketItem != NULL) {
437 char *tmpName = NULL;
438 Anonymize(sessionName, &tmpName);
439 TRANS_LOGI(
440 TRANS_SVC, "socket lane info has existed. socket=%{public}d, sessionName=%{public}s",
441 sessionId, AnonymizeWrapper(tmpName));
442 AnonymizeFree(tmpName);
443 SoftBusFree(newSocket);
444 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
445 return SOFTBUS_OK;
446 }
447
448 ListInit(&(newSocket->node));
449 ListAdd(&(g_socketChannelList->list), &(newSocket->node));
450 g_socketChannelList->cnt++;
451 TRANS_LOGI(TRANS_SVC, "socket lane count is cnt=%{public}d", g_socketChannelList->cnt);
452 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
453 return SOFTBUS_OK;
454 }
455
CheckParamIsValid(const char * sessionName,int32_t sessionId)456 static int32_t CheckParamIsValid(const char *sessionName, int32_t sessionId)
457 {
458 if (sessionName == NULL) {
459 TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null");
460 return SOFTBUS_TRANS_INVALID_SESSION_NAME;
461 }
462 if (sessionId <= 0) {
463 TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId);
464 return SOFTBUS_TRANS_INVALID_SESSION_ID;
465 }
466 return SOFTBUS_OK;
467 }
468
TransUpdateSocketChannelInfoBySession(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType)469 int32_t TransUpdateSocketChannelInfoBySession(
470 const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)
471 {
472 int32_t ret = CheckParamIsValid(sessionName, sessionId);
473 if (ret != SOFTBUS_OK) {
474 return ret;
475 }
476 if (g_socketChannelList == NULL) {
477 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
478 return SOFTBUS_NO_INIT;
479 }
480 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
481 TRANS_LOGE(TRANS_SVC, "lock failed");
482 return SOFTBUS_LOCK_ERR;
483 }
484 SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
485 if (socketItem != NULL) {
486 socketItem->channelId = channelId;
487 socketItem->channelType = channelType;
488 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
489 return SOFTBUS_OK;
490 }
491 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
492 AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
493 return SOFTBUS_NOT_FIND;
494 }
495
TransUpdateSocketChannelLaneInfoBySession(const char * sessionName,int32_t sessionId,uint32_t laneHandle,bool isQosLane,bool isAsync)496 int32_t TransUpdateSocketChannelLaneInfoBySession(
497 const char *sessionName, int32_t sessionId, uint32_t laneHandle, bool isQosLane, bool isAsync)
498 {
499 int32_t ret = CheckParamIsValid(sessionName, sessionId);
500 if (ret != SOFTBUS_OK) {
501 return ret;
502 }
503 if (g_socketChannelList == NULL) {
504 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
505 return SOFTBUS_NO_INIT;
506 }
507 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
508 TRANS_LOGE(TRANS_SVC, "lock failed");
509 return SOFTBUS_LOCK_ERR;
510 }
511 SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
512 if (socketItem != NULL) {
513 socketItem->laneHandle = laneHandle;
514 socketItem->isQosLane = isQosLane;
515 socketItem->isAsync = isAsync;
516 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
517 return SOFTBUS_OK;
518 }
519 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
520 AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
521 return SOFTBUS_NOT_FIND;
522 }
523
TransDeleteSocketChannelInfoBySession(const char * sessionName,int32_t sessionId)524 int32_t TransDeleteSocketChannelInfoBySession(const char *sessionName, int32_t sessionId)
525 {
526 int32_t ret = CheckParamIsValid(sessionName, sessionId);
527 if (ret != SOFTBUS_OK) {
528 return ret;
529 }
530 if (g_socketChannelList == NULL) {
531 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
532 return SOFTBUS_NO_INIT;
533 }
534 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
535 TRANS_LOGE(TRANS_SVC, "lock failed");
536 return SOFTBUS_LOCK_ERR;
537 }
538 SocketWithChannelInfo *socketItem = NULL;
539 SocketWithChannelInfo *next = NULL;
540 LIST_FOR_EACH_ENTRY_SAFE(socketItem, next, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
541 if (strcmp(socketItem->sessionName, sessionName) == 0 && socketItem->sessionId == sessionId) {
542 ListDelete(&(socketItem->node));
543 g_socketChannelList->cnt--;
544 SoftBusFree(socketItem);
545 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
546 char *tmpName = NULL;
547 Anonymize(sessionName, &tmpName);
548 TRANS_LOGI(TRANS_CTRL, "delete socket channel info, sessionName=%{public}s, sessionId=%{public}d",
549 AnonymizeWrapper(tmpName), sessionId);
550 AnonymizeFree(tmpName);
551 return SOFTBUS_OK;
552 }
553 }
554 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
555 AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
556 return SOFTBUS_NOT_FIND;
557 }
558
TransDeleteSocketChannelInfoByChannel(int32_t channelId,int32_t channelType)559 int32_t TransDeleteSocketChannelInfoByChannel(int32_t channelId, int32_t channelType)
560 {
561 if (g_socketChannelList == NULL) {
562 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
563 return SOFTBUS_NO_INIT;
564 }
565 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
566 TRANS_LOGE(TRANS_SVC, "lock failed");
567 return SOFTBUS_LOCK_ERR;
568 }
569 SocketWithChannelInfo *socketItem = NULL;
570 SocketWithChannelInfo *next = NULL;
571 LIST_FOR_EACH_ENTRY_SAFE(socketItem, next, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
572 if (socketItem->channelId == channelId && socketItem->channelType == channelType) {
573 ListDelete(&(socketItem->node));
574 g_socketChannelList->cnt--;
575 SoftBusFree(socketItem);
576 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
577 TRANS_LOGI(TRANS_CTRL, "delete socket channel info, channelId=%{public}d, channelType=%{public}d",
578 channelId, channelType);
579 return SOFTBUS_OK;
580 }
581 }
582 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
583 TRANS_LOGD(
584 TRANS_SVC, "socket info not found. channelId=%{public}d, channelType=%{public}d", channelId, channelType);
585 return SOFTBUS_NOT_FIND;
586 }
587
TransDeleteSocketChannelInfoByPid(int32_t pid)588 int32_t TransDeleteSocketChannelInfoByPid(int32_t pid)
589 {
590 if (g_socketChannelList == NULL) {
591 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
592 return SOFTBUS_NO_INIT;
593 }
594 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
595 TRANS_LOGE(TRANS_SVC, "lock failed");
596 return SOFTBUS_LOCK_ERR;
597 }
598 int32_t delCount = 0;
599 SocketWithChannelInfo *socketItem = NULL;
600 SocketWithChannelInfo *next = NULL;
601 LIST_FOR_EACH_ENTRY_SAFE(socketItem, next, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
602 if (socketItem->pid == pid) {
603 ListDelete(&(socketItem->node));
604 g_socketChannelList->cnt--;
605 SoftBusFree(socketItem);
606 delCount++;
607 }
608 }
609 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
610 if (delCount > 0) {
611 TRANS_LOGI(TRANS_CTRL, "delete socket channel info, pid=%{public}d delete count=%{public}d",
612 pid, delCount);
613 return SOFTBUS_OK;
614 }
615 return SOFTBUS_NOT_FIND;
616 }
617
TransSetSocketChannelStateBySession(const char * sessionName,int32_t sessionId,CoreSessionState state)618 int32_t TransSetSocketChannelStateBySession(const char *sessionName, int32_t sessionId, CoreSessionState state)
619 {
620 int32_t ret = CheckParamIsValid(sessionName, sessionId);
621 if (ret != SOFTBUS_OK) {
622 return ret;
623 }
624 if (g_socketChannelList == NULL) {
625 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
626 return SOFTBUS_NO_INIT;
627 }
628 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
629 TRANS_LOGE(TRANS_SVC, "lock failed");
630 return SOFTBUS_LOCK_ERR;
631 }
632 SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
633 if (socketItem != NULL) {
634 socketItem->state = state;
635 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
636 return SOFTBUS_OK;
637 }
638 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
639 AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
640 return SOFTBUS_NOT_FIND;
641 }
642
TransSetSocketChannelStateByChannel(int32_t channelId,int32_t channelType,CoreSessionState state)643 int32_t TransSetSocketChannelStateByChannel(int32_t channelId, int32_t channelType, CoreSessionState state)
644 {
645 if (g_socketChannelList == NULL) {
646 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
647 return SOFTBUS_NO_INIT;
648 }
649 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
650 TRANS_LOGE(TRANS_SVC, "lock failed");
651 return SOFTBUS_LOCK_ERR;
652 }
653 SocketWithChannelInfo *socketItem = NULL;
654 LIST_FOR_EACH_ENTRY(socketItem, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
655 if (socketItem->channelId == channelId && socketItem->channelType == channelType) {
656 socketItem->state = state;
657 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
658 return SOFTBUS_OK;
659 }
660 }
661 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
662 TRANS_LOGE(
663 TRANS_SVC, "socket info not found. channelId=%{public}d, channelType=%{public}d", channelId, channelType);
664 return SOFTBUS_NOT_FIND;
665 }
666
TransGetSocketChannelStateBySession(const char * sessionName,int32_t sessionId,CoreSessionState * state)667 int32_t TransGetSocketChannelStateBySession(const char *sessionName, int32_t sessionId, CoreSessionState *state)
668 {
669 int32_t ret = CheckParamIsValid(sessionName, sessionId);
670 if (ret != SOFTBUS_OK) {
671 return ret;
672 }
673 if (g_socketChannelList == NULL) {
674 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
675 return SOFTBUS_NO_INIT;
676 }
677 if (state == NULL) {
678 TRANS_LOGE(TRANS_SVC, "Invaild param, state is null");
679 return SOFTBUS_INVALID_PARAM;
680 }
681 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
682 TRANS_LOGE(TRANS_SVC, "lock failed");
683 return SOFTBUS_LOCK_ERR;
684 }
685 SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
686 if (socketItem != NULL) {
687 *state = socketItem->state;
688 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
689 return SOFTBUS_OK;
690 }
691 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
692 AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
693 return SOFTBUS_NOT_FIND;
694 }
695
TransGetSocketChannelLaneInfoBySession(const char * sessionName,int32_t sessionId,uint32_t * laneHandle,bool * isQosLane,bool * isAsync)696 int32_t TransGetSocketChannelLaneInfoBySession(
697 const char *sessionName, int32_t sessionId, uint32_t *laneHandle, bool *isQosLane, bool *isAsync)
698 {
699 int32_t ret = CheckParamIsValid(sessionName, sessionId);
700 if (ret != SOFTBUS_OK) {
701 return ret;
702 }
703 if (g_socketChannelList == NULL) {
704 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
705 return SOFTBUS_NO_INIT;
706 }
707 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
708 TRANS_LOGE(TRANS_SVC, "lock failed");
709 return SOFTBUS_LOCK_ERR;
710 }
711 SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
712 if (socketItem != NULL) {
713 if (laneHandle != NULL) {
714 *laneHandle = socketItem->laneHandle;
715 }
716 if (isQosLane != NULL) {
717 *isQosLane = socketItem->isQosLane;
718 }
719 if (isAsync != NULL) {
720 *isAsync = socketItem->isAsync;
721 }
722 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
723 return SOFTBUS_OK;
724 }
725 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
726 AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
727 return SOFTBUS_NOT_FIND;
728 }
729
TransGetSocketChannelStateByChannel(int32_t channelId,int32_t channelType,CoreSessionState * state)730 int32_t TransGetSocketChannelStateByChannel(int32_t channelId, int32_t channelType, CoreSessionState *state)
731 {
732 if (state == NULL) {
733 TRANS_LOGE(TRANS_SVC, "Invaild param");
734 return SOFTBUS_INVALID_PARAM;
735 }
736
737 if (g_socketChannelList == NULL) {
738 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
739 return SOFTBUS_NO_INIT;
740 }
741 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
742 TRANS_LOGE(TRANS_SVC, "lock failed");
743 return SOFTBUS_LOCK_ERR;
744 }
745 SocketWithChannelInfo *socketItem = NULL;
746 LIST_FOR_EACH_ENTRY(socketItem, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
747 if (socketItem->channelId == channelId && socketItem->channelType == channelType) {
748 *state = socketItem->state;
749 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
750 return SOFTBUS_OK;
751 }
752 }
753 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
754 TRANS_LOGE(
755 TRANS_SVC, "socket info not found. channelId=%{public}d, channelType=%{public}d", channelId, channelType);
756 return SOFTBUS_NOT_FIND;
757 }
758
TransGetPidFromSocketChannelInfoBySession(const char * sessionName,int32_t sessionId,int32_t * pid)759 int32_t TransGetPidFromSocketChannelInfoBySession(const char *sessionName, int32_t sessionId, int32_t *pid)
760 {
761 int32_t ret = CheckParamIsValid(sessionName, sessionId);
762 if (ret != SOFTBUS_OK) {
763 return ret;
764 }
765 if (g_socketChannelList == NULL) {
766 TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
767 return SOFTBUS_NO_INIT;
768 }
769 if (pid == NULL) {
770 TRANS_LOGE(TRANS_SVC, "Invaild param, pid is null");
771 return SOFTBUS_INVALID_PARAM;
772 }
773 if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
774 TRANS_LOGE(TRANS_SVC, "lock failed");
775 return SOFTBUS_LOCK_ERR;
776 }
777 SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
778 if (socketItem != NULL) {
779 *pid = socketItem->pid;
780 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
781 return SOFTBUS_OK;
782 }
783 (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
784 AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
785 return SOFTBUS_NOT_FIND;
786 }
787
ConvertLaneLinkTypeToConnectType(LaneLinkType laneLinkType)788 static ConnectType ConvertLaneLinkTypeToConnectType(LaneLinkType laneLinkType)
789 {
790 switch (laneLinkType) {
791 case LANE_BR:
792 return CONNECT_BR;
793 case LANE_BLE:
794 case LANE_COC:
795 return CONNECT_BLE;
796 case LANE_P2P:
797 return CONNECT_P2P;
798 case LANE_WLAN_2P4G:
799 case LANE_WLAN_5G:
800 case LANE_ETH:
801 return CONNECT_TCP;
802 case LANE_P2P_REUSE:
803 return CONNECT_P2P_REUSE;
804 case LANE_BLE_DIRECT:
805 case LANE_COC_DIRECT:
806 return CONNECT_BLE_DIRECT;
807 case LANE_HML:
808 return CONNECT_HML;
809 case LANE_BLE_REUSE:
810 return CONNECT_BLE;
811 case LANE_SLE:
812 return CONNECT_SLE;
813 case LANE_SLE_DIRECT:
814 return CONNECT_SLE_DIRECT;
815 default:
816 return CONNECT_TYPE_MAX;
817 }
818 }
819
TransGetConnectTypeByChannelId(int32_t channelId,ConnectType * connectType)820 int32_t TransGetConnectTypeByChannelId(int32_t channelId, ConnectType *connectType)
821 {
822 if (connectType == NULL) {
823 TRANS_LOGE(TRANS_INIT, "connectType is null");
824 return SOFTBUS_INVALID_PARAM;
825 }
826
827 if (g_channelLaneList == NULL) {
828 TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
829 return SOFTBUS_INVALID_PARAM;
830 }
831
832 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
833 TRANS_LOGE(TRANS_SVC, "lock failed");
834 return SOFTBUS_LOCK_ERR;
835 }
836
837 TransLaneInfo *item = NULL;
838 LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
839 if (item->channelId != channelId) {
840 continue;
841 }
842
843 ConnectType connType = ConvertLaneLinkTypeToConnectType(item->laneConnInfo.type);
844 if (connType >= CONNECT_TYPE_MAX) {
845 TRANS_LOGE(TRANS_SVC, "invalid connectType=%{public}d. linkType=%{public}d, channelId=%{public}d",
846 connType, item->laneConnInfo.type, channelId);
847 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
848 return SOFTBUS_CONN_INVALID_CONN_TYPE;
849 }
850
851 *connectType = connType;
852 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
853 return SOFTBUS_OK;
854 }
855 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
856 TRANS_LOGE(TRANS_SVC, "can not find connectType by channelId=%{public}d", channelId);
857 return SOFTBUS_TRANS_INVALID_CHANNEL_ID;
858 }
859
TransGetTransLaneInfoByLaneHandle(uint32_t laneHandle,TransLaneInfo * laneInfo)860 int32_t TransGetTransLaneInfoByLaneHandle(uint32_t laneHandle, TransLaneInfo *laneInfo)
861 {
862 if (laneInfo == NULL) {
863 TRANS_LOGE(TRANS_INIT, "laneInfo is null");
864 return SOFTBUS_INVALID_PARAM;
865 }
866 if (g_channelLaneList == NULL) {
867 TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
868 return SOFTBUS_INVALID_PARAM;
869 }
870
871 if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
872 TRANS_LOGE(TRANS_SVC, "lock failed");
873 return SOFTBUS_LOCK_ERR;
874 }
875 TransLaneInfo *item = NULL;
876 LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
877 if (item->laneHandle == laneHandle) {
878 if (memcpy_s(laneInfo, sizeof(TransLaneInfo), item, sizeof(TransLaneInfo)) != EOK) {
879 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
880 return SOFTBUS_MEM_ERR;
881 }
882 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
883 return SOFTBUS_OK;
884 }
885 }
886 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
887 TRANS_LOGE(TRANS_SVC, "can not find laneInfo by laneHandle=%{public}u", laneHandle);
888 return SOFTBUS_NOT_FIND;
889 }