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 
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_P2P:
66             return DUMPER_LANE_P2P;
67         case LANE_WLAN_2P4G:
68             return DUMPER_LANE_WLAN;
69         case LANE_WLAN_5G:
70             return DUMPER_LANE_WLAN;
71         case LANE_ETH:
72             return DUMPER_LANE_ETH;
73         default:
74             break;
75     }
76     return DUMPER_LANE_LINK_TYPE_BUTT;
77 }
78 
TransLaneChannelForEachShowInfo(int32_t fd)79 static int32_t TransLaneChannelForEachShowInfo(int32_t fd)
80 {
81     if (g_channelLaneList == NULL) {
82         TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
83         return SOFTBUS_NO_INIT;
84     }
85     AppInfo *appInfo = (AppInfo *)SoftBusMalloc(sizeof(AppInfo));
86     if (appInfo == NULL) {
87         TRANS_LOGE(TRANS_SVC, "TransSessionInfoForEach malloc appInfo failed");
88         return SOFTBUS_MALLOC_ERR;
89     }
90     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
91         TRANS_LOGE(TRANS_SVC, "lock failed");
92         SoftBusFree(appInfo);
93         return SOFTBUS_LOCK_ERR;
94     }
95 
96     TransLaneInfo *laneItem = NULL;
97     LIST_FOR_EACH_ENTRY(laneItem, &(g_channelLaneList->list), TransLaneInfo, node) {
98         GetTransSessionInfoByLane(laneItem, appInfo);
99         SoftBusTransDumpRunningSession(fd,
100             ConvertLaneLinkTypeToDumper(laneItem->laneConnInfo.type), appInfo);
101     }
102 
103     (void)memset_s(appInfo->sessionKey, sizeof(appInfo->sessionKey), 0, sizeof(appInfo->sessionKey));
104     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
105     SoftBusFree(appInfo);
106     return SOFTBUS_OK;
107 }
108 
TransLaneMgrInit(void)109 int32_t TransLaneMgrInit(void)
110 {
111     if (g_channelLaneList != NULL) {
112         TRANS_LOGI(TRANS_INIT, "trans lane info manager has init.");
113         return SOFTBUS_OK;
114     }
115     g_channelLaneList = CreateSoftBusList();
116     if (g_channelLaneList == NULL) {
117         TRANS_LOGE(TRANS_INIT, "trans lane info manager init failed.");
118         return SOFTBUS_MALLOC_ERR;
119     }
120 
121     return SoftBusRegTransVarDump(CMD_CONCURRENT_SESSION_LIST, TransLaneChannelForEachShowInfo);
122 }
123 
TransSocketLaneMgrInit(void)124 int32_t TransSocketLaneMgrInit(void)
125 {
126     if (g_socketChannelList != NULL) {
127         TRANS_LOGI(TRANS_INIT, "trans lane info manager has init.");
128         return SOFTBUS_OK;
129     }
130     g_socketChannelList = CreateSoftBusList();
131     if (g_socketChannelList == NULL) {
132         TRANS_LOGE(TRANS_INIT, "trans lane info manager init failed.");
133         return SOFTBUS_MALLOC_ERR;
134     }
135     return SOFTBUS_OK;
136 }
137 
TransLaneMgrDeinit(void)138 void TransLaneMgrDeinit(void)
139 {
140     TRANS_LOGI(TRANS_CTRL, "enter.");
141     if (g_channelLaneList == NULL) {
142         return;
143     }
144 
145     if (SoftBusMutexLock(&g_channelLaneList->lock) != SOFTBUS_OK) {
146         TRANS_LOGE(TRANS_SVC, "lock failed");
147         return;
148     }
149     TransLaneInfo *laneItem = NULL;
150     TransLaneInfo *nextLaneItem = NULL;
151     LIST_FOR_EACH_ENTRY_SAFE(laneItem, nextLaneItem, &g_channelLaneList->list, TransLaneInfo, node) {
152         ListDelete(&(laneItem->node));
153         if (laneItem->isQosLane) {
154             TransFreeLaneByLaneHandle(laneItem->laneHandle, true);
155         } else {
156             LnnFreeLane(laneItem->laneHandle);
157         }
158         SoftBusFree(laneItem);
159     }
160     g_channelLaneList->cnt = 0;
161     (void)SoftBusMutexUnlock(&g_channelLaneList->lock);
162     DestroySoftBusList(g_channelLaneList);
163     g_channelLaneList = NULL;
164 }
165 
TransSocketLaneMgrDeinit(void)166 void TransSocketLaneMgrDeinit(void)
167 {
168     TRANS_LOGI(TRANS_CTRL, "enter.");
169     if (g_socketChannelList == NULL) {
170         return;
171     }
172     if (SoftBusMutexLock(&g_socketChannelList->lock) != SOFTBUS_OK) {
173         TRANS_LOGE(TRANS_SVC, "lock failed");
174         return;
175     }
176     SocketWithChannelInfo *socketItem = NULL;
177     SocketWithChannelInfo *nextSocketItem = NULL;
178     LIST_FOR_EACH_ENTRY_SAFE(socketItem, nextSocketItem, &g_socketChannelList->list, SocketWithChannelInfo, node) {
179         ListDelete(&(socketItem->node));
180         SoftBusFree(socketItem);
181     }
182     g_socketChannelList->cnt = 0;
183     (void)SoftBusMutexUnlock(&g_socketChannelList->lock);
184     DestroySoftBusList(g_socketChannelList);
185     g_socketChannelList = NULL;
186 }
187 
TransLaneMgrAddLane(const TransInfo * transInfo,const LaneConnInfo * connInfo,uint32_t laneHandle,bool isQosLane,AppInfoData * myData)188 int32_t TransLaneMgrAddLane(
189     const TransInfo *transInfo, const LaneConnInfo *connInfo, uint32_t laneHandle, bool isQosLane, AppInfoData *myData)
190 {
191     if (transInfo == NULL || g_channelLaneList == NULL || connInfo == NULL || myData == NULL) {
192         return SOFTBUS_INVALID_PARAM;
193     }
194     TransLaneInfo *newLane = (TransLaneInfo *)SoftBusCalloc(sizeof(TransLaneInfo));
195     TRANS_CHECK_AND_RETURN_RET_LOGE(newLane != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "calloc laneInfo failed.");
196     newLane->channelId = transInfo->channelId;
197     newLane->channelType = transInfo->channelType;
198     newLane->laneHandle = laneHandle;
199     newLane->isQosLane = isQosLane;
200     newLane->pid = myData->pid;
201     if (memcpy_s(&(newLane->laneConnInfo), sizeof(LaneConnInfo), connInfo, sizeof(LaneConnInfo)) != EOK) {
202         SoftBusFree(newLane);
203         TRANS_LOGE(TRANS_SVC, "memcpy connInfo failed");
204         return SOFTBUS_MEM_ERR;
205     }
206     if (strcpy_s(newLane->pkgName, sizeof(newLane->pkgName), myData->pkgName) != EOK) {
207         SoftBusFree(newLane);
208         TRANS_LOGE(TRANS_SVC, "strcpy failed.");
209         return SOFTBUS_STRCPY_ERR;
210     }
211     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
212         SoftBusFree(newLane);
213         TRANS_LOGE(TRANS_SVC, "lock failed");
214         return SOFTBUS_LOCK_ERR;
215     }
216 
217     TransLaneInfo *laneItem = NULL;
218     LIST_FOR_EACH_ENTRY(laneItem, &(g_channelLaneList->list), TransLaneInfo, node) {
219         if (laneItem->channelId == transInfo->channelId && laneItem->channelType == transInfo->channelType) {
220             SoftBusFree(newLane);
221             (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
222             TRANS_LOGI(TRANS_SVC, "trans lane info has existed. channelId=%{public}d, channelType=%{public}d",
223                 transInfo->channelId, transInfo->channelType);
224             return SOFTBUS_ALREADY_EXISTED;
225         }
226     }
227     ListInit(&(newLane->node));
228     ListAdd(&(g_channelLaneList->list), &(newLane->node));
229     TRANS_LOGI(TRANS_CTRL, "add channelId=%{public}d", newLane->channelId);
230     g_channelLaneList->cnt++;
231     TRANS_LOGI(TRANS_SVC, "lane count is cnt=%{public}d", g_channelLaneList->cnt);
232     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
233     return SOFTBUS_OK;
234 }
235 
TransLaneMgrDelLane(int32_t channelId,int32_t channelType,bool isAsync)236 int32_t TransLaneMgrDelLane(int32_t channelId, int32_t channelType, bool isAsync)
237 {
238     if (g_channelLaneList == NULL) {
239         TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
240         return SOFTBUS_NO_INIT;
241     }
242     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
243         TRANS_LOGE(TRANS_SVC, "lock failed");
244         return SOFTBUS_LOCK_ERR;
245     }
246     TransLaneInfo *laneItem = NULL;
247     TransLaneInfo *next = NULL;
248     int32_t ret = SOFTBUS_TRANS_NODE_NOT_FOUND;
249     uint32_t laneHandle = 0;
250     bool isQos = false;
251     LIST_FOR_EACH_ENTRY_SAFE(laneItem, next, &(g_channelLaneList->list), TransLaneInfo, node) {
252         if (laneItem->channelId == channelId && laneItem->channelType == channelType) {
253             ListDelete(&(laneItem->node));
254             TRANS_LOGI(TRANS_CTRL, "delete channelId=%{public}d, channelType = %{public}d",
255                 laneItem->channelId, laneItem->channelType);
256             g_channelLaneList->cnt--;
257             laneHandle = laneItem->laneHandle;
258             if (laneItem->isQosLane) {
259                 isQos = true;
260             }
261             SoftBusFree(laneItem);
262             ret = SOFTBUS_OK;
263             break;
264         }
265     }
266     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
267     if (ret != SOFTBUS_OK) {
268         TRANS_LOGW(TRANS_SVC, "No lane to be is found. channelId=%{public}d.", channelId);
269         return ret;
270     }
271     if (isQos) {
272         TransFreeLaneByLaneHandle(laneHandle, isAsync);
273     } else {
274         LnnFreeLane(laneHandle);
275     }
276     return ret;
277 }
278 
TransLaneMgrDeathCallback(const char * pkgName,int32_t pid)279 void TransLaneMgrDeathCallback(const char *pkgName, int32_t pid)
280 {
281     (void)TransDeleteSocketChannelInfoByPid(pid);
282     if (pkgName == NULL || g_channelLaneList == NULL) {
283         TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
284         return;
285     }
286     char *anonymizePkgName = NULL;
287     Anonymize(pkgName, &anonymizePkgName);
288     TRANS_LOGW(TRANS_CTRL, "pkgName=%{public}s, pid=%{public}d", anonymizePkgName, pid);
289     AnonymizeFree(anonymizePkgName);
290     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
291         TRANS_LOGE(TRANS_SVC, "lock failed");
292         return;
293     }
294     TransLaneInfo *laneItem = NULL;
295     TransLaneInfo *next = NULL;
296     LIST_FOR_EACH_ENTRY_SAFE(laneItem, next, &(g_channelLaneList->list), TransLaneInfo, node) {
297         if ((strcmp(laneItem->pkgName, pkgName) == 0) && (laneItem->pid == pid)) {
298             ListDelete(&(laneItem->node));
299             g_channelLaneList->cnt--;
300             TRANS_LOGI(TRANS_SVC, "death del lane. channelId=%{public}d, channelType=%{public}d",
301                 laneItem->channelId, laneItem->channelType);
302             if (laneItem->isQosLane) {
303                 TransFreeLaneByLaneHandle(laneItem->laneHandle, true);
304             } else {
305                 LnnFreeLane(laneItem->laneHandle);
306             }
307             SoftBusFree(laneItem);
308         }
309     }
310     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
311     return;
312 }
313 
TransGetLaneHandleByChannelId(int32_t channelId,uint32_t * laneHandle)314 int32_t TransGetLaneHandleByChannelId(int32_t channelId, uint32_t *laneHandle)
315 {
316     if (g_channelLaneList == NULL || laneHandle == NULL) {
317         return SOFTBUS_INVALID_PARAM;
318     }
319     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
320         return SOFTBUS_LOCK_ERR;
321     }
322     TransLaneInfo *item = NULL;
323     LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
324         if (item->channelId == channelId) {
325             *laneHandle = item->laneHandle;
326             (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
327             return SOFTBUS_OK;
328         }
329     }
330     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
331     return SOFTBUS_TRANS_NODE_NOT_FOUND;
332 }
333 
TransGetLaneIdByChannelId(int32_t channelId,uint64_t * laneId)334 int32_t TransGetLaneIdByChannelId(int32_t channelId, uint64_t *laneId)
335 {
336     if (g_channelLaneList == NULL || laneId == NULL) {
337         return SOFTBUS_INVALID_PARAM;
338     }
339     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != 0) {
340         return SOFTBUS_LOCK_ERR;
341     }
342     TransLaneInfo *item = NULL;
343     LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
344         if (item->channelId == channelId) {
345             *laneId = item->laneConnInfo.laneId;
346             (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
347             return SOFTBUS_OK;
348         }
349     }
350     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
351     return SOFTBUS_NOT_FIND;
352 }
353 
TransGetChannelInfoByLaneHandle(uint32_t laneHandle,int32_t * channelId,int32_t * channelType)354 int32_t TransGetChannelInfoByLaneHandle(uint32_t laneHandle, int32_t *channelId, int32_t *channelType)
355 {
356     if (g_channelLaneList == NULL || channelId == NULL || channelType == NULL) {
357         return SOFTBUS_INVALID_PARAM;
358     }
359     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
360         return SOFTBUS_LOCK_ERR;
361     }
362     TransLaneInfo *item = NULL;
363     LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
364         if (item->laneHandle == laneHandle) {
365             *channelId = item->channelId;
366             *channelType = item->channelType;
367             (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
368             return SOFTBUS_OK;
369         }
370     }
371     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
372     return SOFTBUS_TRANS_NODE_NOT_FOUND;
373 }
374 
GetSocketWithChannelInfoBySession(const char * sessionName,int32_t sessionId)375 static SocketWithChannelInfo *GetSocketWithChannelInfoBySession(const char *sessionName, int32_t sessionId)
376 {
377     // need get lock before
378     SocketWithChannelInfo *socketItem = NULL;
379     LIST_FOR_EACH_ENTRY(socketItem, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
380         if (strcmp(socketItem->sessionName, sessionName) == 0 && socketItem->sessionId == sessionId) {
381             return socketItem;
382         }
383     }
384     return NULL;
385 }
386 
AnonymizeLogSessionNameWhenNotFound(const char * sessionName,int32_t sessionId)387 static void AnonymizeLogSessionNameWhenNotFound(const char *sessionName, int32_t sessionId)
388 {
389     char *tmpName = NULL;
390     Anonymize(sessionName, &tmpName);
391     TRANS_LOGE(
392         TRANS_SVC, "socket info not found. sessionName=%{public}s, sessionId=%{public}d", tmpName, sessionId);
393     AnonymizeFree(tmpName);
394 }
395 
TransAddSocketChannelInfo(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType,CoreSessionState state)396 int32_t TransAddSocketChannelInfo(
397     const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType, CoreSessionState state)
398 {
399     if (sessionName == NULL) {
400         TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null");
401         return SOFTBUS_TRANS_INVALID_SESSION_NAME;
402     }
403     if (sessionId <= 0) {
404         TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId);
405         return SOFTBUS_TRANS_INVALID_SESSION_ID;
406     }
407     TRANS_CHECK_AND_RETURN_RET_LOGE(
408         g_socketChannelList != NULL, SOFTBUS_NO_INIT, TRANS_INIT, "socket info manager hasn't init.");
409 
410     SocketWithChannelInfo *newSocket = (SocketWithChannelInfo *)SoftBusCalloc(sizeof(SocketWithChannelInfo));
411     TRANS_CHECK_AND_RETURN_RET_LOGE(newSocket != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "socket info calloc failed.");
412     if (strcpy_s(newSocket->sessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK) {
413         SoftBusFree(newSocket);
414         return SOFTBUS_STRCPY_ERR;
415     }
416     newSocket->sessionId = sessionId;
417     newSocket->channelId = channelId;
418     newSocket->channelType = channelType;
419     newSocket->state = state;
420     newSocket->laneHandle = INVALID_LANE_REQ_ID;
421     newSocket->isQosLane = false;
422     newSocket->isAsync = false;
423     int32_t tmpUid;
424     TransGetUidAndPid(sessionName, &tmpUid, &(newSocket->pid));
425 
426     if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
427         TRANS_LOGE(TRANS_SVC, "lock failed");
428         SoftBusFree(newSocket);
429         return SOFTBUS_LOCK_ERR;
430     }
431 
432     SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
433     if (socketItem != NULL) {
434         char *tmpName = NULL;
435         Anonymize(sessionName, &tmpName);
436         TRANS_LOGI(
437             TRANS_SVC, "socket lane info has existed. socketId=%{public}d, sessionName=%{public}s", sessionId, tmpName);
438         AnonymizeFree(tmpName);
439         SoftBusFree(newSocket);
440         (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
441         return SOFTBUS_OK;
442     }
443 
444     ListInit(&(newSocket->node));
445     ListAdd(&(g_socketChannelList->list), &(newSocket->node));
446     g_socketChannelList->cnt++;
447     TRANS_LOGI(TRANS_SVC, "socket lane count is cnt=%{public}d", g_socketChannelList->cnt);
448     (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
449     return SOFTBUS_OK;
450 }
451 
CheckParamIsValid(const char * sessionName,int32_t sessionId)452 static int32_t CheckParamIsValid(const char *sessionName, int32_t sessionId)
453 {
454     if (sessionName == NULL) {
455         TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null");
456         return SOFTBUS_TRANS_INVALID_SESSION_NAME;
457     }
458     if (sessionId <= 0) {
459         TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId);
460         return SOFTBUS_TRANS_INVALID_SESSION_ID;
461     }
462     return SOFTBUS_OK;
463 }
464 
TransUpdateSocketChannelInfoBySession(const char * sessionName,int32_t sessionId,int32_t channelId,int32_t channelType)465 int32_t TransUpdateSocketChannelInfoBySession(
466     const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType)
467 {
468     int32_t ret = CheckParamIsValid(sessionName, sessionId);
469     if (ret != SOFTBUS_OK) {
470         return ret;
471     }
472     if (g_socketChannelList == NULL) {
473         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
474         return SOFTBUS_NO_INIT;
475     }
476     if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
477         TRANS_LOGE(TRANS_SVC, "lock failed");
478         return SOFTBUS_LOCK_ERR;
479     }
480     SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
481     if (socketItem != NULL) {
482         socketItem->channelId = channelId;
483         socketItem->channelType = channelType;
484         (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
485         return SOFTBUS_OK;
486     }
487     (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
488     AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
489     return SOFTBUS_NOT_FIND;
490 }
491 
TransUpdateSocketChannelLaneInfoBySession(const char * sessionName,int32_t sessionId,uint32_t laneHandle,bool isQosLane,bool isAsync)492 int32_t TransUpdateSocketChannelLaneInfoBySession(
493     const char *sessionName, int32_t sessionId, uint32_t laneHandle, bool isQosLane, bool isAsync)
494 {
495     int32_t ret = CheckParamIsValid(sessionName, sessionId);
496     if (ret != SOFTBUS_OK) {
497         return ret;
498     }
499     if (g_socketChannelList == NULL) {
500         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
501         return SOFTBUS_NO_INIT;
502     }
503     if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
504         TRANS_LOGE(TRANS_SVC, "lock failed");
505         return SOFTBUS_LOCK_ERR;
506     }
507     SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
508     if (socketItem != NULL) {
509         socketItem->laneHandle = laneHandle;
510         socketItem->isQosLane = isQosLane;
511         socketItem->isAsync = isAsync;
512         (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
513         return SOFTBUS_OK;
514     }
515     (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
516     AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
517     return SOFTBUS_NOT_FIND;
518 }
519 
TransDeleteSocketChannelInfoBySession(const char * sessionName,int32_t sessionId)520 int32_t TransDeleteSocketChannelInfoBySession(const char *sessionName, int32_t sessionId)
521 {
522     int32_t ret = CheckParamIsValid(sessionName, sessionId);
523     if (ret != SOFTBUS_OK) {
524         return ret;
525     }
526     if (g_socketChannelList == NULL) {
527         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
528         return SOFTBUS_NO_INIT;
529     }
530     if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
531         TRANS_LOGE(TRANS_SVC, "lock failed");
532         return SOFTBUS_LOCK_ERR;
533     }
534     SocketWithChannelInfo *socketItem = NULL;
535     SocketWithChannelInfo *next = NULL;
536     LIST_FOR_EACH_ENTRY_SAFE(socketItem, next, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
537         if (strcmp(socketItem->sessionName, sessionName) == 0 && socketItem->sessionId == sessionId) {
538             ListDelete(&(socketItem->node));
539             g_socketChannelList->cnt--;
540             SoftBusFree(socketItem);
541             (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
542             char *tmpName = NULL;
543             Anonymize(sessionName, &tmpName);
544             TRANS_LOGI(TRANS_CTRL, "delete socket channel info, sessionName=%{public}s, sessionId=%{public}d",
545                 tmpName, sessionId);
546             AnonymizeFree(tmpName);
547             return SOFTBUS_OK;
548         }
549     }
550     (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
551     AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
552     return SOFTBUS_NOT_FIND;
553 }
554 
TransDeleteSocketChannelInfoByChannel(int32_t channelId,int32_t channelType)555 int32_t TransDeleteSocketChannelInfoByChannel(int32_t channelId, int32_t channelType)
556 {
557     if (g_socketChannelList == NULL) {
558         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
559         return SOFTBUS_NO_INIT;
560     }
561     if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
562         TRANS_LOGE(TRANS_SVC, "lock failed");
563         return SOFTBUS_LOCK_ERR;
564     }
565     SocketWithChannelInfo *socketItem = NULL;
566     SocketWithChannelInfo *next = NULL;
567     LIST_FOR_EACH_ENTRY_SAFE(socketItem, next, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
568         if (socketItem->channelId == channelId && socketItem->channelType == channelType) {
569             ListDelete(&(socketItem->node));
570             g_socketChannelList->cnt--;
571             SoftBusFree(socketItem);
572             (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
573             TRANS_LOGI(TRANS_CTRL, "delete socket channel info, channelId=%{public}d, channelType=%{public}d",
574                 channelId, channelType);
575             return SOFTBUS_OK;
576         }
577     }
578     (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
579     TRANS_LOGD(
580         TRANS_SVC, "socket info not found. channelId=%{public}d, channelType=%{public}d", channelId, channelType);
581     return SOFTBUS_NOT_FIND;
582 }
583 
TransDeleteSocketChannelInfoByPid(int32_t pid)584 int32_t TransDeleteSocketChannelInfoByPid(int32_t pid)
585 {
586     if (g_socketChannelList == NULL) {
587         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
588         return SOFTBUS_NO_INIT;
589     }
590     if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
591         TRANS_LOGE(TRANS_SVC, "lock failed");
592         return SOFTBUS_LOCK_ERR;
593     }
594     int32_t delCount = 0;
595     SocketWithChannelInfo *socketItem = NULL;
596     SocketWithChannelInfo *next = NULL;
597     LIST_FOR_EACH_ENTRY_SAFE(socketItem, next, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
598         if (socketItem->pid == pid) {
599             ListDelete(&(socketItem->node));
600             g_socketChannelList->cnt--;
601             SoftBusFree(socketItem);
602             delCount++;
603         }
604     }
605     (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
606     if (delCount > 0) {
607         TRANS_LOGI(TRANS_CTRL, "delete socket channel info, pid=%{public}d delete count=%{public}d",
608             pid, delCount);
609         return SOFTBUS_OK;
610     }
611     return SOFTBUS_NOT_FIND;
612 }
613 
TransSetSocketChannelStateBySession(const char * sessionName,int32_t sessionId,CoreSessionState state)614 int32_t TransSetSocketChannelStateBySession(const char *sessionName, int32_t sessionId, CoreSessionState state)
615 {
616     int32_t ret = CheckParamIsValid(sessionName, sessionId);
617     if (ret != SOFTBUS_OK) {
618         return ret;
619     }
620     if (g_socketChannelList == NULL) {
621         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
622         return SOFTBUS_NO_INIT;
623     }
624     if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
625         TRANS_LOGE(TRANS_SVC, "lock failed");
626         return SOFTBUS_LOCK_ERR;
627     }
628     SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId);
629     if (socketItem != NULL) {
630         socketItem->state = state;
631         (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
632         return SOFTBUS_OK;
633     }
634     (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
635     AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId);
636     return SOFTBUS_NOT_FIND;
637 }
638 
TransSetSocketChannelStateByChannel(int32_t channelId,int32_t channelType,CoreSessionState state)639 int32_t TransSetSocketChannelStateByChannel(int32_t channelId, int32_t channelType, CoreSessionState state)
640 {
641     if (g_socketChannelList == NULL) {
642         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
643         return SOFTBUS_NO_INIT;
644     }
645     if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) {
646         TRANS_LOGE(TRANS_SVC, "lock failed");
647         return SOFTBUS_LOCK_ERR;
648     }
649     SocketWithChannelInfo *socketItem = NULL;
650     LIST_FOR_EACH_ENTRY(socketItem, &(g_socketChannelList->list), SocketWithChannelInfo, node) {
651         if (socketItem->channelId == channelId && socketItem->channelType == channelType) {
652             socketItem->state = state;
653             (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
654             return SOFTBUS_OK;
655         }
656     }
657     (void)SoftBusMutexUnlock(&(g_socketChannelList->lock));
658     TRANS_LOGE(
659         TRANS_SVC, "socket info not found. channelId=%{public}d, channelType=%{public}d", channelId, channelType);
660     return SOFTBUS_NOT_FIND;
661 }
662 
TransGetSocketChannelStateBySession(const char * sessionName,int32_t sessionId,CoreSessionState * state)663 int32_t TransGetSocketChannelStateBySession(const char *sessionName, int32_t sessionId, CoreSessionState *state)
664 {
665     int32_t ret = CheckParamIsValid(sessionName, sessionId);
666     if (ret != SOFTBUS_OK) {
667         return ret;
668     }
669     if (g_socketChannelList == NULL) {
670         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
671         return SOFTBUS_NO_INIT;
672     }
673     if (state == NULL) {
674         TRANS_LOGE(TRANS_SVC, "Invaild param, state is null");
675         return SOFTBUS_INVALID_PARAM;
676     }
677     if (g_socketChannelList == NULL) {
678         TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init.");
679         return SOFTBUS_NO_INIT;
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         default:
812             return CONNECT_TYPE_MAX;
813     }
814 }
815 
TransGetConnectTypeByChannelId(int32_t channelId,ConnectType * connectType)816 int32_t TransGetConnectTypeByChannelId(int32_t channelId, ConnectType *connectType)
817 {
818     if (connectType == NULL) {
819         TRANS_LOGE(TRANS_INIT, "connectType is null");
820         return SOFTBUS_INVALID_PARAM;
821     }
822 
823     if (g_channelLaneList == NULL) {
824         TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
825         return SOFTBUS_INVALID_PARAM;
826     }
827 
828     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
829         TRANS_LOGE(TRANS_SVC, "lock failed");
830         return SOFTBUS_LOCK_ERR;
831     }
832 
833     TransLaneInfo *item = NULL;
834     LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
835         if (item->channelId != channelId) {
836             continue;
837         }
838 
839         ConnectType connType = ConvertLaneLinkTypeToConnectType(item->laneConnInfo.type);
840         if (connType >= CONNECT_TYPE_MAX) {
841             TRANS_LOGE(TRANS_SVC, "invalid connectType=%{public}d. linkType=%{public}d, channelId=%{public}d",
842                 connType, item->laneConnInfo.type, channelId);
843             (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
844             return SOFTBUS_CONN_INVALID_CONN_TYPE;
845         }
846 
847         *connectType = connType;
848         (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
849         return SOFTBUS_OK;
850     }
851     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
852     TRANS_LOGE(TRANS_SVC, "can not find connectType by channelId=%{public}d", channelId);
853     return SOFTBUS_TRANS_INVALID_CHANNEL_ID;
854 }
855 
TransGetTransLaneInfoByLaneHandle(uint32_t laneHandle,TransLaneInfo * laneInfo)856 int32_t TransGetTransLaneInfoByLaneHandle(uint32_t laneHandle, TransLaneInfo *laneInfo)
857 {
858     if (laneInfo == NULL) {
859         TRANS_LOGE(TRANS_INIT, "laneInfo is null");
860         return SOFTBUS_INVALID_PARAM;
861     }
862     if (g_channelLaneList == NULL) {
863         TRANS_LOGE(TRANS_INIT, "trans lane manager hasn't init.");
864         return SOFTBUS_INVALID_PARAM;
865     }
866 
867     if (SoftBusMutexLock(&(g_channelLaneList->lock)) != SOFTBUS_OK) {
868         TRANS_LOGE(TRANS_SVC, "lock failed");
869         return SOFTBUS_LOCK_ERR;
870     }
871     TransLaneInfo *item = NULL;
872     LIST_FOR_EACH_ENTRY(item, &(g_channelLaneList->list), TransLaneInfo, node) {
873         if (item->laneHandle == laneHandle) {
874             if (memcpy_s(laneInfo, sizeof(TransLaneInfo), item, sizeof(TransLaneInfo)) != EOK) {
875                 (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
876                 return SOFTBUS_MEM_ERR;
877             }
878             (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
879             return SOFTBUS_OK;
880         }
881     }
882     (void)SoftBusMutexUnlock(&(g_channelLaneList->lock));
883     TRANS_LOGE(TRANS_SVC, "can not find laneInfo by laneHandle=%{public}u", laneHandle);
884     return SOFTBUS_NOT_FIND;
885 }