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_lane.h"
17 
18 #include <securec.h>
19 #include <string.h>
20 
21 #include "anonymizer.h"
22 #include "common_list.h"
23 #include "lnn_async_callback_utils.h"
24 #include "lnn_ctrl_lane.h"
25 #include "lnn_distributed_net_ledger.h"
26 #include "lnn_lane_assign.h"
27 #include "lnn_lane_common.h"
28 #include "lnn_lane_def.h"
29 #include "lnn_lane_interface.h"
30 #include "lnn_lane_link.h"
31 #include "lnn_lane_link_conflict.h"
32 #include "lnn_lane_model.h"
33 #include "lnn_lane_query.h"
34 #include "lnn_lane_score.h"
35 #include "lnn_lane_select.h"
36 #include "lnn_log.h"
37 #include "lnn_trans_lane.h"
38 #include "lnn_lane_reliability.h"
39 #include "lnn_lane_vap_info.h"
40 #include "message_handler.h"
41 #include "softbus_adapter_mem.h"
42 #include "softbus_common.h"
43 #include "softbus_def.h"
44 #include "softbus_errcode.h"
45 #include "softbus_utils.h"
46 #include "wifi_direct_manager.h"
47 
48 #define ID_SHIFT_STEP 5
49 #define ID_CALC_MASK 0x1F
50 #define IS_USED 1
51 #define IS_NOT_USED 0
52 #define LANE_REQ_ID_BITMAP_COUNT ((MAX_LANE_REQ_ID_NUM + ID_CALC_MASK) >> ID_SHIFT_STEP)
53 #define LANE_REQ_ID_TYPE_SHIFT 28
54 #define LANE_REQ_RANDOM_ID_MASK 0xFFFFFFF
55 
56 #define LANE_SCORING_INTERVAL 300 /* 5min */
57 #define CHANNEL_RATING_DELAY (5 * 60 * 1000)
58 
59 typedef struct {
60     ListNode node;
61     ILaneIdStateListener listener;
62 } LaneIdListenerNode;
63 
64 typedef struct {
65     ListNode list;
66     uint32_t cnt;
67 } LaneListenerList;
68 
69 static uint32_t g_laneReqIdBitmap[LANE_REQ_ID_BITMAP_COUNT];
70 static SoftBusMutex g_laneMutex;
71 static LaneListenerList g_laneListenerList;
72 static LaneInterface *g_laneObject[LANE_TYPE_BUTT];
73 static ILaneIdStateListener g_laneIdListener;
74 static uint32_t g_laneReqId = 0;
75 
Lock(void)76 static int32_t Lock(void)
77 {
78     return SoftBusMutexLock(&g_laneMutex);
79 }
80 
Unlock(void)81 static void Unlock(void)
82 {
83     (void)SoftBusMutexUnlock(&g_laneMutex);
84 }
85 
86 /*
87  *  0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
88  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
89  * |  type |          randomId(1 ~ MAX_LANE_REQ_ID_NUM)                |
90  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
91  */
AllocLaneReqId(LaneType type)92 static uint32_t AllocLaneReqId(LaneType type)
93 {
94     if (Lock() != SOFTBUS_OK) {
95         return INVALID_LANE_REQ_ID;
96     }
97     uint32_t laneReqId;
98     uint32_t randomId;
99     uint32_t idIndex = (g_laneReqId + 1) % MAX_LANE_REQ_ID_NUM;
100     while (true) {
101         if (((g_laneReqIdBitmap[idIndex >> ID_SHIFT_STEP] >> (idIndex & ID_CALC_MASK)) & IS_USED) == IS_NOT_USED) {
102             g_laneReqIdBitmap[idIndex >> ID_SHIFT_STEP] |= (IS_USED << (idIndex & ID_CALC_MASK));
103             g_laneReqId = idIndex;
104             randomId = idIndex + 1;
105             laneReqId = randomId | ((uint32_t)type << LANE_REQ_ID_TYPE_SHIFT);
106             Unlock();
107             return laneReqId;
108         }
109         if (idIndex == g_laneReqId) {
110             break;
111         }
112         idIndex = (idIndex + 1) % MAX_LANE_REQ_ID_NUM;
113     }
114     Unlock();
115     LNN_LOGE(LNN_LANE, "laneReqId num exceeds the limit");
116     return INVALID_LANE_REQ_ID;
117 }
118 
DestroyLaneReqId(uint32_t laneReqId)119 static void DestroyLaneReqId(uint32_t laneReqId)
120 {
121     uint32_t randomId = laneReqId & LANE_REQ_RANDOM_ID_MASK;
122     if ((randomId == INVALID_LANE_REQ_ID) || (randomId > MAX_LANE_REQ_ID_NUM)) {
123         LNN_LOGE(LNN_LANE, "[DestroyLaneReqId]invalid laneReqId");
124         return;
125     }
126     if (Lock() != SOFTBUS_OK) {
127         return;
128     }
129     LNN_LOGD(LNN_LANE, "destroy laneReqId=%{public}u", laneReqId);
130     uint32_t idIndex = randomId - 1;
131     g_laneReqIdBitmap[idIndex >> ID_SHIFT_STEP] &= (~(IS_USED << (idIndex & ID_CALC_MASK)));
132     Unlock();
133 }
134 
CheckListener(const ILaneIdStateListener * listener)135 static bool CheckListener(const ILaneIdStateListener *listener)
136 {
137     if (listener == NULL) {
138         LNN_LOGE(LNN_LANE, "laneIdListener is null");
139         return false;
140     }
141     if ((listener->OnLaneIdEnabled == NULL) && (listener->OnLaneIdDisabled == NULL)) {
142         LNN_LOGE(LNN_LANE, "listener invalid");
143         return false;
144     }
145     if (Lock() != SOFTBUS_OK) {
146         return false;
147     }
148     LaneIdListenerNode *item = NULL;
149     LIST_FOR_EACH_ENTRY(item, &g_laneListenerList.list, LaneIdListenerNode, node) {
150         if (memcmp(&item->listener, listener, sizeof(ILaneIdStateListener)) == 0) {
151             LNN_LOGW(LNN_LANE, "the listener has been registered");
152             Unlock();
153             return false;
154         }
155     }
156     Unlock();
157     return true;
158 }
159 
RegisterLaneIdListener(const ILaneIdStateListener * listener)160 void RegisterLaneIdListener(const ILaneIdStateListener *listener)
161 {
162     if (CheckListener(listener) == false) {
163         LNN_LOGE(LNN_LANE, "register fail");
164         return;
165     }
166     LaneIdListenerNode *newNode = (LaneIdListenerNode *)SoftBusCalloc(sizeof(LaneIdListenerNode));
167     if (newNode == NULL) {
168         LNN_LOGE(LNN_LANE, "register laneIdListener malloc fail");
169         return;
170     }
171     ListInit(&newNode->node);
172     if (memcpy_s(&newNode->listener, sizeof(ILaneIdStateListener), listener,
173         sizeof(ILaneIdStateListener)) != EOK) {
174         SoftBusFree(newNode);
175         return;
176     }
177     if (Lock() != SOFTBUS_OK) {
178         SoftBusFree(newNode);
179         return;
180     }
181     ListTailInsert(&g_laneListenerList.list, &newNode->node);
182     g_laneListenerList.cnt++;
183     Unlock();
184 }
185 
UnregisterLaneIdListener(const ILaneIdStateListener * listener)186 void UnregisterLaneIdListener(const ILaneIdStateListener *listener)
187 {
188     if (listener == NULL) {
189         return;
190     }
191     if (Lock() != SOFTBUS_OK) {
192         return;
193     }
194     LaneIdListenerNode *item = NULL;
195     LaneIdListenerNode *next = NULL;
196     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_laneListenerList.list, LaneIdListenerNode, node) {
197         if (memcmp(&item->listener, listener, sizeof(ILaneIdStateListener)) == 0) {
198             ListDelete(&item->node);
199             SoftBusFree(item);
200             g_laneListenerList.cnt--;
201             break;
202         }
203     }
204     Unlock();
205 }
206 
GetAllLaneIdListener(ILaneIdStateListener ** listener,uint32_t * listenerNum)207 static int32_t GetAllLaneIdListener(ILaneIdStateListener **listener, uint32_t *listenerNum)
208 {
209     if (Lock() != SOFTBUS_OK) {
210         return SOFTBUS_LOCK_ERR;
211     }
212     if (g_laneListenerList.cnt == 0) {
213         Unlock();
214         LNN_LOGE(LNN_LANE, "laneIdListener num is zero");
215         return SOFTBUS_INVALID_PARAM;
216     }
217     uint32_t num = g_laneListenerList.cnt;
218     *listener = (ILaneIdStateListener *)SoftBusCalloc(sizeof(ILaneIdStateListener) * num);
219     if (*listener == NULL) {
220         Unlock();
221         LNN_LOGE(LNN_LANE, "malloc laneIdListener fail");
222         return SOFTBUS_MALLOC_ERR;
223     }
224     LaneIdListenerNode *item = NULL;
225     num = 0;
226     LIST_FOR_EACH_ENTRY(item, &g_laneListenerList.list, LaneIdListenerNode, node) {
227         if (memcpy_s(*listener + num, sizeof(ILaneIdStateListener),
228             &item->listener, sizeof(ILaneIdStateListener)) != EOK) {
229             continue;
230         }
231         num++;
232     }
233     *listenerNum = num;
234     Unlock();
235     return SOFTBUS_OK;
236 }
237 
LaneIdEnabled(uint64_t laneId,uint32_t profileId)238 static void LaneIdEnabled(uint64_t laneId, uint32_t profileId)
239 {
240     ILaneIdStateListener *listener = NULL;
241     uint32_t listenerNum = 0;
242     if (GetAllLaneIdListener(&listener, &listenerNum) != SOFTBUS_OK) {
243         LNN_LOGE(LNN_LANE, "get laneListener fail");
244         return;
245     }
246     for (uint32_t i = 0; i < listenerNum; i++) {
247         if (listener[i].OnLaneIdEnabled != NULL) {
248             listener[i].OnLaneIdEnabled(laneId, profileId);
249         }
250     }
251     SoftBusFree(listener);
252 }
253 
LaneIdDisabled(uint64_t laneId,uint32_t laneProfileId)254 static void LaneIdDisabled(uint64_t laneId, uint32_t laneProfileId)
255 {
256     ILaneIdStateListener *listener = NULL;
257     uint32_t listenerNum = 0;
258     if (GetAllLaneIdListener(&listener, &listenerNum) != SOFTBUS_OK) {
259         LNN_LOGE(LNN_LANE, "get laneListener fail");
260         return;
261     }
262     for (uint32_t i = 0; i < listenerNum; i++) {
263         if (listener[i].OnLaneIdDisabled != NULL) {
264             listener[i].OnLaneIdDisabled(laneId, laneProfileId);
265         }
266     }
267     SoftBusFree(listener);
268 }
269 
RequestInfoCheck(const LaneRequestOption * request,const ILaneListener * listener)270 static bool RequestInfoCheck(const LaneRequestOption *request, const ILaneListener *listener)
271 {
272     if ((request == NULL) || (listener == NULL)) {
273         return false;
274     }
275     if ((request->type >= LANE_TYPE_BUTT) || (request->type < 0)) {
276         LNN_LOGE(LNN_LANE, "laneType is invalid. type=%{public}d", request->type);
277         return false;
278     }
279     return true;
280 }
281 
AllocInfoCheck(const LaneAllocInfo * allocInfo,const LaneAllocListener * listener)282 static bool AllocInfoCheck(const LaneAllocInfo *allocInfo, const LaneAllocListener *listener)
283 {
284     if ((allocInfo == NULL) || (listener == NULL)) {
285         return false;
286     }
287     if ((allocInfo->type >= LANE_TYPE_BUTT) || (allocInfo->type < 0)) {
288         LNN_LOGE(LNN_LANE, "laneType is invalid. type=%{public}d", allocInfo->type);
289         return false;
290     }
291     return true;
292 }
293 
294 /* return laneReqId if the operation is successful, return 0 otherwise. */
ApplyLaneReqId(LaneType type)295 uint32_t ApplyLaneReqId(LaneType type)
296 {
297     return AllocLaneReqId(type);
298 }
299 
FreeLaneReqId(uint32_t laneReqId)300 void FreeLaneReqId(uint32_t laneReqId)
301 {
302     return DestroyLaneReqId(laneReqId);
303 }
304 
LnnAllocLane(uint32_t laneReqId,const LaneAllocInfo * allocInfo,const LaneAllocListener * listener)305 static int32_t LnnAllocLane(uint32_t laneReqId, const LaneAllocInfo *allocInfo, const LaneAllocListener *listener)
306 {
307     if (!AllocInfoCheck(allocInfo, listener)) {
308         LNN_LOGE(LNN_LANE, "lane alloc info invalid");
309         return SOFTBUS_INVALID_PARAM;
310     }
311     if (g_laneObject[allocInfo->type] == NULL) {
312         LNN_LOGE(LNN_LANE, "laneType is not supported. laneType=%{public}d", allocInfo->type);
313         return SOFTBUS_INVALID_PARAM;
314     }
315     LNN_LOGI(LNN_LANE, "alloc lane enter, laneReqId=%{public}u, laneType=%{public}d, transType=%{public}d, "
316         "minBW=%{public}u, maxLaneLatency=%{public}u, minLaneLatency=%{public}u",
317         laneReqId, allocInfo->type, allocInfo->transType,
318         allocInfo->qosRequire.minBW,
319         allocInfo->qosRequire.maxLaneLatency,
320         allocInfo->qosRequire.minLaneLatency);
321     int32_t result = g_laneObject[allocInfo->type]->allocLaneByQos(laneReqId, allocInfo, listener);
322     if (result != SOFTBUS_OK) {
323         LNN_LOGE(LNN_LANE, "alloc lane fail, laneReqId=%{public}u, result=%{public}d", laneReqId, result);
324         return result;
325     }
326     return SOFTBUS_OK;
327 }
328 
LnnAllocRawLane(uint32_t laneHandle,const RawLaneAllocInfo * allocInfo,const LaneAllocListener * listener)329 static int32_t LnnAllocRawLane(uint32_t laneHandle, const RawLaneAllocInfo *allocInfo,
330     const LaneAllocListener *listener)
331 {
332     if (allocInfo == NULL || listener == NULL) {
333         LNN_LOGE(LNN_LANE, "lane alloc raw info invalid");
334         return SOFTBUS_INVALID_PARAM;
335     }
336     if ((allocInfo->type >= LANE_TYPE_BUTT) || (allocInfo->type < 0)) {
337         LNN_LOGE(LNN_LANE, "laneType is invalid. type=%{public}d", allocInfo->type);
338         return SOFTBUS_INVALID_PARAM;
339     }
340     if (g_laneObject[allocInfo->type] == NULL) {
341         LNN_LOGE(LNN_LANE, "laneType is not supported. laneType=%{public}d", allocInfo->type);
342         return SOFTBUS_INVALID_PARAM;
343     }
344     int32_t result = g_laneObject[allocInfo->type]->allocRawLane(laneHandle, allocInfo, listener);
345     if (result != SOFTBUS_OK) {
346         LNN_LOGE(LNN_LANE, "alloc raw lane fail, laneReqId=%{public}u, result=%{public}d", laneHandle, result);
347         return result;
348     }
349     return SOFTBUS_OK;
350 }
351 
LnnReAllocLane(uint32_t laneReqId,uint64_t laneId,const LaneAllocInfo * allocInfo,const LaneAllocListener * listener)352 static int32_t LnnReAllocLane(uint32_t laneReqId, uint64_t laneId, const LaneAllocInfo *allocInfo,
353     const LaneAllocListener *listener)
354 {
355     if (!AllocInfoCheck(allocInfo, listener)) {
356         LNN_LOGE(LNN_LANE, "lane realloc info invalid");
357         return SOFTBUS_INVALID_PARAM;
358     }
359     if (g_laneObject[allocInfo->type] == NULL) {
360         LNN_LOGE(LNN_LANE, "laneType is not supported. laneType=%{public}d", allocInfo->type);
361         return SOFTBUS_INVALID_PARAM;
362     }
363     LNN_LOGI(LNN_LANE, "realloc lane enter, laneReqId=%{public}u, laneId=%{public}" PRIu64 ", laneType=%{public}d, "
364         "transType=%{public}d, minBW=%{public}u, maxLaneLatency=%{public}u, minLaneLatency=%{public}u",
365         laneReqId, laneId, allocInfo->type, allocInfo->transType,
366         allocInfo->qosRequire.minBW,
367         allocInfo->qosRequire.maxLaneLatency,
368         allocInfo->qosRequire.minLaneLatency);
369     int32_t result = g_laneObject[allocInfo->type]->reallocLaneByQos(laneReqId, laneId, allocInfo, listener);
370     if (result != SOFTBUS_OK) {
371         LNN_LOGE(LNN_LANE, "realloc lane fail, laneReqId=%{public}u, result=%{public}d", laneReqId, result);
372         return result;
373     }
374     return SOFTBUS_OK;
375 }
376 
LnnAllocTargetLane(uint32_t laneHandle,const LaneAllocInfoExt * allocInfo,const LaneAllocListener * listener)377 static int32_t LnnAllocTargetLane(uint32_t laneHandle, const LaneAllocInfoExt *allocInfo,
378     const LaneAllocListener *listener)
379 {
380     if (allocInfo == NULL || listener == NULL || laneHandle == INVALID_LANE_REQ_ID) {
381         return SOFTBUS_INVALID_PARAM;
382     }
383     if (allocInfo->type != LANE_TYPE_TRANS) {
384         return SOFTBUS_INVALID_PARAM;
385     }
386     LNN_LOGI(LNN_LANE, "targetLinkNum=%{public}u and first targetLinkType=%{public}d",
387         allocInfo->linkList.linkTypeNum, allocInfo->linkList.linkType[0]);
388     if (allocInfo->linkList.linkTypeNum >= LANE_LINK_TYPE_BUTT) {
389         return SOFTBUS_INVALID_PARAM;
390     }
391     int32_t result = g_laneObject[allocInfo->type]->allocTargetLane(laneHandle, allocInfo, listener);
392     if (result != SOFTBUS_OK) {
393         LNN_LOGE(LNN_LANE, "alloc target lane fail, handle=%{public}u, result=%{public}d", laneHandle, result);
394         return result;
395     }
396     return SOFTBUS_OK;
397 }
398 
CheckLaneObject(uint32_t laneReqId,LaneType * type)399 static int32_t CheckLaneObject(uint32_t laneReqId, LaneType *type)
400 {
401     *type = laneReqId >> LANE_REQ_ID_TYPE_SHIFT;
402     if (*type >= LANE_TYPE_BUTT) {
403         LNN_LOGE(LNN_LANE, "laneType invalid");
404         return SOFTBUS_INVALID_PARAM;
405     }
406     if (g_laneObject[*type] == NULL) {
407         return SOFTBUS_INVALID_PARAM;
408     }
409     return SOFTBUS_OK;
410 }
411 
LnnCancelLane(uint32_t laneReqId)412 static int32_t LnnCancelLane(uint32_t laneReqId)
413 {
414     LaneType type;
415     if (CheckLaneObject(laneReqId, &type) != SOFTBUS_OK) {
416         LNN_LOGE(LNN_LANE, "laneType invalid");
417         return SOFTBUS_INVALID_PARAM;
418     }
419     LNN_LOGD(LNN_LANE, "cancel lane enter, laneReqId=%{public}u", laneReqId);
420     int32_t result = g_laneObject[type]->cancelLane(laneReqId);
421     if (result != SOFTBUS_OK) {
422         LNN_LOGE(LNN_LANE, "cancelLane fail, result=%{public}d", result);
423         return result;
424     }
425     return SOFTBUS_OK;
426 }
427 
LnnFreeLink(uint32_t laneReqId)428 static int32_t LnnFreeLink(uint32_t laneReqId)
429 {
430     LaneType type;
431     if (CheckLaneObject(laneReqId, &type) != SOFTBUS_OK) {
432         LNN_LOGE(LNN_LANE, "laneType invalid");
433         return SOFTBUS_INVALID_PARAM;
434     }
435     LNN_LOGD(LNN_LANE, "free lane enter, laneReqId=%{public}u", laneReqId);
436     int32_t result = g_laneObject[type]->freeLane(laneReqId);
437     if (result != SOFTBUS_OK) {
438         LNN_LOGE(LNN_LANE, "freeLane fail, result=%{public}d", result);
439         return result;
440     }
441     return SOFTBUS_OK;
442 }
443 
444 static LnnLaneManager g_LaneManager = {
445     .lnnQueryLaneResource = LnnQueryLaneResource,
446     .lnnGetLaneHandle = ApplyLaneReqId,
447     .lnnAllocLane = LnnAllocLane,
448     .lnnAllocRawLane = LnnAllocRawLane,
449     .lnnReAllocLane = LnnReAllocLane,
450     .lnnAllocTargetLane = LnnAllocTargetLane,
451     .lnnCancelLane = LnnCancelLane,
452     .lnnFreeLane = LnnFreeLink,
453     .registerLaneListener = RegisterLaneListener,
454     .unRegisterLaneListener = UnRegisterLaneListener,
455 };
456 
GetLaneManager(void)457 LnnLaneManager* GetLaneManager(void)
458 {
459     return &g_LaneManager;
460 }
461 
LnnRequestLane(uint32_t laneReqId,const LaneRequestOption * request,const ILaneListener * listener)462 int32_t LnnRequestLane(uint32_t laneReqId, const LaneRequestOption *request,
463     const ILaneListener *listener)
464 {
465     if (RequestInfoCheck(request, listener) == false) {
466         LNN_LOGE(LNN_LANE, "lane requestInfo invalid");
467         return SOFTBUS_INVALID_PARAM;
468     }
469     if (g_laneObject[request->type] == NULL) {
470         LNN_LOGE(LNN_LANE, "lane type is not supported. type=%{public}d", request->type);
471         return SOFTBUS_INVALID_PARAM;
472     }
473     int32_t result;
474     LNN_LOGI(LNN_LANE, "laneRequest, laneReqId=%{public}u, laneType=%{public}d, transType=%{public}d",
475         laneReqId, request->type, request->requestInfo.trans.transType);
476     for (uint32_t i = 0; i < request->requestInfo.trans.expectedLink.linkTypeNum; i++) {
477         LNN_LOGI(LNN_LANE, "laneRequest assign the priority=%{public}u, link=%{public}d",
478             i, request->requestInfo.trans.expectedLink.linkType[i]);
479     }
480     result = g_laneObject[request->type]->allocLane(laneReqId, request, listener);
481     if (result != SOFTBUS_OK) {
482         LNN_LOGE(LNN_LANE, "alloc lane fail, result=%{public}d", result);
483         return result;
484     }
485     LNN_LOGI(LNN_LANE, "request lane success, laneReqId=%{public}u", laneReqId);
486     return result;
487 }
488 
LnnFreeLane(uint32_t laneReqId)489 int32_t LnnFreeLane(uint32_t laneReqId)
490 {
491     LaneType type;
492     if (CheckLaneObject(laneReqId, &type) != SOFTBUS_OK) {
493         LNN_LOGE(LNN_LANE, "laneType invalid");
494         return SOFTBUS_INVALID_PARAM;
495     }
496     LNN_LOGD(LNN_LANE, "free lane enter, laneReqId=%{public}u", laneReqId);
497     int32_t result = g_laneObject[type]->freeLane(laneReqId);
498     if (result != SOFTBUS_OK) {
499         LNN_LOGE(LNN_LANE, "freeLane fail, result=%{public}d", result);
500         return result;
501     }
502     return SOFTBUS_OK;
503 }
504 
GetWifiDirectMacInfo(char * localIp,LnnMacInfo * macInfo)505 static int32_t GetWifiDirectMacInfo(char *localIp, LnnMacInfo *macInfo)
506 {
507     LnnMacInfo dupMacInfo;
508     (void)memset_s(&dupMacInfo, sizeof(LnnMacInfo), 0, sizeof(LnnMacInfo));
509     struct WifiDirectManager *wifiDirectMgr = GetWifiDirectManager();
510     if (wifiDirectMgr == NULL) {
511         LNN_LOGE(LNN_LANE, "get wifi direct manager fail");
512         return SOFTBUS_INVALID_PARAM;
513     }
514     int32_t ret = wifiDirectMgr->getLocalAndRemoteMacByLocalIp(localIp, dupMacInfo.localMac, MAX_MAC_LEN,
515         dupMacInfo.remoteMac, MAX_MAC_LEN);
516     char *anonyIp = NULL;
517     Anonymize(localIp, &anonyIp);
518     if (ret != SOFTBUS_OK) {
519         LNN_LOGE(LNN_LANE, "localIp=%{public}s get Mac fail, ret=%{public}d", AnonymizeWrapper(anonyIp), ret);
520         AnonymizeFree(anonyIp);
521         return ret;
522     }
523     if (strcpy_s(macInfo->localMac, MAX_MAC_LEN, dupMacInfo.localMac) != EOK ||
524         strcpy_s(macInfo->remoteMac, MAX_MAC_LEN, dupMacInfo.remoteMac) != EOK) {
525         LNN_LOGE(LNN_LANE, "strcpy MacInfo fail");
526         AnonymizeFree(anonyIp);
527         return SOFTBUS_STRCPY_ERR;
528     }
529     char *anonyLocalMac = NULL;
530     char *anonyRemoteMac = NULL;
531     Anonymize(macInfo->localMac, &anonyLocalMac);
532     Anonymize(macInfo->remoteMac, &anonyRemoteMac);
533     LNN_LOGI(LNN_LANE, "get mac by ip done, localMac=%{public}s, remoteMac=%{public}s, localIp=%{public}s",
534         AnonymizeWrapper(anonyLocalMac), AnonymizeWrapper(anonyRemoteMac), AnonymizeWrapper(anonyIp));
535     AnonymizeFree(anonyLocalMac);
536     AnonymizeFree(anonyRemoteMac);
537     AnonymizeFree(anonyIp);
538     return SOFTBUS_OK;
539 }
540 
GetMacInfoByLaneId(uint64_t laneId,LnnMacInfo * macInfo)541 int32_t GetMacInfoByLaneId(uint64_t laneId, LnnMacInfo *macInfo)
542 {
543     if (laneId == INVALID_LANE_ID || macInfo == NULL) {
544         LNN_LOGE(LNN_LANE, "laneId is invalid or macInfo is null");
545         return SOFTBUS_INVALID_PARAM;
546     }
547     LaneResource laneLinkInfo;
548     (void)memset_s(&laneLinkInfo, sizeof(LaneResource), 0, sizeof(LaneResource));
549     int32_t ret = FindLaneResourceByLaneId(laneId, &laneLinkInfo);
550     if (ret != SOFTBUS_OK) {
551         LNN_LOGE(LNN_LANE, "laneId=%{public}" PRIu64 " find lane link info fail, ret=%{public}d", laneId, ret);
552         return ret;
553     }
554     if (laneLinkInfo.link.type != LANE_P2P && laneLinkInfo.link.type != LANE_P2P_REUSE &&
555         laneLinkInfo.link.type != LANE_HML) {
556         LNN_LOGE(LNN_LANE, "lane type=%{public}d is invalid", laneLinkInfo.link.type);
557         return SOFTBUS_INVALID_PARAM;
558     }
559     char localIp[IP_LEN] = {0};
560     if (memcpy_s(localIp, IP_LEN, laneLinkInfo.link.linkInfo.p2p.connInfo.localIp, IP_LEN) != EOK) {
561         LNN_LOGE(LNN_LANE, "memcpy ip from lanelinkInfo fail");
562         return SOFTBUS_MEM_ERR;
563     }
564     return GetWifiDirectMacInfo(localIp, macInfo);
565 }
566 
LnnQueryLaneResource(const LaneQueryInfo * queryInfo,const QosInfo * qosInfo)567 int32_t LnnQueryLaneResource(const LaneQueryInfo *queryInfo, const QosInfo *qosInfo)
568 {
569     if (queryInfo == NULL || qosInfo == NULL) {
570         LNN_LOGE(LNN_LANE, "invalid param");
571         return SOFTBUS_INVALID_PARAM;
572     }
573 
574     if (!LnnGetOnlineStateById(queryInfo->networkId, CATEGORY_NETWORK_ID)) {
575         char *anonyNetworkId = NULL;
576         Anonymize(queryInfo->networkId, &anonyNetworkId);
577         LNN_LOGE(LNN_LANE, "device not online, cancel query peerNetworkId=%{public}s",
578             AnonymizeWrapper(anonyNetworkId));
579         AnonymizeFree(anonyNetworkId);
580         return SOFTBUS_NETWORK_NODE_OFFLINE;
581     }
582     return QueryLaneResource(queryInfo, qosInfo);
583 }
584 
LaneInitChannelRatingDelay(void * para)585 static void LaneInitChannelRatingDelay(void *para)
586 {
587     (void)para;
588     if (LnnInitScore() != SOFTBUS_OK) {
589         LNN_LOGE(LNN_LANE, "init laneScoring fail");
590         return;
591     }
592     if (LnnStartScoring(LANE_SCORING_INTERVAL) != SOFTBUS_OK) {
593         LNN_LOGE(LNN_LANE, "start laneScoring fail");
594     }
595 }
596 
LaneDelayInit(void)597 static int32_t LaneDelayInit(void)
598 {
599     int32_t ret = LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), LaneInitChannelRatingDelay,
600         NULL, CHANNEL_RATING_DELAY);
601     if (ret != SOFTBUS_OK) {
602         LNN_LOGE(LNN_LANE, "post channelRating msg fail");
603     }
604     return ret;
605 }
606 
InitLane(void)607 int32_t InitLane(void)
608 {
609     if (InitLaneModel() != SOFTBUS_OK) {
610         LNN_LOGE(LNN_LANE, "[InitLane]init laneModel fail");
611         return SOFTBUS_NO_INIT;
612     }
613     if (InitLaneLink() != SOFTBUS_OK) {
614         LNN_LOGE(LNN_LANE, "[InitLane]init laneLink fail");
615         return SOFTBUS_NO_INIT;
616     }
617     if (InitLaneListener() != SOFTBUS_OK) {
618         LNN_LOGE(LNN_LANE, "[InitLane]init laneListener fail");
619         return SOFTBUS_NO_INIT;
620     }
621     if (LaneDelayInit() != SOFTBUS_OK) {
622         LNN_LOGE(LNN_LANE, "[InitLane]laneDelayInit fail");
623         return SOFTBUS_NO_INIT;
624     }
625     if (InitLaneLinkConflict() != SOFTBUS_OK) {
626         LNN_LOGE(LNN_LANE, "[InitLane]InitLaneLinkConflict fail");
627         return SOFTBUS_NO_INIT;
628     }
629     int32_t ret = LnnInitVapInfo();
630     if (ret != SOFTBUS_OK) {
631         /* optional case, ignore result */
632         LNN_LOGW(LNN_LANE, "[InitLane]init vap info err, ret=%{public}d", ret);
633     }
634     if (SoftBusMutexInit(&g_laneMutex, NULL) != SOFTBUS_OK) {
635         return SOFTBUS_NO_INIT;
636     }
637     g_laneIdListener.OnLaneIdEnabled = LaneIdEnabled;
638     g_laneIdListener.OnLaneIdDisabled = LaneIdDisabled;
639     g_laneObject[LANE_TYPE_TRANS] = TransLaneGetInstance();
640     if (g_laneObject[LANE_TYPE_TRANS] != NULL) {
641         LNN_LOGI(LNN_LANE, "transLane get instance succ");
642         g_laneObject[LANE_TYPE_TRANS]->init(&g_laneIdListener);
643     }
644     g_laneObject[LANE_TYPE_CTRL] = CtrlLaneGetInstance();
645     if (g_laneObject[LANE_TYPE_CTRL] != NULL) {
646         LNN_LOGI(LNN_LANE, "ctrl get instance succ");
647         g_laneObject[LANE_TYPE_CTRL]->init(&g_laneIdListener);
648     }
649     ListInit(&g_laneListenerList.list);
650     g_laneListenerList.cnt = 0;
651     return SOFTBUS_OK;
652 }
653 
DeinitLane(void)654 void DeinitLane(void)
655 {
656     DeinitLaneModel();
657     DeinitLaneLink();
658     DeinitLaneListener();
659     LnnDeinitScore();
660     LnnDeinitVapInfo();
661     DeinitLaneLinkConflict();
662     if (g_laneObject[LANE_TYPE_TRANS] != NULL) {
663         g_laneObject[LANE_TYPE_TRANS]->deinit();
664     }
665     if (g_laneObject[LANE_TYPE_CTRL] != NULL) {
666         g_laneObject[LANE_TYPE_CTRL]->deinit();
667     }
668     (void)SoftBusMutexDestroy(&g_laneMutex);
669 }
670