1 /*
2 * Copyright (c) 2022 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 "lnn_trans_lane.h"
17
18 #include <securec.h>
19
20 #include "anonymizer.h"
21 #include "auth_interface.h"
22 #include "bus_center_manager.h"
23 #include "common_list.h"
24 #include "lnn_heartbeat_utils.h"
25 #include "lnn_distributed_net_ledger.h"
26 #include "lnn_lane.h"
27 #include "lnn_lane_common.h"
28 #include "lnn_lane_def.h"
29 #include "lnn_lane_interface.h"
30 #include "lnn_lane_link_p2p.h"
31 #include "lnn_lane_listener.h"
32 #include "lnn_lane_model.h"
33 #include "lnn_lane_reliability.h"
34 #include "lnn_lane_select.h"
35 #include "lnn_log.h"
36 #include "message_handler.h"
37 #include "softbus_adapter_mem.h"
38 #include "softbus_def.h"
39 #include "softbus_errcode.h"
40 #include "softbus_protocol_def.h"
41 #include "softbus_utils.h"
42 #include "wifi_direct_error_code.h"
43 #include "wifi_direct_manager.h"
44
45 #define LANE_REQ_ID_TYPE_SHIFT 28
46 #define DEFAULT_LINK_LATENCY 30000
47 #define DELAY_DESTROY_LANE_TIME 5000
48 #define WIFI_DIRECET_NUM_LIMIT 4
49
50 typedef enum {
51 MSG_TYPE_LANE_TRIGGER_LINK = 0,
52 MSG_TYPE_LANE_LINK_SUCCESS,
53 MSG_TYPE_LANE_LINK_FAIL,
54 MSG_TYPE_LANE_STATE_CHANGE,
55 MSG_TYPE_DELAY_DESTROY_LINK,
56 MSG_TYPE_LANE_DETECT_TIMEOUT,
57 MSG_TYPE_LANE_LINK_TIMEOUT,
58 MSG_TYPE_NOTIFY_FREE_LANE_RESULT,
59 } LaneMsgType;
60
61 typedef struct {
62 uint32_t cnt;
63 ListNode list;
64 } TransLaneList;
65
66 typedef enum {
67 BUILD_LINK_STATUS_BUILDING = 0,
68 BUILD_LINK_STATUS_FAIL,
69 BUILD_LINK_STATUS_SUCC,
70 BUILD_LINK_STATUS_BUTT,
71 } BuildLinkStatus;
72
73 typedef struct {
74 BuildLinkStatus status;
75 LaneLinkInfo linkInfo;
76 int32_t result;
77 } LinkStatusInfo;
78
79 typedef struct {
80 ListNode node;
81 uint32_t laneReqId;
82 int32_t pid;
83 char networkId[NETWORK_ID_BUF_LEN];
84 LanePreferredLinkList *linkList; /* Mem provided by laneSelect module */
85 uint32_t listNum;
86 uint32_t linkRetryIdx;
87 bool networkDelegate;
88 uint32_t bandWidth;
89 uint64_t triggerLinkTime;
90 uint64_t availableLinkTime;
91 char peerBleMac[MAX_MAC_LEN];
92 LaneTransType transType;
93 ProtocolType acceptableProtocols;
94 // OldInfo
95 int32_t psm;
96 bool p2pOnly;
97 LinkStatusInfo statusList[LANE_LINK_TYPE_BUTT];
98 bool isCompleted;
99 uint32_t actionAddr;
100 bool isSupportIpv6;
101 } LaneLinkNodeInfo;
102
103 typedef struct {
104 LaneState state;
105 char peerUdid[UDID_BUF_LEN];
106 LaneLinkInfo laneLinkInfo;
107 } StateNotifyInfo;
108
109 typedef struct {
110 int32_t reason;
111 LaneLinkType linkType;
112 } LinkFailInfo;
113
114 typedef struct {
115 uint32_t laneReqId;
116 LaneLinkType linkType;
117 } LaneTimeoutInfo;
118
119 static ListNode g_multiLinkList;
120 static SoftBusMutex g_transLaneMutex;
121 static TransLaneList *g_requestList = NULL;
122 static SoftBusHandler g_laneLoopHandler;
123 static ILaneIdStateListener *g_laneIdCallback = NULL;
124
Lock(void)125 static int32_t Lock(void)
126 {
127 return SoftBusMutexLock(&g_transLaneMutex);
128 }
129
Unlock(void)130 static void Unlock(void)
131 {
132 (void)SoftBusMutexUnlock(&g_transLaneMutex);
133 }
134
LnnLanePostMsgToHandler(int32_t msgType,uint64_t param1,uint64_t param2,void * obj,uint64_t delayMillis)135 static int32_t LnnLanePostMsgToHandler(int32_t msgType, uint64_t param1, uint64_t param2,
136 void *obj, uint64_t delayMillis)
137 {
138 SoftBusMessage *msg = (SoftBusMessage *)SoftBusCalloc(sizeof(SoftBusMessage));
139 if (msg == NULL) {
140 LNN_LOGE(LNN_LANE, "[transLane]create handler msg failed");
141 return SOFTBUS_MALLOC_ERR;
142 }
143 msg->what = msgType;
144 msg->arg1 = param1;
145 msg->arg2 = param2;
146 msg->handler = &g_laneLoopHandler;
147 msg->obj = obj;
148 if (delayMillis == 0) {
149 g_laneLoopHandler.looper->PostMessage(g_laneLoopHandler.looper, msg);
150 } else {
151 g_laneLoopHandler.looper->PostMessageDelay(g_laneLoopHandler.looper, msg, delayMillis);
152 }
153 return SOFTBUS_OK;
154 }
155
RemoveLinkTimeout(const SoftBusMessage * msg,void * data)156 static int32_t RemoveLinkTimeout(const SoftBusMessage *msg, void *data)
157 {
158 LaneTimeoutInfo *info = (LaneTimeoutInfo *)data;
159 if (msg->what != MSG_TYPE_LANE_LINK_TIMEOUT || msg->arg1 != info->laneReqId) {
160 return SOFTBUS_INVALID_PARAM;
161 }
162 if (info->linkType == LANE_LINK_TYPE_BUTT) {
163 LNN_LOGI(LNN_LANE, "remove build link timeout message succ. laneReqId=%{public}u, linkType=%{public}d",
164 info->laneReqId, info->linkType);
165 return SOFTBUS_OK;
166 }
167 if (msg->arg2 == info->linkType) {
168 LNN_LOGI(LNN_LANE, "remove build link timeout message succ. laneReqId=%{public}u, linkType=%{public}d",
169 info->laneReqId, info->linkType);
170 return SOFTBUS_OK;
171 }
172 return SOFTBUS_INVALID_PARAM;
173 }
174
RemoveLinkTimeoutMessage(uint32_t laneReqId,LaneLinkType linkType)175 static void RemoveLinkTimeoutMessage(uint32_t laneReqId, LaneLinkType linkType)
176 {
177 LNN_LOGI(LNN_LANE, "remove build link timeout message. laneReqId=%{public}u, linkType=%{public}d",
178 laneReqId, linkType);
179 LaneTimeoutInfo info = {
180 .laneReqId = laneReqId,
181 .linkType = linkType,
182 };
183 g_laneLoopHandler.looper->RemoveMessageCustom(g_laneLoopHandler.looper, &g_laneLoopHandler,
184 RemoveLinkTimeout, &info);
185 }
186
LinkSuccess(uint32_t laneReqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)187 static void LinkSuccess(uint32_t laneReqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
188 {
189 LNN_LOGI(LNN_LANE, "build link succ, laneReqId=%{public}u, link=%{public}d", laneReqId, linkType);
190 if (linkInfo == NULL) {
191 LNN_LOGE(LNN_LANE, "linkSuccess param invalid");
192 return;
193 }
194 RemoveLinkTimeoutMessage(laneReqId, linkType);
195 LaneLinkInfo *linkParam = (LaneLinkInfo *)SoftBusCalloc(sizeof(LaneLinkInfo));
196 if (linkParam == NULL) {
197 LNN_LOGE(LNN_LANE, "linkSuccess info malloc fail");
198 (void)LnnLanePostMsgToHandler(MSG_TYPE_LANE_LINK_FAIL, laneReqId, SOFTBUS_MALLOC_ERR, NULL, 0);
199 return;
200 }
201 if (memcpy_s(linkParam, sizeof(LaneLinkInfo), linkInfo, sizeof(LaneLinkInfo)) != EOK) {
202 LNN_LOGE(LNN_LANE, "linkParam memcpy fail, laneReqId=%{public}u", laneReqId);
203 SoftBusFree(linkParam);
204 (void)LnnLanePostMsgToHandler(MSG_TYPE_LANE_LINK_FAIL, laneReqId, SOFTBUS_MEM_ERR, NULL, 0);
205 return;
206 }
207 if (LnnLanePostMsgToHandler(MSG_TYPE_LANE_LINK_SUCCESS, laneReqId, linkType, linkParam, 0) != SOFTBUS_OK) {
208 LNN_LOGE(LNN_LANE, "post LaneLinkSuccess msg err, laneReqId=%{public}u", laneReqId);
209 SoftBusFree(linkParam);
210 }
211 }
212
LinkFail(uint32_t laneReqId,int32_t reason,LaneLinkType linkType)213 static void LinkFail(uint32_t laneReqId, int32_t reason, LaneLinkType linkType)
214 {
215 LNN_LOGE(LNN_LANE, "build link fail, laneReqId=%{public}u, link=%{public}d, reason=%{public}d",
216 laneReqId, linkType, reason);
217 RemoveLinkTimeoutMessage(laneReqId, linkType);
218 LinkFailInfo *failInfo = (LinkFailInfo *)SoftBusCalloc(sizeof(LinkFailInfo));
219 if (failInfo == NULL) {
220 LNN_LOGE(LNN_LANE, "failInfo malloc fail");
221 (void)LnnLanePostMsgToHandler(MSG_TYPE_LANE_LINK_FAIL, laneReqId, SOFTBUS_MALLOC_ERR, NULL, 0);
222 return;
223 }
224 failInfo->reason = reason;
225 failInfo->linkType = linkType;
226 if (LnnLanePostMsgToHandler(MSG_TYPE_LANE_LINK_FAIL, laneReqId, (uint64_t)reason, failInfo, 0) != SOFTBUS_OK) {
227 LNN_LOGE(LNN_LANE, "post lanelink fail msg err");
228 SoftBusFree(failInfo);
229 }
230 }
231
DeleteLaneLinkNode(uint32_t laneReqId)232 static void DeleteLaneLinkNode(uint32_t laneReqId)
233 {
234 if (Lock() != SOFTBUS_OK) {
235 LNN_LOGE(LNN_LANE, "get lock fail");
236 return;
237 }
238 LaneLinkNodeInfo *item = NULL;
239 LaneLinkNodeInfo *next = NULL;
240 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_multiLinkList, LaneLinkNodeInfo, node) {
241 if (item->laneReqId == laneReqId) {
242 ListDelete(&item->node);
243 SoftBusFree(item->linkList);
244 SoftBusFree(item);
245 break;
246 }
247 }
248 Unlock();
249 }
250
PostLinkTimeoutMessage(uint32_t laneReqId,LaneLinkType linkType,uint64_t delayMillis)251 static int32_t PostLinkTimeoutMessage(uint32_t laneReqId, LaneLinkType linkType, uint64_t delayMillis)
252 {
253 LNN_LOGI(LNN_LANE, "post build link timeout message, laneReqId=%{public}u, linkType=%{public}d",
254 laneReqId, linkType);
255 return LnnLanePostMsgToHandler(MSG_TYPE_LANE_LINK_TIMEOUT, laneReqId, linkType, NULL, delayMillis);
256 }
257
InitStatusList(LaneLinkNodeInfo * linkNode)258 static void InitStatusList(LaneLinkNodeInfo *linkNode)
259 {
260 for (uint32_t i = 0; i < LANE_LINK_TYPE_BUTT; i++) {
261 linkNode->statusList[i].status = BUILD_LINK_STATUS_BUTT;
262 linkNode->statusList[i].result = SOFTBUS_LANE_BUILD_LINK_FAIL;
263 (void)memset_s(&linkNode->statusList[i].linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo));
264 }
265 }
266
TriggerLink(uint32_t laneReqId,TransOption * request,LanePreferredLinkList * recommendLinkList)267 static int32_t TriggerLink(uint32_t laneReqId, TransOption *request,
268 LanePreferredLinkList *recommendLinkList)
269 {
270 LaneLinkNodeInfo *linkNode = (LaneLinkNodeInfo *)SoftBusCalloc(sizeof(LaneLinkNodeInfo));
271 if (linkNode == NULL) {
272 return SOFTBUS_MALLOC_ERR;
273 }
274 if (memcpy_s(linkNode->networkId, NETWORK_ID_BUF_LEN,
275 request->networkId, NETWORK_ID_BUF_LEN) != EOK) {
276 LNN_LOGE(LNN_LANE, "memcpy fail for networkId");
277 SoftBusFree(linkNode);
278 return SOFTBUS_MEM_ERR;
279 }
280 if (memcpy_s(linkNode->peerBleMac, MAX_MAC_LEN, request->peerBleMac, MAX_MAC_LEN) != EOK) {
281 LNN_LOGE(LNN_LANE, "memcpy fail for peerBleMac");
282 SoftBusFree(linkNode);
283 return SOFTBUS_MEM_ERR;
284 }
285 linkNode->psm = request->psm;
286 linkNode->transType = request->transType;
287 linkNode->laneReqId = laneReqId;
288 linkNode->linkRetryIdx = 0;
289 linkNode->listNum = recommendLinkList->linkTypeNum;
290 linkNode->linkList = recommendLinkList;
291 linkNode->pid = request->pid;
292 linkNode->networkDelegate = request->networkDelegate;
293 linkNode->p2pOnly = request->p2pOnly;
294 linkNode->acceptableProtocols = request->acceptableProtocols;
295 linkNode->bandWidth = 0;
296 linkNode->triggerLinkTime = SoftBusGetSysTimeMs();
297 linkNode->availableLinkTime = DEFAULT_LINK_LATENCY;
298 linkNode->isCompleted = false;
299 InitStatusList(linkNode);
300 ListInit(&linkNode->node);
301 if (Lock() != SOFTBUS_OK) {
302 LNN_LOGE(LNN_LANE, "get lock fail");
303 SoftBusFree(linkNode);
304 return SOFTBUS_LOCK_ERR;
305 }
306 ListTailInsert(&g_multiLinkList, &linkNode->node);
307 Unlock();
308 int32_t ret = LnnLanePostMsgToHandler(MSG_TYPE_LANE_TRIGGER_LINK, laneReqId, 0, NULL, 0);
309 if (ret != SOFTBUS_OK) {
310 DeleteLaneLinkNode(laneReqId);
311 return ret;
312 }
313 return SOFTBUS_OK;
314 }
315
CreateRequestNode(uint32_t laneReqId,const TransOption * option,const ILaneListener * listener)316 static TransReqInfo *CreateRequestNode(uint32_t laneReqId, const TransOption *option, const ILaneListener *listener)
317 {
318 TransReqInfo *newNode = (TransReqInfo *)SoftBusCalloc(sizeof(TransReqInfo));
319 if (newNode == NULL) {
320 LNN_LOGE(LNN_LANE, "malloc fail");
321 return NULL;
322 }
323 if (memcpy_s(&newNode->extraInfo.listener, sizeof(ILaneListener), listener, sizeof(ILaneListener)) != EOK) {
324 SoftBusFree(newNode);
325 return NULL;
326 }
327 if (memcpy_s(&newNode->extraInfo.info, sizeof(TransOption), option, sizeof(TransOption)) != EOK) {
328 SoftBusFree(newNode);
329 return NULL;
330 }
331 newNode->isWithQos = false;
332 newNode->isCanceled = false;
333 newNode->isNotified = false;
334 newNode->notifyFree = false;
335 newNode->hasNotifiedFree = false;
336 newNode->laneReqId = laneReqId;
337 newNode->extraInfo.isSupportIpv6 = option->isSupportIpv6;
338 ListInit(&newNode->node);
339 return newNode;
340 }
341
DeleteRequestNode(uint32_t laneReqId)342 static void DeleteRequestNode(uint32_t laneReqId)
343 {
344 if (Lock() != SOFTBUS_OK) {
345 LNN_LOGE(LNN_LANE, "get lock fail");
346 return;
347 }
348 TransReqInfo *item = NULL;
349 TransReqInfo *next = NULL;
350 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_requestList->list, TransReqInfo, node) {
351 if (item->laneReqId == laneReqId) {
352 ListDelete(&item->node);
353 SoftBusFree(item);
354 g_requestList->cnt--;
355 break;
356 }
357 }
358 Unlock();
359 }
360
CreateReqNodeWithQos(uint32_t laneReqId,const LaneAllocInfo * allocInfo,const LaneAllocListener * listener)361 static TransReqInfo *CreateReqNodeWithQos(uint32_t laneReqId, const LaneAllocInfo *allocInfo,
362 const LaneAllocListener *listener)
363 {
364 TransReqInfo *newNode = (TransReqInfo *)SoftBusCalloc(sizeof(TransReqInfo));
365 if (newNode == NULL) {
366 LNN_LOGE(LNN_LANE, "malloc fail");
367 return NULL;
368 }
369 if (memcpy_s(&newNode->listener, sizeof(LaneAllocListener), listener, sizeof(LaneAllocListener)) != EOK) {
370 LNN_LOGE(LNN_LANE, "memcpy fail for lane alloc listener");
371 SoftBusFree(newNode);
372 return NULL;
373 }
374 if (memcpy_s(&newNode->allocInfo, sizeof(LaneAllocInfo), allocInfo, sizeof(LaneAllocInfo)) != EOK) {
375 LNN_LOGE(LNN_LANE, "memcpy fail for lane alloc info");
376 SoftBusFree(newNode);
377 return NULL;
378 }
379 newNode->extraInfo.actionAddr = allocInfo->extendInfo.actionAddr;
380 newNode->extraInfo.isSupportIpv6 = allocInfo->extendInfo.isSupportIpv6;
381 newNode->laneReqId = laneReqId;
382 newNode->isWithQos = true;
383 newNode->isCanceled = false;
384 newNode->isNotified = false;
385 newNode->notifyFree = false;
386 newNode->hasNotifiedFree = false;
387 ListInit(&newNode->node);
388 return newNode;
389 }
390
TriggerLinkWithQos(uint32_t laneReqId,const LaneAllocInfo * allocInfo,LanePreferredLinkList * recommendLinkList)391 static int32_t TriggerLinkWithQos(uint32_t laneReqId, const LaneAllocInfo *allocInfo,
392 LanePreferredLinkList *recommendLinkList)
393 {
394 LaneLinkNodeInfo *linkNode = (LaneLinkNodeInfo *)SoftBusCalloc(sizeof(LaneLinkNodeInfo));
395 if (linkNode == NULL) {
396 return SOFTBUS_MALLOC_ERR;
397 }
398 if (memcpy_s(linkNode->networkId, NETWORK_ID_BUF_LEN, allocInfo->networkId, NETWORK_ID_BUF_LEN) != EOK) {
399 LNN_LOGE(LNN_LANE, "memcpy fail for networkId");
400 SoftBusFree(linkNode);
401 return SOFTBUS_MEM_ERR;
402 }
403 if (memcpy_s(linkNode->peerBleMac, MAX_MAC_LEN, allocInfo->extendInfo.peerBleMac, MAX_MAC_LEN) != EOK) {
404 LNN_LOGE(LNN_LANE, "memcpy fail for peerBleMac");
405 SoftBusFree(linkNode);
406 return SOFTBUS_MEM_ERR;
407 }
408 linkNode->transType = allocInfo->transType;
409 linkNode->laneReqId = laneReqId;
410 linkNode->linkRetryIdx = 0;
411 linkNode->listNum = recommendLinkList->linkTypeNum;
412 linkNode->linkList = recommendLinkList;
413 linkNode->pid = allocInfo->pid;
414 linkNode->networkDelegate = allocInfo->extendInfo.networkDelegate;
415 linkNode->acceptableProtocols = allocInfo->acceptableProtocols;
416 linkNode->actionAddr = allocInfo->extendInfo.actionAddr;
417 linkNode->isSupportIpv6 = allocInfo->extendInfo.isSupportIpv6;
418 linkNode->bandWidth = allocInfo->qosRequire.minBW;
419 linkNode->triggerLinkTime = SoftBusGetSysTimeMs();
420 linkNode->availableLinkTime = allocInfo->qosRequire.maxLaneLatency != 0 ?
421 allocInfo->qosRequire.maxLaneLatency : DEFAULT_LINK_LATENCY;
422 linkNode->isCompleted = false;
423 InitStatusList(linkNode);
424 ListInit(&linkNode->node);
425 if (Lock() != SOFTBUS_OK) {
426 LNN_LOGE(LNN_LANE, "get lock fail");
427 SoftBusFree(linkNode);
428 return SOFTBUS_LOCK_ERR;
429 }
430 ListTailInsert(&g_multiLinkList, &linkNode->node);
431 Unlock();
432 int32_t ret = LnnLanePostMsgToHandler(MSG_TYPE_LANE_TRIGGER_LINK, laneReqId, 0, NULL, 0);
433 if (ret != SOFTBUS_OK) {
434 DeleteLaneLinkNode(laneReqId);
435 return ret;
436 }
437 return SOFTBUS_OK;
438 }
439
StartTriggerLink(uint32_t laneReqId,const LaneAllocInfo * allocInfo,const LaneAllocListener * listener,LanePreferredLinkList * recommendLinkList)440 static int32_t StartTriggerLink(uint32_t laneReqId, const LaneAllocInfo *allocInfo, const LaneAllocListener *listener,
441 LanePreferredLinkList *recommendLinkList)
442 {
443 TransReqInfo *newItem = CreateReqNodeWithQos(laneReqId, allocInfo, listener);
444 if (newItem == NULL) {
445 return SOFTBUS_MEM_ERR;
446 }
447 if (Lock() != SOFTBUS_OK) {
448 LNN_LOGE(LNN_LANE, "get lock fail");
449 SoftBusFree(newItem);
450 return SOFTBUS_LOCK_ERR;
451 }
452 ListTailInsert(&g_requestList->list, &newItem->node);
453 g_requestList->cnt++;
454 Unlock();
455 int32_t ret = TriggerLinkWithQos(laneReqId, allocInfo, recommendLinkList);
456 if (ret != SOFTBUS_OK) {
457 DeleteRequestNode(laneReqId);
458 return ret;
459 }
460 return SOFTBUS_OK;
461 }
462
AllocValidLane(uint32_t laneReqId,uint64_t allocLaneId,const LaneAllocInfo * allocInfo,const LaneAllocListener * listener)463 static int32_t AllocValidLane(uint32_t laneReqId, uint64_t allocLaneId, const LaneAllocInfo *allocInfo,
464 const LaneAllocListener *listener)
465 {
466 LaneSelectParam selectParam;
467 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
468 selectParam.transType = allocInfo->transType;
469 selectParam.qosRequire = allocInfo->qosRequire;
470 selectParam.allocedLaneId = allocLaneId;
471 LanePreferredLinkList *recommendLinkList = (LanePreferredLinkList *)SoftBusMalloc(sizeof(LanePreferredLinkList));
472 if (recommendLinkList == NULL) {
473 LNN_LOGE(LNN_LANE, "recommendLinkList malloc fail");
474 return SOFTBUS_MALLOC_ERR;
475 }
476 recommendLinkList->linkTypeNum = 0;
477 int32_t ret = SelectExpectLanesByQos((const char *)allocInfo->networkId, &selectParam, recommendLinkList);
478 if (ret != SOFTBUS_OK) {
479 SoftBusFree(recommendLinkList);
480 LNN_LOGE(LNN_LANE, "selectExpectLanesByQos fail, laneReqId=%{public}u", laneReqId);
481 return ret;
482 }
483 if (recommendLinkList->linkTypeNum == 0) {
484 SoftBusFree(recommendLinkList);
485 LNN_LOGE(LNN_LANE, "no available link resources, laneReqId=%{public}u", laneReqId);
486 return SOFTBUS_LANE_NO_AVAILABLE_LINK;
487 }
488 for (uint32_t i = 0; i < recommendLinkList->linkTypeNum; i++) {
489 LNN_LOGI(LNN_LANE, "expect linklist nums=%{public}u, priority=%{public}u, link=%{public}u",
490 recommendLinkList->linkTypeNum, i, recommendLinkList->linkType[i]);
491 }
492 ret = StartTriggerLink(laneReqId, allocInfo, listener, recommendLinkList);
493 if (ret != SOFTBUS_OK) {
494 SoftBusFree(recommendLinkList);
495 LNN_LOGE(LNN_LANE, "trigger link fail, laneReqId=%{public}u", laneReqId);
496 return ret;
497 }
498 return SOFTBUS_OK;
499 }
500
DumpInputLinkList(const LanePreferredLinkList * linkInfo)501 static void DumpInputLinkList(const LanePreferredLinkList *linkInfo)
502 {
503 for (uint32_t i = 0; i < linkInfo->linkTypeNum; i++) {
504 LNN_LOGD(LNN_LANE, "priority=%{public}u, linkType=%{public}d", i, linkInfo->linkType[i]);
505 }
506 }
507
LaneAllocInfoConvert(const LaneAllocInfoExt * allocInfoExt,LaneAllocInfo * allocInfo)508 static int32_t LaneAllocInfoConvert(const LaneAllocInfoExt *allocInfoExt, LaneAllocInfo *allocInfo)
509 {
510 allocInfo->type = allocInfoExt->type;
511 allocInfo->transType = allocInfoExt->commInfo.transType;
512 if (strcpy_s(allocInfo->networkId, NETWORK_ID_BUF_LEN, allocInfoExt->commInfo.networkId) != EOK) {
513 return SOFTBUS_STRCPY_ERR;
514 }
515 return SOFTBUS_OK;
516 }
517
BuildTargetLink(uint32_t laneHandle,const LaneAllocInfoExt * allocInfoExt,const LaneAllocListener * listener)518 static int32_t BuildTargetLink(uint32_t laneHandle, const LaneAllocInfoExt *allocInfoExt,
519 const LaneAllocListener *listener)
520 {
521 LanePreferredLinkList *linkList = (LanePreferredLinkList *)SoftBusCalloc(sizeof(LanePreferredLinkList));
522 if (linkList == NULL) {
523 return SOFTBUS_MALLOC_ERR;
524 }
525 if (memcpy_s(linkList, sizeof(LanePreferredLinkList), &allocInfoExt->linkList,
526 sizeof(LanePreferredLinkList)) != EOK) {
527 SoftBusFree(linkList);
528 return SOFTBUS_MEM_ERR;
529 }
530 LaneAllocInfo allocInfo;
531 (void)memset_s(&allocInfo, sizeof(allocInfo), 0, sizeof(allocInfo));
532 int32_t ret = LaneAllocInfoConvert(allocInfoExt, &allocInfo);
533 if (ret != SOFTBUS_OK) {
534 SoftBusFree(linkList);
535 return ret;
536 }
537 TransReqInfo *newItem = CreateReqNodeWithQos(laneHandle, &allocInfo, listener);
538 if (newItem == NULL) {
539 SoftBusFree(linkList);
540 return SOFTBUS_MEM_ERR;
541 }
542 if (Lock() != SOFTBUS_OK) {
543 LNN_LOGE(LNN_LANE, "get lock fail");
544 SoftBusFree(newItem);
545 SoftBusFree(linkList);
546 return SOFTBUS_LOCK_ERR;
547 }
548 ListTailInsert(&g_requestList->list, &newItem->node);
549 g_requestList->cnt++;
550 Unlock();
551 ret = TriggerLinkWithQos(laneHandle, &allocInfo, linkList);
552 if (ret != SOFTBUS_OK) {
553 SoftBusFree(linkList);
554 DeleteRequestNode(laneHandle);
555 return ret;
556 }
557 return SOFTBUS_OK;
558 }
559
AllocTargetLane(uint32_t laneHandle,const LaneAllocInfoExt * allocInfo,const LaneAllocListener * listener)560 static int32_t AllocTargetLane(uint32_t laneHandle, const LaneAllocInfoExt *allocInfo,
561 const LaneAllocListener *listener)
562 {
563 if (laneHandle == INVALID_LANE_REQ_ID || allocInfo == NULL ||
564 allocInfo->type != LANE_TYPE_TRANS || listener == NULL) {
565 LNN_LOGE(LNN_LANE, "alloc targetLane param invalid");
566 return SOFTBUS_INVALID_PARAM;
567 }
568 if (allocInfo->linkList.linkTypeNum >= LANE_LINK_TYPE_BUTT) {
569 return SOFTBUS_INVALID_PARAM;
570 }
571 DumpInputLinkList((const LanePreferredLinkList *)&allocInfo->linkList);
572 return BuildTargetLink(laneHandle, allocInfo, listener);
573 }
574
SpecifiedLinkConvert(const char * networkId,LaneSpecifiedLink link,LanePreferredLinkList * preferLink)575 static int32_t SpecifiedLinkConvert(const char *networkId, LaneSpecifiedLink link, LanePreferredLinkList *preferLink)
576 {
577 LaneLinkType optionalLink[LANE_LINK_TYPE_BUTT];
578 (void)memset_s(optionalLink, sizeof(optionalLink), 0, sizeof(optionalLink));
579 uint32_t linkNum = 0;
580 switch (link) {
581 case LANE_LINK_TYPE_WIFI_WLAN:
582 optionalLink[linkNum++] = LANE_WLAN_5G;
583 optionalLink[linkNum++] = LANE_WLAN_2P4G;
584 break;
585 case LANE_LINK_TYPE_WIFI_P2P:
586 optionalLink[linkNum++] = LANE_P2P;
587 break;
588 case LANE_LINK_TYPE_BR:
589 optionalLink[linkNum++] = LANE_BR;
590 break;
591 case LANE_LINK_TYPE_COC_DIRECT:
592 optionalLink[linkNum++] = LANE_COC_DIRECT;
593 break;
594 case LANE_LINK_TYPE_BLE_DIRECT:
595 optionalLink[linkNum++] = LANE_BLE_DIRECT;
596 break;
597 case LANE_LINK_TYPE_HML:
598 optionalLink[linkNum++] = LANE_HML;
599 break;
600 default:
601 LNN_LOGE(LNN_LANE, "unexpected link=%{public}d", link);
602 break;
603 }
604 if (linkNum == 0) {
605 return SOFTBUS_LANE_NO_AVAILABLE_LINK;
606 }
607 uint32_t resNum = 0;
608 for (uint32_t i = 0; i < linkNum; i++) {
609 if (LaneCapCheck(networkId, optionalLink[i]) != SOFTBUS_OK) {
610 LNN_LOGE(LNN_LANE, "SpecifiedLink capcheck fail, linkType=%{public}d", optionalLink[i]);
611 continue;
612 }
613 preferLink->linkType[resNum] = optionalLink[i];
614 resNum++;
615 }
616 if (resNum == 0) {
617 return GetErrCodeOfLink(networkId, optionalLink[0]);
618 }
619 preferLink->linkTypeNum = resNum;
620 return SOFTBUS_OK;
621 }
622
ProcessSpecifiedLink(uint32_t laneHandle,const LaneAllocInfo * allocInfo,const LaneAllocListener * listener)623 static int32_t ProcessSpecifiedLink(uint32_t laneHandle, const LaneAllocInfo *allocInfo,
624 const LaneAllocListener *listener)
625 {
626 LaneAllocInfoExt info;
627 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
628 if (SpecifiedLinkConvert((const char *)allocInfo->networkId, allocInfo->extendInfo.linkType, &info.linkList)
629 != SOFTBUS_OK) {
630 return SOFTBUS_LANE_SELECT_FAIL;
631 }
632 info.type = allocInfo->type;
633 info.commInfo.transType = allocInfo->transType;
634 if (strcpy_s(info.commInfo.networkId, NETWORK_ID_BUF_LEN, allocInfo->networkId) != EOK) {
635 return SOFTBUS_STRCPY_ERR;
636 }
637 return BuildTargetLink(laneHandle, &info, listener);
638 }
639
AllocLaneByQos(uint32_t laneReqId,const LaneAllocInfo * allocInfo,const LaneAllocListener * listener)640 static int32_t AllocLaneByQos(uint32_t laneReqId, const LaneAllocInfo *allocInfo, const LaneAllocListener *listener)
641 {
642 if (laneReqId == INVALID_LANE_REQ_ID || allocInfo == NULL ||
643 allocInfo->type != LANE_TYPE_TRANS || listener == NULL) {
644 LNN_LOGE(LNN_LANE, "allocLane param invalid");
645 return SOFTBUS_INVALID_PARAM;
646 }
647 if (allocInfo->extendInfo.isSpecifiedLink) {
648 LNN_LOGW(LNN_LANE, "process specifiedLink, linkType=%{public}d", allocInfo->extendInfo.linkType);
649 return ProcessSpecifiedLink(laneReqId, allocInfo, listener);
650 }
651 int32_t ret = AllocValidLane(laneReqId, INVALID_LANE_ID, allocInfo, listener);
652 if (ret != SOFTBUS_OK) {
653 LNN_LOGE(LNN_LANE, "alloc valid lane fail, laneReqId=%{public}u", laneReqId);
654 FreeLaneReqId(laneReqId);
655 return ret;
656 }
657 return SOFTBUS_OK;
658 }
659
ReallocLaneByQos(uint32_t laneReqId,uint64_t laneId,const LaneAllocInfo * allocInfo,const LaneAllocListener * listener)660 static int32_t ReallocLaneByQos(uint32_t laneReqId, uint64_t laneId, const LaneAllocInfo *allocInfo,
661 const LaneAllocListener *listener)
662 {
663 if (laneReqId == INVALID_LANE_REQ_ID || allocInfo == NULL || allocInfo->type != LANE_TYPE_TRANS ||
664 listener == NULL || laneId == INVALID_LANE_ID) {
665 LNN_LOGE(LNN_LANE, "reallocLane param invalid");
666 return SOFTBUS_INVALID_PARAM;
667 }
668 int32_t ret = AllocValidLane(laneReqId, laneId, allocInfo, listener);
669 if (ret != SOFTBUS_OK) {
670 LNN_LOGE(LNN_LANE, "alloc valid lane fail, laneReqId=%{public}u", laneReqId);
671 FreeLaneReqId(laneReqId);
672 return ret;
673 }
674 return SOFTBUS_OK;
675 }
676
AllocRawLane(uint32_t laneHandle,const RawLaneAllocInfo * allocInfo,const LaneAllocListener * listener)677 static int32_t AllocRawLane(uint32_t laneHandle, const RawLaneAllocInfo *allocInfo, const LaneAllocListener *listener)
678 {
679 if ((allocInfo == NULL) || (allocInfo->type != LANE_TYPE_TRANS) || (listener == NULL)) {
680 LNN_LOGE(LNN_LANE, "allocLane param invalid");
681 return SOFTBUS_INVALID_PARAM;
682 }
683 LNN_LOGI(LNN_LANE, "get raw lane info, actionAddr=%{public}u", allocInfo->actionAddr);
684 LaneSelectParam selectParam;
685 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
686 selectParam.transType = allocInfo->transType;
687 selectParam.qosRequire = allocInfo->qosRequire;
688 selectParam.allocedLaneId = INVALID_LANE_ID;
689 LanePreferredLinkList *recommendLinkList = (LanePreferredLinkList *)SoftBusCalloc(sizeof(LanePreferredLinkList));
690 if (recommendLinkList == NULL) {
691 LNN_LOGE(LNN_LANE, "recommendLinkList malloc fail");
692 return SOFTBUS_MALLOC_ERR;
693 }
694 recommendLinkList->linkTypeNum = 1;
695 recommendLinkList->linkType[0] = LANE_HML_RAW;
696 LaneAllocInfo laneAllocInfo;
697 (void)memset_s(&laneAllocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo));
698 laneAllocInfo.type = allocInfo->type;
699 laneAllocInfo.transType = allocInfo->transType;
700 laneAllocInfo.qosRequire = allocInfo->qosRequire;
701 laneAllocInfo.extendInfo.actionAddr = allocInfo->actionAddr;
702 laneAllocInfo.extendInfo.isSupportIpv6 = true;
703 int32_t ret = StartTriggerLink(laneHandle, &laneAllocInfo, listener, recommendLinkList);
704 if (ret != SOFTBUS_OK) {
705 SoftBusFree(recommendLinkList);
706 LNN_LOGE(LNN_LANE, "trigger link fail, laneHandle=%{public}u", laneHandle);
707 return ret;
708 }
709 return SOFTBUS_OK;
710 }
711
Alloc(uint32_t laneReqId,const LaneRequestOption * request,const ILaneListener * listener)712 static int32_t Alloc(uint32_t laneReqId, const LaneRequestOption *request, const ILaneListener *listener)
713 {
714 if ((request == NULL) || (request->type != LANE_TYPE_TRANS)) {
715 return SOFTBUS_INVALID_PARAM;
716 }
717 TransOption *transRequest = (TransOption *)&request->requestInfo.trans;
718 LaneSelectParam selectParam;
719 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
720 selectParam.transType = transRequest->transType;
721 selectParam.expectedBw = transRequest->expectedBw;
722 if (memcpy_s(&selectParam.list, sizeof(selectParam.list),
723 &transRequest->expectedLink, sizeof(transRequest->expectedLink)) != EOK) {
724 return SOFTBUS_MEM_ERR;
725 }
726 LanePreferredLinkList *recommendLinkList = (LanePreferredLinkList *)SoftBusCalloc(sizeof(LanePreferredLinkList));
727 if (recommendLinkList == NULL) {
728 return SOFTBUS_MALLOC_ERR;
729 }
730 uint32_t listNum = 0;
731 int32_t ret = SelectLane((const char *)transRequest->networkId, &selectParam, recommendLinkList, &listNum);
732 if (ret != SOFTBUS_OK) {
733 SoftBusFree(recommendLinkList);
734 return ret;
735 }
736 if (recommendLinkList->linkTypeNum == 0) {
737 LNN_LOGE(LNN_LANE, "no available link to request, laneReqId=%{public}u", laneReqId);
738 SoftBusFree(recommendLinkList);
739 return SOFTBUS_LANE_NO_AVAILABLE_LINK;
740 }
741 LNN_LOGI(LNN_LANE, "select lane link success, linkNum=%{public}d, laneReqId=%{public}u", listNum, laneReqId);
742 TransReqInfo *newItem = CreateRequestNode(laneReqId, transRequest, listener);
743 if (newItem == NULL) {
744 SoftBusFree(recommendLinkList);
745 return SOFTBUS_MEM_ERR;
746 }
747 if (Lock() != SOFTBUS_OK) {
748 SoftBusFree(newItem);
749 SoftBusFree(recommendLinkList);
750 return SOFTBUS_LOCK_ERR;
751 }
752 ListTailInsert(&g_requestList->list, &newItem->node);
753 g_requestList->cnt++;
754 Unlock();
755 ret = TriggerLink(laneReqId, transRequest, recommendLinkList);
756 if (ret != SOFTBUS_OK) {
757 SoftBusFree(recommendLinkList);
758 DeleteRequestNode(laneReqId);
759 return ret;
760 }
761 return SOFTBUS_OK;
762 }
763
ParseLaneTypeByLaneReqId(uint32_t laneReqId,LaneType * laneType)764 static int32_t ParseLaneTypeByLaneReqId(uint32_t laneReqId, LaneType *laneType)
765 {
766 if (laneReqId == INVALID_LANE_REQ_ID || laneType == NULL) {
767 LNN_LOGE(LNN_LANE, "[ParseLaneType]invalid param");
768 return SOFTBUS_INVALID_PARAM;
769 }
770 *laneType = (LaneType)(laneReqId >> LANE_REQ_ID_TYPE_SHIFT);
771 return SOFTBUS_OK;
772 }
773
NotifyFreeLaneResult(uint32_t laneReqId,int32_t errCode)774 void NotifyFreeLaneResult(uint32_t laneReqId, int32_t errCode)
775 {
776 TransReqInfo reqInfo;
777 (void)memset_s(&reqInfo, sizeof(TransReqInfo), 0, sizeof(TransReqInfo));
778 if (GetTransReqInfoByLaneReqId(laneReqId, &reqInfo) != SOFTBUS_OK) {
779 LNN_LOGI(LNN_LANE, "get trans req info fail, laneReqId=%{public}d", laneReqId);
780 return;
781 }
782 if (!reqInfo.notifyFree) {
783 LNN_LOGI(LNN_LANE, "free unused link no notify, laneReqId=%{public}u, errCode=%{public}d",
784 laneReqId, errCode);
785 return;
786 }
787 LNN_LOGI(LNN_LANE, "notify free lane result, laneReqId=%{public}d, errCode=%{public}d",
788 laneReqId, errCode);
789 DelLaneResourceByLaneId(reqInfo.laneId, false);
790 if (reqInfo.isWithQos && !reqInfo.hasNotifiedFree) {
791 if (errCode == SOFTBUS_OK && reqInfo.listener.onLaneFreeSuccess != NULL) {
792 reqInfo.listener.onLaneFreeSuccess(laneReqId);
793 } else if (errCode != SOFTBUS_OK && reqInfo.listener.onLaneFreeFail != NULL) {
794 reqInfo.listener.onLaneFreeFail(laneReqId, errCode);
795 }
796 }
797 DeleteRequestNode(laneReqId);
798 FreeLaneReqId(laneReqId);
799 }
800
PostNotifyFreeLaneResult(uint32_t laneReqId,int32_t errCode,uint64_t delayMillis)801 static int32_t PostNotifyFreeLaneResult(uint32_t laneReqId, int32_t errCode, uint64_t delayMillis)
802 {
803 LNN_LOGI(LNN_LANE, "post notify free lane result message, laneReqId=%{public}u, errCode=%{public}d",
804 laneReqId, errCode);
805 return LnnLanePostMsgToHandler(MSG_TYPE_NOTIFY_FREE_LANE_RESULT, laneReqId, errCode, NULL, delayMillis);
806 }
807
FreeLaneLink(uint32_t laneReqId,uint64_t laneId)808 static int32_t FreeLaneLink(uint32_t laneReqId, uint64_t laneId)
809 {
810 LaneResource resourceItem;
811 (void)memset_s(&resourceItem, sizeof(LaneResource), 0, sizeof(LaneResource));
812 if (FindLaneResourceByLaneId(laneId, &resourceItem) != SOFTBUS_OK) {
813 return PostNotifyFreeLaneResult(laneReqId, SOFTBUS_OK, 0);
814 }
815 if (resourceItem.link.type == LANE_HML_RAW) {
816 LNN_LOGI(LNN_LANE, "del flag for raw hml laneReqId=%{public}u", laneReqId);
817 (void)RemoveAuthSessionServer(resourceItem.link.linkInfo.rawWifiDirect.peerIp);
818 }
819 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
820 if (LnnGetNetworkIdByUdid(resourceItem.link.peerUdid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
821 LNN_LOGE(LNN_LANE, "get networkId fail");
822 }
823 return DestroyLink(networkId, laneReqId, resourceItem.link.type);
824 }
825
CancelLane(uint32_t laneReqId)826 static int32_t CancelLane(uint32_t laneReqId)
827 {
828 if (Lock() != SOFTBUS_OK) {
829 LNN_LOGE(LNN_LANE, "get lock fail");
830 return SOFTBUS_LOCK_ERR;
831 }
832 TransReqInfo *item = NULL;
833 TransReqInfo *next = NULL;
834 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_requestList->list, TransReqInfo, node) {
835 if (item->isWithQos && item->laneReqId == laneReqId) {
836 if (item->isNotified) {
837 Unlock();
838 LNN_LOGE(LNN_LANE, "cancel lane fail, lane result has notified, laneReqId=%{public}u", laneReqId);
839 return SOFTBUS_INVALID_PARAM;
840 }
841 item->isCanceled = true;
842 Unlock();
843 LnnCancelWifiDirect(laneReqId);
844 LNN_LOGI(LNN_LANE, "cancel lane succ, laneReqId=%{public}u", laneReqId);
845 return SOFTBUS_OK;
846 }
847 }
848 Unlock();
849 LNN_LOGE(LNN_LANE, "cancel lane fail, lane reqinfo not find, laneReqId=%{public}u", laneReqId);
850 return SOFTBUS_LANE_NOT_FOUND;
851 }
852
UpdateReqListLaneId(uint64_t oldLaneId,uint64_t newLaneId)853 int32_t UpdateReqListLaneId(uint64_t oldLaneId, uint64_t newLaneId)
854 {
855 if (Lock() != SOFTBUS_OK) {
856 LNN_LOGE(LNN_LANE, "get lock fail");
857 return SOFTBUS_LOCK_ERR;
858 }
859 TransReqInfo *item = NULL;
860 LIST_FOR_EACH_ENTRY(item, &g_requestList->list, TransReqInfo, node) {
861 if (item->laneId == oldLaneId) {
862 item->laneId = newLaneId;
863 LNN_LOGI(LNN_LANE, "update newLaneId=%{public}" PRIu64 "oldLaneId=%{public}" PRIu64,
864 newLaneId, oldLaneId);
865 Unlock();
866 return SOFTBUS_OK;
867 }
868 }
869 Unlock();
870 return SOFTBUS_NOT_FIND;
871 }
872
GetAuthType(const char * peerNetWorkId)873 static bool GetAuthType(const char *peerNetWorkId)
874 {
875 int32_t value = 0;
876 int32_t ret = LnnGetRemoteNumInfo(peerNetWorkId, NUM_KEY_META_NODE, &value);
877 if (ret != SOFTBUS_OK) {
878 LNN_LOGE(LNN_LANE, "fail, ret=%{public}d", ret);
879 return false;
880 }
881 LNN_LOGD(LNN_LANE, "success, value=%{public}d", value);
882 return ((1 << ONLINE_HICHAIN) == value);
883 }
884
CheckLinkConflict(const char * peerUdid,LaneLinkType linkType)885 static int32_t CheckLinkConflict(const char* peerUdid, LaneLinkType linkType)
886 {
887 if (linkType != LANE_HML) {
888 return SOFTBUS_OK;
889 }
890 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
891 if (LnnGetNetworkIdByUdid(peerUdid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
892 LNN_LOGE(LNN_LANE, "get networkId by uuid fail");
893 return SOFTBUS_AUTH_GET_BR_CONN_INFO_FAIL;
894 }
895 int32_t conflictErr = GetWifiDirectManager()->prejudgeAvailability(networkId, WIFI_DIRECT_LINK_TYPE_HML);
896 if (conflictErr != SOFTBUS_OK) {
897 LNN_LOGE(LNN_LANE, "link=%{public}d conflict=%{public}d, cancel delay free lane", LANE_HML, conflictErr);
898 return conflictErr;
899 }
900 conflictErr = GetWifiDirectManager()->prejudgeAvailability(networkId, WIFI_DIRECT_LINK_TYPE_P2P);
901 if (conflictErr != SOFTBUS_OK) {
902 LNN_LOGE(LNN_LANE, "link=%{public}d conflict=%{public}d, cancel delay free lane", LANE_P2P, conflictErr);
903 return conflictErr;
904 }
905 return SOFTBUS_OK;
906 }
907
IsNeedDelayFreeLane(uint32_t laneReqId,uint64_t laneId,bool * isDelayFree)908 static void IsNeedDelayFreeLane(uint32_t laneReqId, uint64_t laneId, bool *isDelayFree)
909 {
910 LaneResource resourceItem;
911 (void)memset_s(&resourceItem, sizeof(LaneResource), 0, sizeof(LaneResource));
912 if (FindLaneResourceByLaneId(laneId, &resourceItem) != SOFTBUS_OK) {
913 *isDelayFree = false;
914 return;
915 }
916 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
917 if (LnnConvertDlId(resourceItem.link.peerUdid, CATEGORY_UDID, CATEGORY_NETWORK_ID,
918 networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
919 LNN_LOGE(LNN_LANE, "LnnConvertDlId fail");
920 *isDelayFree = false;
921 return;
922 }
923 bool isHichain = GetAuthType(networkId);
924 LNN_LOGD(LNN_LANE, "isHichain=%{public}d", isHichain);
925 if (resourceItem.link.type == LANE_HML && resourceItem.clientRef == 1 && isHichain &&
926 CheckLinkConflict(resourceItem.link.peerUdid, resourceItem.link.type) == SOFTBUS_OK) {
927 if (PostDelayDestroyMessage(laneReqId, laneId, DELAY_DESTROY_LANE_TIME) == SOFTBUS_OK) {
928 *isDelayFree = true;
929 return;
930 }
931 }
932 *isDelayFree = false;
933 return;
934 }
935
FreeLink(uint32_t laneReqId,uint64_t laneId,LaneType type)936 static int32_t FreeLink(uint32_t laneReqId, uint64_t laneId, LaneType type)
937 {
938 (void)DelLaneBusinessInfoItem(type, laneId);
939 bool isDelayDestroy = false;
940 IsNeedDelayFreeLane(laneReqId, laneId, &isDelayDestroy);
941 LNN_LOGI(LNN_LANE, "free lane, laneReqId=%{public}u, laneId=%{public}" PRIu64 ", delayDestroy=%{public}s",
942 laneReqId, laneId, isDelayDestroy ? "true" : "false");
943 if (isDelayDestroy) {
944 PostDelayDestroyMessage(laneReqId, INVALID_LANE_ID, 0);
945 return SOFTBUS_OK;
946 }
947 return FreeLaneLink(laneReqId, laneId);
948 }
949
Free(uint32_t laneReqId)950 static int32_t Free(uint32_t laneReqId)
951 {
952 if (Lock() != SOFTBUS_OK) {
953 LNN_LOGE(LNN_LANE, "get lock fail");
954 return SOFTBUS_LOCK_ERR;
955 }
956 LaneType type = (LaneType)(laneReqId >> LANE_REQ_ID_TYPE_SHIFT);
957 TransReqInfo *item = NULL;
958 TransReqInfo *next = NULL;
959 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_requestList->list, TransReqInfo, node) {
960 if (item->laneReqId == laneReqId) {
961 item->notifyFree = true;
962 Unlock();
963 int32_t ret = FreeLink(laneReqId, item->laneId, type);
964 if (ret != SOFTBUS_OK) {
965 DeleteRequestNode(laneReqId);
966 FreeLaneReqId(laneReqId);
967 }
968 return ret;
969 }
970 }
971 Unlock();
972 LNN_LOGI(LNN_LANE, "no find lane need free, laneReqId=%{public}u", laneReqId);
973 FreeLaneReqId(laneReqId);
974 return SOFTBUS_LANE_NOT_FOUND;
975 }
976
UpdateReqInfoWithLaneReqId(uint32_t laneReqId,uint64_t laneId)977 static void UpdateReqInfoWithLaneReqId(uint32_t laneReqId, uint64_t laneId)
978 {
979 if (Lock() != SOFTBUS_OK) {
980 LNN_LOGE(LNN_LANE, "get lock fail");
981 return;
982 }
983 TransReqInfo *item = NULL;
984 LIST_FOR_EACH_ENTRY(item, &g_requestList->list, TransReqInfo, node) {
985 if (item->laneReqId == laneReqId) {
986 item->laneId = laneId;
987 if (item->isWithQos && !item->isCanceled) {
988 item->isNotified = true;
989 }
990 Unlock();
991 return;
992 }
993 }
994 Unlock();
995 }
996
NotifyLaneAllocSuccess(uint32_t laneReqId,uint64_t laneId,const LaneLinkInfo * info)997 static void NotifyLaneAllocSuccess(uint32_t laneReqId, uint64_t laneId, const LaneLinkInfo *info)
998 {
999 UpdateReqInfoWithLaneReqId(laneReqId, laneId);
1000 TransReqInfo reqInfo;
1001 (void)memset_s(&reqInfo, sizeof(TransReqInfo), 0, sizeof(TransReqInfo));
1002 if (GetTransReqInfoByLaneReqId(laneReqId, &reqInfo) != SOFTBUS_OK) {
1003 LNN_LOGE(LNN_LANE, "get lane reqInfo fail");
1004 return;
1005 }
1006 LaneProfile profile;
1007 LaneConnInfo connInfo;
1008 (void)memset_s(&profile, sizeof(LaneProfile), 0, sizeof(LaneProfile));
1009 if (LaneInfoProcess(info, &connInfo, &profile) != SOFTBUS_OK) {
1010 LNN_LOGE(LNN_LANE, "lane alloc success, but laneInfo proc fail");
1011 return;
1012 }
1013 LNN_LOGI(LNN_LANE, "Notify laneAlloc succ, laneReqId=%{public}u, linkType=%{public}d, "
1014 "laneId=%{public}" PRIu64 "", laneReqId, info->type, laneId);
1015 if (reqInfo.isWithQos) {
1016 if (reqInfo.isCanceled) {
1017 LNN_LOGE(LNN_LANE, "lane has canceled only notify fail, laneReqId=%{public}u", laneReqId);
1018 reqInfo.listener.onLaneAllocFail(laneReqId, SOFTBUS_LANE_SUCC_AFTER_CANCELED);
1019 (void)Free(laneReqId);
1020 return;
1021 }
1022 connInfo.laneId = laneId;
1023 reqInfo.listener.onLaneAllocSuccess(laneReqId, &connInfo);
1024 } else {
1025 connInfo.laneId = INVALID_LANE_ID;
1026 reqInfo.extraInfo.listener.onLaneRequestSuccess(laneReqId, &connInfo);
1027 }
1028 LaneType laneType;
1029 if (ParseLaneTypeByLaneReqId(laneReqId, &laneType) != SOFTBUS_OK ||
1030 AddLaneBusinessInfoItem(laneType, laneId) != SOFTBUS_OK) {
1031 LNN_LOGE(LNN_LANE, "create laneBusinessInfo fail, laneReqId=%{public}u", laneReqId);
1032 }
1033 }
1034
NotifyLaneAllocFail(uint32_t laneReqId,int32_t reason)1035 static void NotifyLaneAllocFail(uint32_t laneReqId, int32_t reason)
1036 {
1037 UpdateReqInfoWithLaneReqId(laneReqId, INVALID_LANE_ID);
1038 TransReqInfo reqInfo;
1039 (void)memset_s(&reqInfo, sizeof(TransReqInfo), 0, sizeof(TransReqInfo));
1040 if (GetTransReqInfoByLaneReqId(laneReqId, &reqInfo) != SOFTBUS_OK) {
1041 LNN_LOGE(LNN_LANE, "get lane reqInfo fail");
1042 return;
1043 }
1044 if (reqInfo.isWithQos && reqInfo.isCanceled) {
1045 LNN_LOGE(LNN_LANE, "lane has canceled only notify fail, laneReqId=%{public}u", laneReqId);
1046 }
1047 LNN_LOGE(LNN_LANE, "Notify laneAlloc fail, laneReqId=%{public}u, reason=%{public}d", laneReqId, reason);
1048 if (reqInfo.isWithQos) {
1049 reqInfo.listener.onLaneAllocFail(laneReqId, reason);
1050 FreeLaneReqId(laneReqId);
1051 } else {
1052 reqInfo.extraInfo.listener.onLaneRequestFail(laneReqId, reason);
1053 }
1054 DeleteRequestNode(laneReqId);
1055 }
1056
GetLaneLinkNodeWithoutLock(uint32_t laneReqId)1057 static LaneLinkNodeInfo *GetLaneLinkNodeWithoutLock(uint32_t laneReqId)
1058 {
1059 LaneLinkNodeInfo *linkNode = NULL;
1060 LIST_FOR_EACH_ENTRY(linkNode, &g_multiLinkList, LaneLinkNodeInfo, node) {
1061 if (linkNode->laneReqId == laneReqId) {
1062 return linkNode;
1063 }
1064 }
1065 return NULL;
1066 }
1067
GetErrCodeWithLock(uint32_t laneReqId)1068 static int32_t GetErrCodeWithLock(uint32_t laneReqId)
1069 {
1070 if (Lock() != SOFTBUS_OK) {
1071 LNN_LOGE(LNN_LANE, "get lock fail");
1072 return SOFTBUS_LOCK_ERR;
1073 }
1074 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1075 if (nodeInfo == NULL || nodeInfo->linkList == NULL) {
1076 LNN_LOGE(LNN_LANE, "get lane link node info fail, laneReqId=%{public}u", laneReqId);
1077 Unlock();
1078 return SOFTBUS_LANE_NOT_FOUND;
1079 }
1080 LaneLinkType linkType;
1081 int32_t result = SOFTBUS_LANE_BUILD_LINK_FAIL;
1082 for (uint32_t i = 0; i < nodeInfo->linkList->linkTypeNum; i++) {
1083 linkType = nodeInfo->linkList->linkType[i];
1084 if (linkType == LANE_HML || linkType == LANE_P2P) {
1085 result = nodeInfo->statusList[linkType].result;
1086 Unlock();
1087 return result;
1088 }
1089 }
1090 linkType = nodeInfo->linkList->linkType[0];
1091 result = nodeInfo->statusList[linkType].result;
1092 Unlock();
1093 return result;
1094 }
1095
CreateLinkRequestNode(const LaneLinkNodeInfo * nodeInfo,LinkRequest * requestInfo)1096 static int32_t CreateLinkRequestNode(const LaneLinkNodeInfo *nodeInfo, LinkRequest *requestInfo)
1097 {
1098 requestInfo->networkDelegate = nodeInfo->networkDelegate;
1099 requestInfo->p2pOnly = nodeInfo->p2pOnly;
1100 requestInfo->linkType = nodeInfo->linkList->linkType[nodeInfo->linkRetryIdx];
1101 requestInfo->pid = nodeInfo->pid;
1102 requestInfo->acceptableProtocols = nodeInfo->acceptableProtocols;
1103 requestInfo->transType = nodeInfo->transType;
1104 requestInfo->psm = nodeInfo->psm;
1105 requestInfo->actionAddr = nodeInfo->actionAddr;
1106 requestInfo->isSupportIpv6 = nodeInfo->isSupportIpv6;
1107 if (memcpy_s(requestInfo->peerNetworkId, NETWORK_ID_BUF_LEN, nodeInfo->networkId, NETWORK_ID_BUF_LEN) != EOK) {
1108 LNN_LOGE(LNN_LANE, "memcpy networkId fail");
1109 return SOFTBUS_MEM_ERR;
1110 }
1111 if (memcpy_s(requestInfo->peerBleMac, MAX_MAC_LEN, nodeInfo->peerBleMac, MAX_MAC_LEN) != EOK) {
1112 LNN_LOGE(LNN_LANE, "memcpy peerBleMac fail");
1113 return SOFTBUS_MEM_ERR;
1114 }
1115 requestInfo->bandWidth = nodeInfo->bandWidth;
1116 requestInfo->triggerLinkTime = nodeInfo->triggerLinkTime;
1117 requestInfo->availableLinkTime = nodeInfo->availableLinkTime;
1118 return SOFTBUS_OK;
1119 }
1120
1121 static int32_t g_laneLatency[LANE_LINK_TYPE_BUTT] = {
1122 [LANE_BR] = BR_LATENCY,
1123 [LANE_BLE] = COC_DIRECT_LATENCY,
1124 [LANE_P2P] = P2P_LATENCY,
1125 [LANE_WLAN_2P4G] = WLAN_LATENCY,
1126 [LANE_WLAN_5G] = WLAN_LATENCY,
1127 [LANE_ETH] = WLAN_LATENCY,
1128 [LANE_P2P_REUSE] = P2P_LATENCY,
1129 [LANE_BLE_DIRECT] = COC_DIRECT_LATENCY,
1130 [LANE_BLE_REUSE] = COC_DIRECT_LATENCY,
1131 [LANE_COC] = COC_DIRECT_LATENCY,
1132 [LANE_COC_DIRECT] = COC_DIRECT_LATENCY,
1133 [LANE_HML] = HML_LATENCY,
1134 };
1135
LaneTriggerLink(SoftBusMessage * msg)1136 static void LaneTriggerLink(SoftBusMessage *msg)
1137 {
1138 uint32_t laneReqId = (uint32_t)msg->arg1;
1139 LaneLinkCb linkCb = {
1140 .onLaneLinkSuccess = LinkSuccess,
1141 .onLaneLinkFail = LinkFail,
1142 };
1143 LinkRequest requestInfo = {0};
1144 if (Lock() != SOFTBUS_OK) {
1145 LNN_LOGE(LNN_LANE, "get lock fail");
1146 return;
1147 }
1148 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1149 if (nodeInfo == NULL) {
1150 LNN_LOGE(LNN_LANE, "get lane link node info fail");
1151 Unlock();
1152 return;
1153 }
1154 int32_t ret = SOFTBUS_LANE_BUILD_LINK_FAIL;
1155 do {
1156 ret = CreateLinkRequestNode(nodeInfo, &requestInfo);
1157 if (ret != SOFTBUS_OK) {
1158 LNN_LOGE(LNN_LANE, "Create LinkRequestNode fail.");
1159 Unlock();
1160 break;
1161 }
1162 nodeInfo->linkRetryIdx++;
1163 nodeInfo->statusList[requestInfo.linkType].status = BUILD_LINK_STATUS_BUILDING;
1164 Unlock();
1165 uint64_t delayMillis = (uint64_t)g_laneLatency[requestInfo.linkType];
1166 (void)PostLinkTimeoutMessage(laneReqId, requestInfo.linkType, delayMillis);
1167 ret = BuildLink(&requestInfo, laneReqId, &linkCb);
1168 if (ret == SOFTBUS_OK) {
1169 return;
1170 }
1171 } while (false);
1172 linkCb.onLaneLinkFail(laneReqId, ret, requestInfo.linkType);
1173 }
1174
FreeUnusedLink(uint32_t laneReqId,const LaneLinkInfo * linkInfo)1175 static void FreeUnusedLink(uint32_t laneReqId, const LaneLinkInfo *linkInfo)
1176 {
1177 LNN_LOGI(LNN_LANE, "free unused link, laneReqId=%{public}u", laneReqId);
1178 if (linkInfo == NULL) {
1179 LNN_LOGE(LNN_LANE, "linkInfo is null, laneReqId=%{public}u", laneReqId);
1180 return;
1181 }
1182 if (linkInfo->type == LANE_P2P || linkInfo->type == LANE_HML) {
1183 char networkId[NETWORK_ID_BUF_LEN] = {0};
1184 if (LnnGetNetworkIdByUdid(linkInfo->peerUdid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
1185 LNN_LOGE(LNN_LANE, "get networkId fail, laneReqId=%{public}u", laneReqId);
1186 return;
1187 }
1188 LnnDisconnectP2p(networkId, laneReqId);
1189 }
1190 }
1191
UpdateLinkStatus(uint32_t laneReqId,BuildLinkStatus status,LaneLinkType linkType,const LaneLinkInfo * linkInfo,int32_t result)1192 static int32_t UpdateLinkStatus(uint32_t laneReqId, BuildLinkStatus status, LaneLinkType linkType,
1193 const LaneLinkInfo *linkInfo, int32_t result)
1194 {
1195 if (Lock() != SOFTBUS_OK) {
1196 LNN_LOGE(LNN_LANE, "get lock fail");
1197 return SOFTBUS_LOCK_ERR;
1198 }
1199 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1200 if (nodeInfo == NULL) {
1201 Unlock();
1202 LNN_LOGI(LNN_LANE, "link result has notified, not need update link status. laneReqId=%{public}u", laneReqId);
1203 if (status == BUILD_LINK_STATUS_SUCC) {
1204 FreeUnusedLink(laneReqId, linkInfo);
1205 }
1206 return SOFTBUS_LANE_NOT_FOUND;
1207 }
1208 if (nodeInfo->isCompleted) {
1209 Unlock();
1210 LNN_LOGI(LNN_LANE, "build link has completed, not need update link status. laneReqId=%{public}u, "
1211 "linkType=%{public}d", laneReqId, linkType);
1212 if (status == BUILD_LINK_STATUS_SUCC) {
1213 FreeUnusedLink(laneReqId, linkInfo);
1214 }
1215 return SOFTBUS_LANE_TRIGGER_LINK_FAIL;
1216 }
1217 LNN_LOGI(LNN_LANE, "update link status, laneReqId=%{public}u, status=%{public}d, linkType=%{public}d",
1218 laneReqId, status, linkType);
1219 nodeInfo->statusList[linkType].status = status;
1220 nodeInfo->statusList[linkType].result = result;
1221 if (status != BUILD_LINK_STATUS_SUCC) {
1222 Unlock();
1223 return SOFTBUS_OK;
1224 }
1225 if (memcpy_s(&(nodeInfo->statusList[linkType].linkInfo), sizeof(LaneLinkInfo), linkInfo,
1226 sizeof(LaneLinkInfo)) != EOK) {
1227 LNN_LOGE(LNN_LANE, "linkParam memcpy fail, laneReqId=%{public}u", laneReqId);
1228 Unlock();
1229 return SOFTBUS_MEM_ERR;
1230 }
1231 Unlock();
1232 return SOFTBUS_OK;
1233 }
1234
IsNeedNotifySucc(uint32_t laneReqId)1235 static bool IsNeedNotifySucc(uint32_t laneReqId)
1236 {
1237 if (Lock() != SOFTBUS_OK) {
1238 LNN_LOGE(LNN_LANE, "get lock fail");
1239 return false;
1240 }
1241 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1242 if (nodeInfo == NULL) {
1243 Unlock();
1244 LNN_LOGE(LNN_LANE, "get lane link node info fail, laneReqId=%{public}u", laneReqId);
1245 return false;
1246 }
1247 bool isBuilding = false;
1248 for (uint32_t i = 0; i < nodeInfo->listNum; i++) {
1249 LaneLinkType linkType = nodeInfo->linkList->linkType[i];
1250 if (nodeInfo->statusList[linkType].status == BUILD_LINK_STATUS_BUILDING) {
1251 Unlock();
1252 isBuilding = true;
1253 LNN_LOGE(LNN_LANE, "has exist building link, laneReqId=%{public}u", laneReqId);
1254 return false;
1255 }
1256 if (!isBuilding && nodeInfo->statusList[linkType].status == BUILD_LINK_STATUS_SUCC) {
1257 nodeInfo->isCompleted = true;
1258 Unlock();
1259 return true;
1260 }
1261 }
1262 Unlock();
1263 return false;
1264 }
1265
GetLaneLinkInfo(uint32_t laneReqId,LaneLinkType * type,LaneLinkInfo * info)1266 static int32_t GetLaneLinkInfo(uint32_t laneReqId, LaneLinkType *type, LaneLinkInfo *info)
1267 {
1268 if (Lock() != SOFTBUS_OK) {
1269 LNN_LOGE(LNN_LANE, "get lock fail");
1270 return SOFTBUS_LOCK_ERR;
1271 }
1272 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1273 if (nodeInfo == NULL) {
1274 Unlock();
1275 LNN_LOGE(LNN_LANE, "get lane link node info fail, laneReqId=%{public}u", laneReqId);
1276 return SOFTBUS_LANE_NOT_FOUND;
1277 }
1278 for (uint32_t i = 0; i < nodeInfo->listNum; i++) {
1279 LaneLinkType linkType = nodeInfo->linkList->linkType[i];
1280 if (nodeInfo->statusList[linkType].status == BUILD_LINK_STATUS_SUCC) {
1281 if (memcpy_s(info, sizeof(LaneLinkInfo), &(nodeInfo->statusList[linkType].linkInfo),
1282 sizeof(LaneLinkInfo)) != EOK) {
1283 Unlock();
1284 LNN_LOGE(LNN_LANE, "info memcpy fail, laneReqId=%{public}u", laneReqId);
1285 return SOFTBUS_MEM_ERR;
1286 }
1287 *type = linkType;
1288 Unlock();
1289 return SOFTBUS_OK;
1290 }
1291 }
1292 Unlock();
1293 LNN_LOGE(LNN_LANE, "not found LaneLinkInfo, laneReqId=%{public}u", laneReqId);
1294 return SOFTBUS_LANE_NOT_FOUND;
1295 }
1296
FreeLowPriorityLink(uint32_t laneReqId,LaneLinkType linkType)1297 static void FreeLowPriorityLink(uint32_t laneReqId, LaneLinkType linkType)
1298 {
1299 if (Lock() != SOFTBUS_OK) {
1300 LNN_LOGE(LNN_LANE, "get lock fail");
1301 return;
1302 }
1303 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1304 if (nodeInfo == NULL) {
1305 Unlock();
1306 LNN_LOGE(LNN_LANE, "get lane link node info fail, laneReqId=%{public}u", laneReqId);
1307 return;
1308 }
1309 LinkStatusInfo statusList[LANE_LINK_TYPE_BUTT];
1310 (void)memset_s(&statusList, sizeof(statusList), 0, sizeof(statusList));
1311 uint32_t listNum = 0;
1312 for (uint32_t i = 0; i < nodeInfo->listNum; i++) {
1313 LaneLinkType type = nodeInfo->linkList->linkType[i];
1314 if (type != linkType && nodeInfo->statusList[type].status == BUILD_LINK_STATUS_SUCC) {
1315 if (memcpy_s(&statusList[listNum++], sizeof(LinkStatusInfo), &nodeInfo->statusList[type],
1316 sizeof(LinkStatusInfo)) != EOK) {
1317 continue;
1318 }
1319 }
1320 }
1321 Unlock();
1322 for (uint32_t i = 0; i < listNum; i++) {
1323 FreeUnusedLink(laneReqId, &statusList[i].linkInfo);
1324 }
1325 }
1326
NotifyLinkSucc(uint32_t laneReqId)1327 static void NotifyLinkSucc(uint32_t laneReqId)
1328 {
1329 LaneLinkType linkType;
1330 LaneLinkInfo info;
1331 int32_t ret = SOFTBUS_LANE_RESULT_REPORT_ERR;
1332 (void)memset_s(&info, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo));
1333 ret = GetLaneLinkInfo(laneReqId, &linkType, &info);
1334 if (ret != SOFTBUS_OK) {
1335 LNN_LOGE(LNN_LANE, "get LaneLinkInfo fail, laneReqId=%{public}u", laneReqId);
1336 goto FAIL;
1337 }
1338 char localUdid[UDID_BUF_LEN] = {0};
1339 if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
1340 LNN_LOGE(LNN_LANE, "get udid fail, laneReqId=%{public}u", laneReqId);
1341 ret = SOFTBUS_LANE_GET_LEDGER_INFO_ERR;
1342 goto FAIL;
1343 }
1344 LNN_LOGI(LNN_LANE, "check is need peerIp, udidlen=%{public}zu", strlen(info.peerUdid));
1345 uint64_t laneId = INVALID_LANE_ID;
1346 if (strlen(info.peerUdid) == 0) {
1347 laneId = GenerateLaneId(localUdid, info.linkInfo.rawWifiDirect.peerIp, info.type);
1348 } else {
1349 laneId = GenerateLaneId(localUdid, info.peerUdid, info.type);
1350 }
1351 if (laneId == INVALID_LANE_ID) {
1352 LNN_LOGE(LNN_LANE, "generate laneId fail, laneReqId=%{public}u", laneReqId);
1353 ret = SOFTBUS_LANE_ID_GENERATE_FAIL;
1354 goto FAIL;
1355 }
1356 ret = AddLaneResourceToPool(&info, laneId, false);
1357 if (ret != SOFTBUS_OK) {
1358 LNN_LOGE(LNN_LANE, "add linkInfo item fail, laneReqId=%{public}u", laneReqId);
1359 goto FAIL;
1360 }
1361 NotifyLaneAllocSuccess(laneReqId, laneId, &info);
1362 FreeLowPriorityLink(laneReqId, linkType);
1363 return;
1364 FAIL:
1365 NotifyLaneAllocFail(laneReqId, ret);
1366 }
1367
LaneLinkSuccess(SoftBusMessage * msg)1368 static void LaneLinkSuccess(SoftBusMessage *msg)
1369 {
1370 if (msg->obj == NULL) {
1371 LNN_LOGE(LNN_LANE, "invalid msg->obj");
1372 return;
1373 }
1374 LaneLinkInfo *info = (LaneLinkInfo *)msg->obj;
1375 uint32_t laneReqId = (uint32_t)msg->arg1;
1376 LaneLinkType linkType = (LaneLinkType)msg->arg2;
1377 if (UpdateLinkStatus(laneReqId, BUILD_LINK_STATUS_SUCC, linkType, info, SOFTBUS_OK) != SOFTBUS_OK) {
1378 LNN_LOGE(LNN_LANE, "update link status fail, laneReqId=%{public}u", laneReqId);
1379 SoftBusFree(info);
1380 return;
1381 }
1382 SoftBusFree(info);
1383 if (IsNeedNotifySucc(laneReqId)) {
1384 RemoveLinkTimeoutMessage(laneReqId, LANE_LINK_TYPE_BUTT);
1385 NotifyLinkSucc(laneReqId);
1386 DeleteLaneLinkNode(laneReqId);
1387 }
1388 }
1389
IsNeedNotifyFail(uint32_t laneReqId)1390 static bool IsNeedNotifyFail(uint32_t laneReqId)
1391 {
1392 bool notifyFail = false;
1393 if (Lock() != SOFTBUS_OK) {
1394 LNN_LOGE(LNN_LANE, "get lock fail");
1395 return true;
1396 }
1397 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1398 if (nodeInfo == NULL) {
1399 Unlock();
1400 LNN_LOGE(LNN_LANE, "get lane link node info fail, laneReqId=%{public}u", laneReqId);
1401 return true;
1402 }
1403 uint64_t costTime = SoftBusGetSysTimeMs() - nodeInfo->triggerLinkTime;
1404 if (costTime >= nodeInfo->availableLinkTime || nodeInfo->linkRetryIdx >= nodeInfo->listNum) {
1405 LNN_LOGE(LNN_LANE, "link retry exceed limit, laneReqId=%{public}u", laneReqId);
1406 notifyFail = true;
1407 }
1408 if (!notifyFail) {
1409 nodeInfo->isCompleted = notifyFail ? true : false;
1410 Unlock();
1411 return notifyFail;
1412 }
1413 for (uint32_t i = 0; i < nodeInfo->linkRetryIdx; i++) {
1414 LaneLinkType linkType = nodeInfo->linkList->linkType[i];
1415 if (nodeInfo->statusList[linkType].status != BUILD_LINK_STATUS_FAIL) {
1416 notifyFail = false;
1417 }
1418 }
1419 nodeInfo->isCompleted = notifyFail ? true : false;
1420 Unlock();
1421 return notifyFail;
1422 }
1423
BuildLinkRetry(uint32_t laneReqId)1424 static void BuildLinkRetry(uint32_t laneReqId)
1425 {
1426 bool needRetry = true;
1427 if (Lock() != SOFTBUS_OK) {
1428 LNN_LOGE(LNN_LANE, "get lock fail");
1429 NotifyLaneAllocFail(laneReqId, SOFTBUS_LOCK_ERR);
1430 return;
1431 }
1432 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1433 if (nodeInfo == NULL) {
1434 Unlock();
1435 LNN_LOGE(LNN_LANE, "get lane link node info fail, laneReqId=%{public}u", laneReqId);
1436 NotifyLaneAllocFail(laneReqId, SOFTBUS_LANE_NOT_FOUND);
1437 return;
1438 }
1439 uint64_t costTime = SoftBusGetSysTimeMs() - nodeInfo->triggerLinkTime;
1440 if (costTime >= nodeInfo->availableLinkTime || nodeInfo->linkRetryIdx >= nodeInfo->listNum) {
1441 LNN_LOGE(LNN_LANE, "link retry exceed limit, laneReqId=%{public}u", laneReqId);
1442 Unlock();
1443 return;
1444 }
1445 for (uint32_t i = 0; i < nodeInfo->linkRetryIdx; i++) {
1446 LaneLinkType linkType = nodeInfo->linkList->linkType[i];
1447 if (nodeInfo->statusList[linkType].status == BUILD_LINK_STATUS_SUCC) {
1448 LNN_LOGI(LNN_LANE, "has exist high priority succ link, laneReqId=%{public}u", laneReqId);
1449 needRetry = false;
1450 }
1451 if (nodeInfo->linkRetryIdx < nodeInfo->listNum &&
1452 nodeInfo->linkList->linkType[nodeInfo->linkRetryIdx] == LANE_P2P && linkType == LANE_HML &&
1453 nodeInfo->statusList[linkType].status == BUILD_LINK_STATUS_BUILDING) {
1454 LNN_LOGI(LNN_LANE, "refuse same type link repeat build, laneReqId=%{public}u", laneReqId);
1455 needRetry = false;
1456 }
1457 }
1458 Unlock();
1459 if (needRetry) {
1460 LNN_LOGI(LNN_LANE, "continue to build link, laneReqId=%{public}u", laneReqId);
1461 (void)LnnLanePostMsgToHandler(MSG_TYPE_LANE_TRIGGER_LINK, laneReqId, 0, NULL, 0);
1462 }
1463 }
1464
LaneLinkFail(SoftBusMessage * msg)1465 static void LaneLinkFail(SoftBusMessage *msg)
1466 {
1467 uint32_t laneReqId = (uint32_t)msg->arg1;
1468 int32_t failReason = (int32_t)msg->arg2;
1469 if (msg->obj == NULL) {
1470 LNN_LOGE(LNN_LANE, "invalid msg->obj");
1471 NotifyLaneAllocFail(laneReqId, failReason);
1472 return;
1473 }
1474 LinkFailInfo *failInfo = (LinkFailInfo *)msg->obj;
1475 LaneLinkType linkType = failInfo->linkType;
1476 SoftBusFree(failInfo);
1477 LnnDumpLocalBasicInfo();
1478 LnnDumpOnlineDeviceInfo();
1479 if (UpdateLinkStatus(laneReqId, BUILD_LINK_STATUS_FAIL, linkType, NULL, failReason) != SOFTBUS_OK) {
1480 return;
1481 }
1482 if (IsNeedNotifySucc(laneReqId)) {
1483 RemoveLinkTimeoutMessage(laneReqId, LANE_LINK_TYPE_BUTT);
1484 NotifyLinkSucc(laneReqId);
1485 DeleteLaneLinkNode(laneReqId);
1486 } else if (IsNeedNotifyFail(laneReqId)) {
1487 RemoveLinkTimeoutMessage(laneReqId, LANE_LINK_TYPE_BUTT);
1488 NotifyLaneAllocFail(laneReqId, GetErrCodeWithLock(laneReqId));
1489 DeleteLaneLinkNode(laneReqId);
1490 } else {
1491 BuildLinkRetry(laneReqId);
1492 }
1493 }
1494
LaneStateChange(SoftBusMessage * msg)1495 static void LaneStateChange(SoftBusMessage *msg)
1496 {
1497 if (msg->obj == NULL) {
1498 LNN_LOGE(LNN_LANE, "invalid msg->obj");
1499 return;
1500 }
1501 StateNotifyInfo *info = (StateNotifyInfo*)msg->obj;
1502 switch (info->state) {
1503 case LANE_STATE_LINKUP:
1504 if (LaneLinkupNotify(info->peerUdid, &info->laneLinkInfo) != SOFTBUS_OK) {
1505 LNN_LOGE(LNN_LANE, "notify lane linkup fail");
1506 }
1507 break;
1508 case LANE_STATE_LINKDOWN:
1509 if (LaneLinkdownNotify(info->peerUdid, &info->laneLinkInfo) != SOFTBUS_OK) {
1510 LNN_LOGE(LNN_LANE, "notify lane linkdown fail");
1511 }
1512 break;
1513 default:
1514 LNN_LOGE(LNN_LANE, "lane state=%{public}d cannot found", info->state);
1515 }
1516 SoftBusFree(info);
1517 }
1518
UpdateFreeLaneStatus(uint32_t laneReqId)1519 static void UpdateFreeLaneStatus(uint32_t laneReqId)
1520 {
1521 if (Lock() != SOFTBUS_OK) {
1522 LNN_LOGE(LNN_LANE, "get lock fail");
1523 return ;
1524 }
1525 TransReqInfo *item = NULL;
1526 LIST_FOR_EACH_ENTRY(item, &g_requestList->list, TransReqInfo, node) {
1527 if (item->laneReqId == laneReqId) {
1528 item->hasNotifiedFree = true;
1529 Unlock();
1530 return;
1531 }
1532 }
1533 Unlock();
1534 LNN_LOGE(LNN_LANE, "Update free lane status fail, laneReqId=%{public}d", laneReqId);
1535 return;
1536 }
1537
HandleAsyncNotifySucc(uint32_t laneReqId)1538 static void HandleAsyncNotifySucc(uint32_t laneReqId)
1539 {
1540 LNN_LOGI(LNN_LANE, "handle notify free lane succ, laneReqId=%{public}u", laneReqId);
1541 TransReqInfo reqInfo;
1542 (void)memset_s(&reqInfo, sizeof(TransReqInfo), 0, sizeof(TransReqInfo));
1543 if (GetTransReqInfoByLaneReqId(laneReqId, &reqInfo) != SOFTBUS_OK) {
1544 LNN_LOGE(LNN_LANE, "get trans req info fail, laneReqId=%{public}d", laneReqId);
1545 return;
1546 }
1547 LaneResource resourceItem;
1548 (void)memset_s(&resourceItem, sizeof(LaneResource), 0, sizeof(LaneResource));
1549 if (FindLaneResourceByLaneId(reqInfo.laneId, &resourceItem) != SOFTBUS_OK) {
1550 return;
1551 }
1552 if (resourceItem.link.type == LANE_HML) {
1553 if (reqInfo.isWithQos && reqInfo.listener.onLaneFreeSuccess != NULL) {
1554 reqInfo.listener.onLaneFreeSuccess(laneReqId);
1555 UpdateFreeLaneStatus(laneReqId);
1556 }
1557 } else {
1558 DelLaneResourceByLaneId(reqInfo.laneId, false);
1559 if (reqInfo.isWithQos && reqInfo.listener.onLaneFreeSuccess != NULL) {
1560 reqInfo.listener.onLaneFreeSuccess(laneReqId);
1561 }
1562 DeleteRequestNode(laneReqId);
1563 FreeLaneReqId(laneReqId);
1564 }
1565 }
1566
HandleDelayDestroyLink(SoftBusMessage * msg)1567 static void HandleDelayDestroyLink(SoftBusMessage *msg)
1568 {
1569 uint32_t laneReqId = (uint32_t)msg->arg1;
1570 uint64_t laneId = (uint64_t)msg->arg2;
1571 LNN_LOGI(LNN_LANE, "handle delay destroy message, laneReqId=%{public}u, laneId=%{public}" PRIu64 "",
1572 laneReqId, laneId);
1573 if (laneId == INVALID_LANE_ID) {
1574 HandleAsyncNotifySucc(laneReqId);
1575 return;
1576 }
1577 int32_t ret = FreeLaneLink(laneReqId, laneId);
1578 if (ret != SOFTBUS_OK) {
1579 NotifyFreeLaneResult(laneReqId, ret);
1580 }
1581 }
1582
HandleDetectTimeout(SoftBusMessage * msg)1583 static void HandleDetectTimeout(SoftBusMessage *msg)
1584 {
1585 uint32_t detectId = (uint32_t)msg->arg1;
1586 LNN_LOGI(LNN_LANE, "lane detect timeout. detectId=%{public}u", detectId);
1587 NotifyDetectTimeout(detectId);
1588 }
1589
HandleLinkTimeout(SoftBusMessage * msg)1590 static void HandleLinkTimeout(SoftBusMessage *msg)
1591 {
1592 uint32_t laneReqId = (uint32_t)msg->arg1;
1593 LaneLinkType timeoutLinkType = (LaneLinkType)msg->arg2;
1594 if (Lock() != SOFTBUS_OK) {
1595 LNN_LOGE(LNN_LANE, "get lock fail");
1596 return;
1597 }
1598 LaneLinkNodeInfo *nodeInfo = GetLaneLinkNodeWithoutLock(laneReqId);
1599 if (nodeInfo == NULL) {
1600 Unlock();
1601 LNN_LOGE(LNN_LANE, "get lane link node info fail, laneReqId=%{public}u", laneReqId);
1602 return;
1603 }
1604 uint64_t costTime = SoftBusGetSysTimeMs() - nodeInfo->triggerLinkTime;
1605 if (costTime >= nodeInfo->availableLinkTime || nodeInfo->linkRetryIdx >= nodeInfo->listNum) {
1606 LNN_LOGE(LNN_LANE, "link retry exceed limit, laneReqId=%{public}u", laneReqId);
1607 Unlock();
1608 return;
1609 }
1610 for (uint32_t i = 0; i < nodeInfo->linkRetryIdx; i++) {
1611 LaneLinkType linkType = nodeInfo->linkList->linkType[i];
1612 if (nodeInfo->statusList[linkType].status == BUILD_LINK_STATUS_SUCC) {
1613 LNN_LOGI(LNN_LANE, "a successful link already exist, laneReqId=%{public}u, linkType=%{public}d",
1614 laneReqId, linkType);
1615 Unlock();
1616 return;
1617 }
1618 }
1619 if (nodeInfo->linkList->linkType[nodeInfo->linkRetryIdx] == LANE_P2P) {
1620 for (uint32_t i = 0; i < nodeInfo->linkRetryIdx; i++) {
1621 LaneLinkType type = nodeInfo->linkList->linkType[i];
1622 if (type == LANE_HML && nodeInfo->statusList[type].status == BUILD_LINK_STATUS_BUILDING) {
1623 LNN_LOGI(LNN_LANE, "refuse same type link repeat build, laneReqId=%{public}u", laneReqId);
1624 Unlock();
1625 return;
1626 }
1627 }
1628 }
1629 Unlock();
1630 LNN_LOGI(LNN_LANE, "continue to build link, laneReqId=%{public}u, timeoutLinkType=%{public}d",
1631 laneReqId, timeoutLinkType);
1632 (void)LnnLanePostMsgToHandler(MSG_TYPE_LANE_TRIGGER_LINK, laneReqId, 0, NULL, 0);
1633 }
1634
HandelNotifyFreeLaneResult(SoftBusMessage * msg)1635 static void HandelNotifyFreeLaneResult(SoftBusMessage *msg)
1636 {
1637 uint32_t laneReqId = (uint32_t)msg->arg1;
1638 int32_t errCode = (int32_t)msg->arg2;
1639 LNN_LOGI(LNN_LANE, "handle notify free lane result, laneReqId=%{public}u, errCode=%{public}d",
1640 laneReqId, errCode);
1641 NotifyFreeLaneResult(laneReqId, errCode);
1642 }
1643
MsgHandler(SoftBusMessage * msg)1644 static void MsgHandler(SoftBusMessage *msg)
1645 {
1646 if (msg == NULL) {
1647 return;
1648 }
1649 switch (msg->what) {
1650 case MSG_TYPE_LANE_TRIGGER_LINK:
1651 LaneTriggerLink(msg);
1652 break;
1653 case MSG_TYPE_LANE_LINK_SUCCESS:
1654 LaneLinkSuccess(msg);
1655 break;
1656 case MSG_TYPE_LANE_LINK_FAIL:
1657 LaneLinkFail(msg);
1658 break;
1659 case MSG_TYPE_LANE_STATE_CHANGE:
1660 LaneStateChange(msg);
1661 break;
1662 case MSG_TYPE_DELAY_DESTROY_LINK:
1663 HandleDelayDestroyLink(msg);
1664 break;
1665 case MSG_TYPE_LANE_DETECT_TIMEOUT:
1666 HandleDetectTimeout(msg);
1667 break;
1668 case MSG_TYPE_LANE_LINK_TIMEOUT:
1669 HandleLinkTimeout(msg);
1670 break;
1671 case MSG_TYPE_NOTIFY_FREE_LANE_RESULT:
1672 HandelNotifyFreeLaneResult(msg);
1673 break;
1674 default:
1675 LNN_LOGE(LNN_LANE, "msg type=%{public}d cannot found", msg->what);
1676 break;
1677 }
1678 return;
1679 }
1680
InitLooper(void)1681 static int32_t InitLooper(void)
1682 {
1683 g_laneLoopHandler.name = "transLaneLooper";
1684 g_laneLoopHandler.HandleMessage = MsgHandler;
1685 g_laneLoopHandler.looper = GetLooper(LOOP_TYPE_LNN);
1686 if (g_laneLoopHandler.looper == NULL) {
1687 LNN_LOGE(LNN_LANE, "transLane init looper fail");
1688 return SOFTBUS_NO_INIT;
1689 }
1690 return SOFTBUS_OK;
1691 }
1692
Init(const ILaneIdStateListener * listener)1693 static void Init(const ILaneIdStateListener *listener)
1694 {
1695 if (g_requestList != NULL) {
1696 LNN_LOGW(LNN_LANE, "already init");
1697 return;
1698 }
1699 if (InitLooper() != SOFTBUS_OK) {
1700 LNN_LOGE(LNN_LANE, "init looper fail");
1701 return;
1702 }
1703
1704 if (SoftBusMutexInit(&g_transLaneMutex, NULL) != SOFTBUS_OK) {
1705 LNN_LOGE(LNN_LANE, "transLane mutex init fail");
1706 return;
1707 }
1708 g_requestList = (TransLaneList *)SoftBusCalloc(sizeof(TransLaneList));
1709 if (g_requestList == NULL) {
1710 LNN_LOGE(LNN_LANE, "transLane malloc fail");
1711 (void)SoftBusMutexDestroy(&g_transLaneMutex);
1712 return;
1713 }
1714 ListInit(&g_requestList->list);
1715 ListInit(&g_multiLinkList);
1716 g_laneIdCallback = (ILaneIdStateListener *)listener;
1717 if (InitLaneReliability() != SOFTBUS_OK) {
1718 LNN_LOGE(LNN_LANE, "init laneReliability fail");
1719 return;
1720 }
1721 }
1722
Deinit(void)1723 static void Deinit(void)
1724 {
1725 if (g_requestList == NULL) {
1726 return;
1727 }
1728 if (Lock() != SOFTBUS_OK) {
1729 LNN_LOGE(LNN_LANE, "get lock fail");
1730 return;
1731 }
1732 TransReqInfo *item = NULL;
1733 TransReqInfo *nextItem = NULL;
1734 LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, &g_requestList->list, TransReqInfo, node) {
1735 ListDelete(&item->node);
1736 SoftBusFree(item);
1737 g_requestList->cnt--;
1738 }
1739 Unlock();
1740 (void)SoftBusMutexDestroy(&g_transLaneMutex);
1741 SoftBusFree(g_requestList);
1742 g_requestList = NULL;
1743 DeinitLaneReliability();
1744 }
1745
1746 static LaneInterface g_transLaneObject = {
1747 .init = Init,
1748 .deinit = Deinit,
1749 .allocLane = Alloc,
1750 .allocLaneByQos = AllocLaneByQos,
1751 .allocRawLane = AllocRawLane,
1752 .reallocLaneByQos = ReallocLaneByQos,
1753 .allocTargetLane = AllocTargetLane,
1754 .cancelLane = CancelLane,
1755 .freeLane = Free,
1756 };
1757
TransLaneGetInstance(void)1758 LaneInterface *TransLaneGetInstance(void)
1759 {
1760 return &g_transLaneObject;
1761 }
1762
GetTransReqInfoByLaneReqId(uint32_t laneReqId,TransReqInfo * reqInfo)1763 int32_t GetTransReqInfoByLaneReqId(uint32_t laneReqId, TransReqInfo *reqInfo)
1764 {
1765 if (reqInfo == NULL || laneReqId == INVALID_LANE_REQ_ID) {
1766 return SOFTBUS_INVALID_PARAM;
1767 }
1768 if (Lock() != SOFTBUS_OK) {
1769 LNN_LOGE(LNN_LANE, "get lock fail");
1770 return SOFTBUS_LOCK_ERR;
1771 }
1772 TransReqInfo *item = NULL;
1773 LIST_FOR_EACH_ENTRY(item, &g_requestList->list, TransReqInfo, node) {
1774 if (item->laneReqId == laneReqId) {
1775 if (memcpy_s(reqInfo, sizeof(TransReqInfo), item, sizeof(TransReqInfo)) != EOK) {
1776 LNN_LOGE(LNN_LANE, "memcpy TransReqInfo fail");
1777 Unlock();
1778 return SOFTBUS_MEM_ERR;
1779 }
1780 Unlock();
1781 return SOFTBUS_OK;
1782 }
1783 }
1784 Unlock();
1785 return SOFTBUS_LANE_NOT_FOUND;
1786 }
1787
PostDetectTimeoutMessage(uint32_t detectId,uint64_t delayMillis)1788 int32_t PostDetectTimeoutMessage(uint32_t detectId, uint64_t delayMillis)
1789 {
1790 LNN_LOGI(LNN_LANE, "post timeout message, detectId=%{public}u", detectId);
1791 return LnnLanePostMsgToHandler(MSG_TYPE_LANE_DETECT_TIMEOUT, detectId, 0, NULL, delayMillis);
1792 }
1793
RemoveDetectTimeout(const SoftBusMessage * msg,void * data)1794 static int32_t RemoveDetectTimeout(const SoftBusMessage *msg, void *data)
1795 {
1796 uint32_t *detectId = (uint32_t *)data;
1797 if (msg->what != MSG_TYPE_LANE_DETECT_TIMEOUT) {
1798 return SOFTBUS_INVALID_PARAM;
1799 }
1800 if (msg->arg1 == *detectId) {
1801 LNN_LOGE(LNN_LANE, "remove detect timeout message success. detectId=%{public}u", *detectId);
1802 return SOFTBUS_OK;
1803 }
1804 return SOFTBUS_INVALID_PARAM;
1805 }
1806
RemoveDetectTimeoutMessage(uint32_t detectId)1807 void RemoveDetectTimeoutMessage(uint32_t detectId)
1808 {
1809 LNN_LOGI(LNN_LANE, "remove detect timeout message. detectId=%{public}u", detectId);
1810 g_laneLoopHandler.looper->RemoveMessageCustom(g_laneLoopHandler.looper, &g_laneLoopHandler,
1811 RemoveDetectTimeout, &detectId);
1812 }
1813
PostDelayDestroyMessage(uint32_t laneReqId,uint64_t laneId,uint64_t delayMillis)1814 int32_t PostDelayDestroyMessage(uint32_t laneReqId, uint64_t laneId, uint64_t delayMillis)
1815 {
1816 LNN_LOGI(LNN_LANE, "post delay destroy message. laneReqId=%{public}u, laneId=%{public}" PRIu64 "",
1817 laneReqId, laneId);
1818 return LnnLanePostMsgToHandler(MSG_TYPE_DELAY_DESTROY_LINK, laneReqId, laneId, NULL, delayMillis);
1819 }
1820
PostLaneStateChangeMessage(LaneState state,const char * peerUdid,const LaneLinkInfo * laneLinkInfo)1821 int32_t PostLaneStateChangeMessage(LaneState state, const char *peerUdid, const LaneLinkInfo *laneLinkInfo)
1822 {
1823 LNN_LOGI(LNN_LANE, "post lane state change msg, state=%{public}d", state);
1824 if (peerUdid == NULL || laneLinkInfo == NULL) {
1825 LNN_LOGE(LNN_LANE, "invalid param");
1826 return SOFTBUS_INVALID_PARAM;
1827 }
1828 StateNotifyInfo *stateNotifyInfo = (StateNotifyInfo *)SoftBusCalloc(sizeof(StateNotifyInfo));
1829 if (stateNotifyInfo == NULL) {
1830 LNN_LOGE(LNN_LANE, "calloc stateNotifyInfo fail");
1831 return SOFTBUS_MALLOC_ERR;
1832 }
1833 stateNotifyInfo->state = state;
1834 if (strncpy_s(stateNotifyInfo->peerUdid, UDID_BUF_LEN, peerUdid, UDID_BUF_LEN) != EOK) {
1835 SoftBusFree(stateNotifyInfo);
1836 LNN_LOGE(LNN_STATE, "copy peerUdid fail");
1837 return SOFTBUS_STRCPY_ERR;
1838 }
1839 if (memcpy_s(&stateNotifyInfo->laneLinkInfo, sizeof(LaneLinkInfo), laneLinkInfo,
1840 sizeof(LaneLinkInfo)) != EOK) {
1841 SoftBusFree(stateNotifyInfo);
1842 LNN_LOGE(LNN_LANE, "memcpy laneLinkInfo fail");
1843 return SOFTBUS_MEM_ERR;
1844 }
1845 int32_t ret = LnnLanePostMsgToHandler(MSG_TYPE_LANE_STATE_CHANGE, 0, 0, stateNotifyInfo, 0);
1846 if (ret != SOFTBUS_OK) {
1847 SoftBusFree(stateNotifyInfo);
1848 LNN_LOGE(LNN_LANE, "post lane state change msg fail");
1849 return ret;
1850 }
1851 return SOFTBUS_OK;
1852 }
1853
RemoveDelayDestroy(const SoftBusMessage * msg,void * data)1854 static int32_t RemoveDelayDestroy(const SoftBusMessage *msg, void *data)
1855 {
1856 uint64_t *laneId = (uint64_t *)data;
1857 if (msg->what == MSG_TYPE_DELAY_DESTROY_LINK && *laneId == (uint64_t)msg->arg2) {
1858 LNN_LOGI(LNN_LANE, "remove delay destroy message succ, laneId=%{public}" PRIu64 "", *laneId);
1859 return SOFTBUS_OK;
1860 }
1861 return SOFTBUS_INVALID_PARAM;
1862 }
1863
RemoveDelayDestroyMessage(uint64_t laneId)1864 void RemoveDelayDestroyMessage(uint64_t laneId)
1865 {
1866 g_laneLoopHandler.looper->RemoveMessageCustom(g_laneLoopHandler.looper, &g_laneLoopHandler,
1867 RemoveDelayDestroy, &laneId);
1868 }
1869
DelLogicAndLaneRelationship(uint64_t laneId)1870 void DelLogicAndLaneRelationship(uint64_t laneId)
1871 {
1872 if (Lock() != SOFTBUS_OK) {
1873 LNN_LOGE(LNN_LANE, "get lock fail");
1874 return;
1875 }
1876 TransReqInfo *item = NULL;
1877 LIST_FOR_EACH_ENTRY(item, &g_requestList->list, TransReqInfo, node) {
1878 if (item->laneId == laneId) {
1879 item->laneId = INVALID_LANE_ID;
1880 }
1881 }
1882 Unlock();
1883 }
1884