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