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