1 /*
2 * Copyright (c) 2021 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_network_manager.h"
17
18 #include <pthread.h>
19 #include <securec.h>
20 #include <unistd.h>
21
22 #include "auth_interface.h"
23 #include "bus_center_event.h"
24 #include "bus_center_manager.h"
25 #include "disc_interface.h"
26 #include "g_enhance_lnn_func.h"
27 #include "g_enhance_lnn_func_pack.h"
28 #include "lnn_async_callback_utils.h"
29 #include "lnn_common_utils.h"
30 #include "lnn_discovery_manager.h"
31 #include "lnn_distributed_net_ledger.h"
32 #include "lnn_heartbeat_ctrl.h"
33 #include "lnn_log.h"
34 #include "lnn_net_builder.h"
35 #include "lnn_ohos_account.h"
36 #include "lnn_physical_subnet_manager.h"
37 #include "lnn_settingdata_event_monitor.h"
38 #include "lnn_connection_fsm.h"
39 #include "lnn_init_monitor.h"
40 #include "lnn_network_manager.h"
41 #include "softbus_adapter_mem.h"
42 #include "softbus_def.h"
43 #include "softbus_error_code.h"
44 #include "softbus_feature_config.h"
45 #include "softbus_init_common.h"
46
47 #define LNN_MAX_IF_NAME_LEN 256
48 #define LNN_DELIMITER_OUTSIDE ","
49 #define LNN_DELIMITER_INSIDE ":"
50
51 #define LNN_DEFAULT_IF_NAME_WLAN "wlan0"
52 #define LNN_DEFAULT_IF_NAME_ETH "eth0"
53 #define LNN_DEFAULT_IF_NAME_BR "br0"
54 #define LNN_DEFAULT_IF_NAME_BLE "ble0"
55 #define LNN_DEFAULT_IF_NAME_USB_NCM "ncm0"
56 #define LNN_DEFAULT_IF_NAME_USB_WWAN "wwan0"
57
58 #define LNN_CHECK_OOBE_DELAY_LEN (5 * 60 * 1000LL)
59 #define LNN_RESTART_DISCOVERY_DELAY_LEN (5 * 1000LL)
60
61 static SoftBusMutex g_dataShareLock;
62 static bool g_isDataShareInit = false;
63
64 typedef enum {
65 LNN_ETH_TYPE = 0,
66 LNN_WLAN_TYPE,
67 LNN_BR_TYPE,
68 LNN_BLE_TYPE,
69 LNN_USB_TYPE,
70 LNN_MAX_NUM_TYPE,
71 } LnnNetIfNameType;
72
73 static ListNode g_netIfNameList = {
74 .prev = &g_netIfNameList,
75 .next = &g_netIfNameList,
76 };
77
78 static ListNode *g_nightOnCache = NULL;
79
80 typedef struct {
81 ListNode node;
82 ConnectionAddr addrs;
83 } DeviceNightMode;
84
85 static bool g_isNightMode = false;
86 static bool g_isOOBEEnd = false;
87 static bool g_isUnLock = false;
88 static bool g_isDeviceRoot = false;
89 static SoftBusUserState g_backgroundState = SOFTBUS_USER_FOREGROUND;
90
91 int32_t RegistIPProtocolManager(void);
92 int32_t RegistNewIPProtocolManager(void);
93 int32_t LnnInitUsbChannelManager(void);
94 void LnnDeinitUsbChannelManager(void);
95
RegistNewIPProtocolManager(void)96 int32_t __attribute__((weak)) RegistNewIPProtocolManager(void)
97 {
98 return SOFTBUS_OK;
99 }
100
RegistBtProtocolManager(void)101 int32_t __attribute__((weak)) RegistBtProtocolManager(void)
102 {
103 LNN_LOGW(LNN_BUILDER, "regist virtual bt protocol manager");
104 return SOFTBUS_OK;
105 }
106
LnnInitUsbChannelManager(void)107 int32_t __attribute__((weak)) LnnInitUsbChannelManager(void)
108 {
109 LNN_LOGW(LNN_BUILDER, "regist virtual usb channel manager");
110 return SOFTBUS_OK;
111 }
112
LnnDeinitUsbChannelManager(void)113 void __attribute__((weak)) LnnDeinitUsbChannelManager(void)
114 {
115 }
116
117 static LnnNetIfManagerBuilder g_netifBuilders[LNN_MAX_NUM_TYPE] = {0};
118
119 static LnnProtocolManager *g_networkProtocols[LNN_NETWORK_MAX_PROTOCOL_COUNT] = {0};
120
CreateNetifMgr(const char * netIfName)121 static LnnNetIfMgr *CreateNetifMgr(const char *netIfName)
122 {
123 if (netIfName == NULL) {
124 LNN_LOGE(LNN_BUILDER, "parameters invalid");
125 return NULL;
126 }
127 LnnNetIfMgr *netIfMgr = (LnnNetIfMgr *)SoftBusCalloc(sizeof(LnnNetIfMgr));
128 if (netIfMgr == NULL) {
129 LNN_LOGE(LNN_BUILDER, "malloc LnnNetIfMgr fail");
130 return NULL;
131 }
132 do {
133 ListInit(&netIfMgr->node);
134 if (strncpy_s(netIfMgr->ifName, NET_IF_NAME_LEN, netIfName, strlen(netIfName)) != EOK) {
135 LNN_LOGE(LNN_BUILDER, "copy netIfName fail");
136 break;
137 }
138 return netIfMgr;
139 } while (false);
140
141 SoftBusFree(netIfMgr);
142 return NULL;
143 }
144
RegistNetIfMgr(LnnNetIfNameType type,LnnNetIfManagerBuilder builder)145 static int32_t RegistNetIfMgr(LnnNetIfNameType type, LnnNetIfManagerBuilder builder)
146 {
147 if (type >= LNN_MAX_NUM_TYPE) {
148 LNN_LOGE(LNN_BUILDER, "type too big");
149 return SOFTBUS_INVALID_PARAM;
150 }
151 if (g_netifBuilders[type] != NULL && g_netifBuilders[type] != builder) {
152 LNN_LOGE(LNN_BUILDER, "type already registed");
153 return SOFTBUS_ALREADY_EXISTED;
154 }
155 g_netifBuilders[type] = builder;
156 return SOFTBUS_OK;
157 }
158
ConvertToNetIfType(LnnNetIfNameType nameType)159 static LnnNetIfType ConvertToNetIfType(LnnNetIfNameType nameType)
160 {
161 return nameType >= LNN_MAX_NUM_TYPE ? 0 : (0x1 << nameType);
162 }
163
NetifMgrFactory(LnnNetIfNameType type,const char * ifName)164 static LnnNetIfMgr *NetifMgrFactory(LnnNetIfNameType type, const char *ifName)
165 {
166 if (type >= LNN_MAX_NUM_TYPE) {
167 return NULL;
168 }
169 if (g_netifBuilders[type] == NULL) {
170 LNN_LOGE(LNN_BUILDER, "netif type not supported. type=%{public}d", type);
171 return NULL;
172 }
173 LnnNetIfMgr *netifMgr = g_netifBuilders[type](ifName);
174 if (netifMgr != NULL) {
175 netifMgr->type = ConvertToNetIfType(type);
176 }
177 return netifMgr;
178 }
179
ParseIfNameConfig(char * buf,uint32_t bufLen)180 static int32_t ParseIfNameConfig(char *buf, uint32_t bufLen)
181 {
182 char *outerPtr = NULL;
183 char *innerPtr = NULL;
184 char *value1 = NULL;
185 char *value2 = NULL;
186 if (buf == NULL || bufLen == 0) {
187 LNN_LOGE(LNN_BUILDER, "parameters invalid");
188 return SOFTBUS_INVALID_PARAM;
189 }
190 char *key = strtok_s(buf, LNN_DELIMITER_OUTSIDE, &outerPtr);
191 while (key != NULL) {
192 value1 = strtok_s(key, LNN_DELIMITER_INSIDE, &innerPtr);
193 value2 = strtok_s(NULL, LNN_DELIMITER_INSIDE, &innerPtr);
194
195 LnnNetIfMgr *netIfMgr = NetifMgrFactory((LnnNetIfNameType)atoi(value1), value2);
196 if (netIfMgr != NULL) {
197 LNN_LOGW(LNN_BUILDER, "Create netif mgr. value1=%{public}s, value2=%{public}s", value1, value2);
198 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
199 } else {
200 LNN_LOGE(LNN_BUILDER, "Create netif mgr failed, value1=%{public}s, value2=%{public}s", value1, value2);
201 }
202 key = strtok_s(NULL, LNN_DELIMITER_OUTSIDE, &outerPtr);
203 }
204 return SOFTBUS_OK;
205 }
206
SetIfNameDefaultVal(void)207 static int32_t SetIfNameDefaultVal(void)
208 {
209 LnnNetIfMgr *netIfMgr = NetifMgrFactory(LNN_ETH_TYPE, LNN_DEFAULT_IF_NAME_ETH);
210 if (netIfMgr == NULL) {
211 LNN_LOGE(LNN_BUILDER, "add default ETH port failed");
212 return SOFTBUS_NETWORK_SET_DEFAULT_VAL_FAILED;
213 }
214 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
215 netIfMgr = NetifMgrFactory(LNN_WLAN_TYPE, LNN_DEFAULT_IF_NAME_WLAN);
216 if (netIfMgr == NULL) {
217 LNN_LOGE(LNN_BUILDER, "add default ETH port failed");
218 return SOFTBUS_NETWORK_SET_DEFAULT_VAL_FAILED;
219 }
220 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
221 netIfMgr = NetifMgrFactory(LNN_BR_TYPE, LNN_DEFAULT_IF_NAME_BR);
222 if (netIfMgr == NULL) {
223 LNN_LOGE(LNN_BUILDER, "add default BR netIfMgr failed");
224 return SOFTBUS_NETWORK_SET_DEFAULT_VAL_FAILED;
225 }
226 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
227 netIfMgr = NetifMgrFactory(LNN_BLE_TYPE, LNN_DEFAULT_IF_NAME_BLE);
228 if (netIfMgr == NULL) {
229 LNN_LOGE(LNN_BUILDER, "add default BLE netIfMgr failed");
230 return SOFTBUS_NETWORK_SET_DEFAULT_VAL_FAILED;
231 }
232 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
233 netIfMgr = NetifMgrFactory(LNN_USB_TYPE, LNN_DEFAULT_IF_NAME_USB_NCM);
234 if (netIfMgr == NULL) {
235 LNN_LOGE(LNN_BUILDER, "add default USB NCM netIfMgr failed");
236 return SOFTBUS_NETWORK_SET_DEFAULT_VAL_FAILED;
237 }
238 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
239 netIfMgr = NetifMgrFactory(LNN_USB_TYPE, LNN_DEFAULT_IF_NAME_USB_WWAN);
240 if (netIfMgr == NULL) {
241 LNN_LOGE(LNN_BUILDER, "add default USB WWAN netIfMgr failed");
242 return SOFTBUS_NETWORK_SET_DEFAULT_VAL_FAILED;
243 }
244 ListTailInsert(&g_netIfNameList, &netIfMgr->node);
245 return SOFTBUS_OK;
246 }
247
LnnInitManagerByConfig(void)248 static int32_t LnnInitManagerByConfig(void)
249 {
250 char netIfName[LNN_MAX_IF_NAME_LEN] = {0};
251 if (SoftbusGetConfig(SOFTBUS_STR_LNN_NET_IF_NAME, (unsigned char *)netIfName, sizeof(netIfName)) != SOFTBUS_OK) {
252 LNN_LOGE(LNN_BUILDER, "get lnn net ifName fail, use default value");
253 if (SetIfNameDefaultVal() != SOFTBUS_OK) {
254 LNN_LOGE(LNN_BUILDER, "default value set fail");
255 return SOFTBUS_NETWORK_SET_DEFAULT_VAL_FAILED;
256 }
257 return SOFTBUS_OK;
258 }
259 int32_t ret = ParseIfNameConfig(netIfName, strlen(netIfName));
260 if (ret != SOFTBUS_OK) {
261 LNN_LOGE(LNN_BUILDER, "ifName str parse fail!");
262 return ret;
263 }
264 return SOFTBUS_OK;
265 }
266
DfxRecordWifiTriggerTimestamp(LnnTriggerReason reason)267 static void DfxRecordWifiTriggerTimestamp(LnnTriggerReason reason)
268 {
269 DfxRecordTriggerTime(reason, EVENT_STAGE_LNN_WIFI_TRIGGER);
270 }
271
NetUserStateEventHandler(const LnnEventBasicInfo * info)272 static void NetUserStateEventHandler(const LnnEventBasicInfo *info)
273 {
274 if (info == NULL || info->event != LNN_EVENT_USER_STATE_CHANGED) {
275 LNN_LOGE(LNN_BUILDER, "wifi user background state change evt handler get invalid param");
276 return;
277 }
278 bool addrType[CONNECTION_ADDR_MAX] = { false };
279 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
280 SoftBusUserState userState = (SoftBusUserState)event->status;
281 switch (userState) {
282 case SOFTBUS_USER_FOREGROUND:
283 g_backgroundState = userState;
284 LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_USER_FOREGROUND");
285 RestartCoapDiscovery();
286 DfxRecordWifiTriggerTimestamp(WIFI_USER_FOREGROUND);
287 break;
288 case SOFTBUS_USER_BACKGROUND:
289 g_backgroundState = userState;
290 LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_USER_BACKGROUND");
291 for (int32_t i = 0; i < CONNECTION_ADDR_MAX; i++) {
292 addrType[i] = true;
293 }
294 if (LnnRequestLeaveByAddrType(addrType, CONNECTION_ADDR_MAX) != SOFTBUS_OK) {
295 LNN_LOGE(LNN_BUILDER, "LNN leave network fail");
296 }
297 break;
298 default:
299 return;
300 }
301 }
302
NetRootDeviceLeaveLnn(void)303 static int32_t NetRootDeviceLeaveLnn(void)
304 {
305 LNN_LOGI(LNN_BUILDER, "enter NetRootDeviceLeaveLnn");
306 int32_t i = 0;
307 int32_t infoNum = 0;
308 NodeBasicInfo *info = NULL;
309 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
310 LNN_LOGE(LNN_BUILDER, "get online node info failed");
311 return SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR;
312 }
313 if (info == NULL || infoNum == 0) {
314 LNN_LOGE(LNN_BUILDER, "get online node is 0");
315 return SOFTBUS_NO_ONLINE_DEVICE;
316 }
317 int32_t ret;
318 NodeInfo nodeInfo;
319 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
320 for (i = 0; i < infoNum; ++i) {
321 ret = LnnGetRemoteNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo);
322 if (ret != SOFTBUS_OK) {
323 continue;
324 }
325 LNN_LOGI(LNN_BUILDER, "device is root, need to offline");
326 LnnRequestLeaveSpecific(info[i].networkId, CONNECTION_ADDR_MAX);
327 AuthRemoveDeviceKeyByUdidPacked(nodeInfo.deviceInfo.deviceUdid);
328 }
329 SoftBusFree(info);
330 return SOFTBUS_OK;
331 }
332
NetDeviceRootStateEventHandler(const LnnEventBasicInfo * info)333 static void NetDeviceRootStateEventHandler(const LnnEventBasicInfo *info)
334 {
335 if (info == NULL || info->event != LNN_EVENT_DEVICE_ROOT_STATE_CHANGED) {
336 LNN_LOGE(LNN_BUILDER, "device root state change evt handler get invalid param");
337 return;
338 }
339 const LnnDeviceRootStateChangeEvent *event = (const LnnDeviceRootStateChangeEvent *)info;
340 SoftBusDeviceRootState deviceRootState = (SoftBusDeviceRootState)event->status;
341 LNN_LOGI(LNN_BUILDER, "device root state=%{public}d", deviceRootState);
342 switch (deviceRootState) {
343 case SOFTBUS_DEVICE_IS_ROOT:
344 g_isDeviceRoot = true;
345 AuthStopListening(AUTH_LINK_TYPE_WIFI);
346 LnnStopPublish();
347 LnnStopDiscovery();
348 NetRootDeviceLeaveLnn();
349 break;
350 case SOFTBUS_DEVICE_NOT_ROOT:
351 break;
352 default:
353 break;
354 }
355 }
356
NetLockStateEventHandler(const LnnEventBasicInfo * info)357 static void NetLockStateEventHandler(const LnnEventBasicInfo *info)
358 {
359 if (info == NULL || info->event != LNN_EVENT_SCREEN_LOCK_CHANGED) {
360 LNN_LOGE(LNN_BUILDER, "wifi user background state change evt handler get invalid param");
361 return;
362 }
363 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
364 SoftBusScreenLockState lockState = (SoftBusScreenLockState)event->status;
365 if (lockState != SOFTBUS_USER_UNLOCK && g_isUnLock) {
366 LNN_LOGI(LNN_BUILDER, "ignore wifi SOFTBUS_SCREEN_UNLOCK");
367 return;
368 }
369 switch (lockState) {
370 case SOFTBUS_USER_UNLOCK:
371 case SOFTBUS_SCREEN_UNLOCK:
372 g_isUnLock = true;
373 LNN_LOGI(LNN_BUILDER, "wifi handle %{public}d", lockState);
374 RestartCoapDiscovery();
375 DfxRecordWifiTriggerTimestamp(WIFI_NET_LOCK_STATE_CHANGED);
376 break;
377 case SOFTBUS_SCREEN_LOCK:
378 LNN_LOGI(LNN_BUILDER, "ignore wifi SOFTBUS_SCREEN_LOCK");
379 break;
380 default:
381 return;
382 }
383 }
384
NetOOBEStateEventHandler(const LnnEventBasicInfo * info)385 static void NetOOBEStateEventHandler(const LnnEventBasicInfo *info)
386 {
387 if (info == NULL || info->event != LNN_EVENT_OOBE_STATE_CHANGED) {
388 LNN_LOGE(LNN_BUILDER, "OOBE state change evt handler get invalid param");
389 return;
390 }
391 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
392 SoftBusOOBEState state = (SoftBusOOBEState)event->status;
393 switch (state) {
394 case SOFTBUS_OOBE_RUNNING:
395 LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_OOBE_RUNNING");
396 break;
397 case SOFTBUS_OOBE_END:
398 __attribute__((fallthrough));
399 case SOFTBUS_FACK_OOBE_END:
400 LNN_LOGI(LNN_BUILDER, "wifi handle oobe state=%{public}d", state);
401 if (!g_isOOBEEnd) {
402 g_isOOBEEnd = true;
403 RestartCoapDiscovery();
404 DfxRecordWifiTriggerTimestamp(WIFI_FACK_OOBE);
405 }
406 break;
407 default:
408 return;
409 }
410 }
411
RetryCheckOOBEState(void * para)412 static void RetryCheckOOBEState(void *para)
413 {
414 (void)para;
415
416 if (!IsOOBEState()) {
417 LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_OOBE_END");
418 LnnNotifyOOBEStateChangeEvent(SOFTBUS_OOBE_END);
419 } else {
420 LNN_LOGD(LNN_BUILDER, "check OOBE again after a delay. delay=%{public}" PRIu64 "ms",
421 (uint64_t)LNN_CHECK_OOBE_DELAY_LEN);
422 LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), RetryCheckOOBEState, NULL, LNN_CHECK_OOBE_DELAY_LEN);
423 }
424 }
425
DataShareStateEventHandler(const LnnEventBasicInfo * info)426 static void DataShareStateEventHandler(const LnnEventBasicInfo *info)
427 {
428 if (info == NULL || info->event != LNN_EVENT_DATA_SHARE_STATE_CHANGE) {
429 LNN_LOGE(LNN_BUILDER, "Data share get invalid param");
430 return;
431 }
432
433 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
434 SoftBusDataShareState state = (SoftBusDataShareState)event->status;
435 switch (state) {
436 case SOFTBUS_DATA_SHARE_READY:
437 if (SoftBusMutexLock(&g_dataShareLock) != SOFTBUS_OK) {
438 LNN_LOGE(LNN_BUILDER, "gen data share mutex fail");
439 return;
440 }
441 LNN_LOGI(LNN_BUILDER, "data share state is=%{public}d", g_isDataShareInit);
442 if (!g_isDataShareInit) {
443 g_isDataShareInit = true;
444 LnnInitOOBEStateMonitorImplPacked();
445 RetryCheckOOBEState(NULL);
446 }
447 (void)SoftBusMutexUnlock(&g_dataShareLock);
448 LnnInitModuleStatusSet(INIT_DEPS_DATA_SHARE, DEPS_STATUS_SUCCESS);
449 break;
450 default:
451 LnnInitModuleStatusSet(INIT_DEPS_DATA_SHARE, DEPS_STATUS_FAILED);
452 LnnInitModuleReturnSet(INIT_DEPS_DATA_SHARE, SOFTBUS_NETWORK_DATA_SHARE_QUERY_FAILED);
453 if (SoftBusMutexLock(&g_dataShareLock) != SOFTBUS_OK) {
454 LNN_LOGE(LNN_BUILDER, "gen data share mutex fail");
455 return;
456 }
457 g_isDataShareInit = false;
458 (void)SoftBusMutexUnlock(&g_dataShareLock);
459 }
460 }
461
LnnGetDataShareInitResult(bool * isDataShareInit)462 void LnnGetDataShareInitResult(bool *isDataShareInit)
463 {
464 if (isDataShareInit == NULL) {
465 LNN_LOGE(LNN_BUILDER, "Data share get invalid param");
466 return;
467 }
468 if (SoftBusMutexLock(&g_dataShareLock) != SOFTBUS_OK) {
469 LNN_LOGE(LNN_BUILDER, "gen data share mutex fail");
470 return;
471 }
472 *isDataShareInit = g_isDataShareInit;
473 (void)SoftBusMutexUnlock(&g_dataShareLock);
474 }
475
LnnClearNetConfigList(void)476 int32_t LnnClearNetConfigList(void)
477 {
478 LnnNetIfMgr *item = NULL;
479 LnnNetIfMgr *next = NULL;
480
481 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_netIfNameList, LnnNetIfMgr, node)
482 {
483 ListDelete(&item->node);
484 SoftBusFree(item);
485 }
486 return SOFTBUS_OK;
487 }
488
LnnRegistProtocol(LnnProtocolManager * protocolMgr)489 int32_t LnnRegistProtocol(LnnProtocolManager *protocolMgr)
490 {
491 int32_t ret = SOFTBUS_OK;
492
493 if (protocolMgr == NULL || protocolMgr->getListenerModule == NULL || protocolMgr->init == NULL ||
494 protocolMgr->enable == NULL) {
495 LNN_LOGE(LNN_BUILDER, "bad input protocol");
496 return SOFTBUS_INVALID_PARAM;
497 }
498 for (uint8_t i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
499 if (g_networkProtocols[i] != NULL) {
500 continue;
501 }
502 if (protocolMgr->init != NULL) {
503 ret = protocolMgr->init(protocolMgr);
504 if (ret != SOFTBUS_OK) {
505 LNN_LOGE(LNN_BUILDER, "init network protocol failed! ret=%{public}d", ret);
506 break;
507 }
508 } else {
509 LNN_LOGW(LNN_BUILDER, "network protocol have no init. supportedNetif=%{public}u",
510 protocolMgr->supportedNetif);
511 }
512 g_networkProtocols[i] = protocolMgr;
513 break;
514 }
515 return ret;
516 }
517
UnregistProtocol(LnnProtocolManager * protocolMgr)518 int32_t UnregistProtocol(LnnProtocolManager *protocolMgr)
519 {
520 uint8_t i;
521 if (protocolMgr == NULL) {
522 LNN_LOGE(LNN_BUILDER, "protocoMgr is null");
523 return SOFTBUS_INVALID_PARAM;
524 }
525 for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
526 if (g_networkProtocols[i] == protocolMgr) {
527 g_networkProtocols[i] = NULL;
528 if (protocolMgr->deinit != NULL) {
529 protocolMgr->deinit(protocolMgr);
530 }
531 return SOFTBUS_OK;
532 }
533 }
534 LNN_LOGE(LNN_BUILDER, "no such protocol!");
535 return SOFTBUS_NETWORK_NOT_SUPPORT;
536 }
537
LnnVisitNetif(VisitNetifCallback callback,void * data)538 bool LnnVisitNetif(VisitNetifCallback callback, void *data)
539 {
540 LnnNetIfMgr *item = NULL;
541 VisitNextChoice result = CHOICE_VISIT_NEXT;
542 LIST_FOR_EACH_ENTRY(item, &g_netIfNameList, LnnNetIfMgr, node)
543 {
544 result = callback(item, data);
545 if (result == CHOICE_FINISH_VISITING) {
546 return false;
547 }
548 }
549 return true;
550 }
551
LnnVisitProtocol(VisitProtocolCallback callback,void * data)552 bool LnnVisitProtocol(VisitProtocolCallback callback, void *data)
553 {
554 VisitNextChoice result = CHOICE_VISIT_NEXT;
555 for (uint8_t i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
556 if (g_networkProtocols[i] == NULL) {
557 continue;
558 }
559 result = callback(g_networkProtocols[i], data);
560 if (result == CHOICE_FINISH_VISITING) {
561 return false;
562 }
563 }
564 return true;
565 }
566
RestartCoapDiscovery(void)567 void RestartCoapDiscovery(void)
568 {
569 char ifName[NET_IF_NAME_LEN] = {0};
570 int32_t authPort = 0;
571 if (!LnnIsAutoNetWorkingEnabled()) {
572 LNN_LOGW(LNN_BUILDER, "network is disabled yet, dont restart coap discovery");
573 return;
574 }
575 if (LnnGetLocalStrInfoByIfnameIdx(STRING_KEY_NET_IF_NAME, ifName, NET_IF_NAME_LEN, WLAN_IF) != SOFTBUS_OK) {
576 LNN_LOGE(LNN_BUILDER, "get local ifName error!");
577 return;
578 }
579 if (strncmp(ifName, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) == 0) {
580 LNN_LOGI(LNN_BUILDER, "ip invalid now, stop restart coap discovery");
581 return;
582 }
583 if (LnnGetLocalNumInfoByIfnameIdx(NUM_KEY_AUTH_PORT, &authPort, WLAN_IF) != SOFTBUS_OK) {
584 LNN_LOGE(LNN_BUILDER, "get local auth port failed.");
585 return;
586 }
587 LNN_LOGI(LNN_BUILDER, "open previous discovery again");
588 DiscLinkStatusChanged(LINK_STATUS_UP, COAP, WLAN_IF);
589 LnnStopPublish();
590 if (LnnStartPublish() != SOFTBUS_OK) {
591 LNN_LOGE(LNN_BUILDER, "start publish failed");
592 }
593 LnnStopDiscovery();
594 if (LnnStartDiscovery() != SOFTBUS_OK) {
595 LNN_LOGE(LNN_BUILDER, "start discovery failed");
596 }
597 }
598
OnGroupCreated(const char * groupId,int32_t groupType)599 static void OnGroupCreated(const char *groupId, int32_t groupType)
600 {
601 (void)groupId;
602 LNN_LOGI(LNN_BUILDER, "OnGroupCreated, groupType=%{public}d", groupType);
603 LnnUpdateOhosAccount(UPDATE_ACCOUNT_ONLY);
604 LnnHbOnTrustedRelationIncreased(groupType);
605 if (groupType == AUTH_IDENTICAL_ACCOUNT_GROUP) {
606 LnnNotifyAccountStateChangeEvent(SOFTBUS_ACCOUNT_LOG_IN);
607 }
608 RestartCoapDiscovery();
609 DfxRecordWifiTriggerTimestamp(WIFI_GROUP_CREATED);
610 EhLoginEventHandlerPacked();
611 }
612
OnGroupDeleted(const char * groupId,int32_t groupType)613 static void OnGroupDeleted(const char *groupId, int32_t groupType)
614 {
615 (void)groupId;
616 LNN_LOGD(LNN_BUILDER, "wifi handle OnGroupDeleted");
617 if (groupType == AUTH_IDENTICAL_ACCOUNT_GROUP) {
618 LnnOnOhosAccountLogout();
619 }
620 LnnHbOnTrustedRelationReduced();
621 }
622
RestartCoapDiscoveryDelay(void * para)623 static void RestartCoapDiscoveryDelay(void *para)
624 {
625 (void)para;
626 RestartCoapDiscovery();
627 }
628
OnDeviceBound(const char * udid,const char * groupInfo)629 static void OnDeviceBound(const char *udid, const char *groupInfo)
630 {
631 (void)groupInfo;
632 if (LnnGetOnlineStateById(udid, CATEGORY_UDID)) {
633 LNN_LOGD(LNN_BUILDER, "device is online, no need to start discovery");
634 return;
635 }
636 LnnHbOnTrustedRelationIncreased(AUTH_PEER_TO_PEER_GROUP);
637 LNN_LOGD(LNN_BUILDER, "wifi handle OnDeviceBound");
638 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), RestartCoapDiscoveryDelay, NULL,
639 LNN_RESTART_DISCOVERY_DELAY_LEN) != SOFTBUS_OK) {
640 LNN_LOGE(LNN_HEART_BEAT, "restart coap discovery delay fail");
641 }
642 DfxRecordWifiTriggerTimestamp(WIFI_DEVICE_BOUND);
643 }
644
645 static GroupChangeListener g_groupChangeListener = {
646 .onGroupCreated = OnGroupCreated,
647 .onGroupDeleted = OnGroupDeleted,
648 .onDeviceBound = OnDeviceBound,
649 };
650
GetAllProtocols(const LnnProtocolManager * manager,void * data)651 static VisitNextChoice GetAllProtocols(const LnnProtocolManager *manager, void *data)
652 {
653 if (manager == NULL || data == NULL) {
654 return CHOICE_FINISH_VISITING;
655 }
656
657 ProtocolType *type = (ProtocolType *)data;
658 *type |= manager->id;
659 return CHOICE_VISIT_NEXT;
660 }
661
RestoreBrNetworkDevices(void)662 static void RestoreBrNetworkDevices(void)
663 {
664 DeviceNightMode *item = NULL;
665 DeviceNightMode *next = NULL;
666 LnnDfxDeviceInfoReport infoReport;
667 (void)memset_s(&infoReport, sizeof(LnnDfxDeviceInfoReport), 0, sizeof(LnnDfxDeviceInfoReport));
668 LIST_FOR_EACH_ENTRY_SAFE(item, next, g_nightOnCache, DeviceNightMode, node) {
669 if (LnnNotifyDiscoveryDevice(&(item->addrs), &infoReport, true) != SOFTBUS_OK) {
670 LNN_LOGE(LNN_BUILDER, "notify device found failed\n");
671 }
672 ListDelete(&item->node);
673 SoftBusFree(item);
674 }
675 SoftBusFree(g_nightOnCache);
676 g_nightOnCache = NULL;
677 }
678
SaveBrNetworkDevices(void)679 static void SaveBrNetworkDevices(void)
680 {
681 int32_t infoNum = 0;
682 NodeBasicInfo *netInfo = NULL;
683 if (LnnGetAllOnlineNodeInfo(&netInfo, &infoNum) != SOFTBUS_OK) {
684 LNN_LOGE(LNN_BUILDER, "night mode on: get all online node info fail.");
685 }
686
687 NodeInfo nodeInfo;
688 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
689 for (int32_t i = 0; i < infoNum; i++) {
690 if (LnnGetRemoteNodeInfoById(netInfo[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
691 LNN_LOGE(LNN_BUILDER, "night mode on: GetRemoteNodeInfo fail.");
692 continue;
693 }
694 if (!LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_BR)) {
695 LNN_LOGE(LNN_BUILDER, "night mode on: ignore no br network device.");
696 continue;
697 }
698 DeviceNightMode *modeInfo = (DeviceNightMode *)SoftBusMalloc(sizeof(DeviceNightMode));
699 if (modeInfo == NULL) {
700 LNN_LOGE(LNN_BUILDER, "mode info malloc fail.");
701 continue;
702 }
703 if (strcpy_s(modeInfo->addrs.info.br.brMac, BT_MAC_LEN, nodeInfo.connectInfo.macAddr) != EOK) {
704 LNN_LOGE(LNN_BUILDER, "night mode on: str copy fail.");
705 SoftBusFree(modeInfo);
706 continue;
707 }
708 modeInfo->addrs.type = CONNECTION_ADDR_BR;
709 ListNodeInsert(g_nightOnCache, &modeInfo->node);
710 }
711 SoftBusFree(netInfo);
712 }
713
NightModeChangeEventHandler(const LnnEventBasicInfo * info)714 static void NightModeChangeEventHandler(const LnnEventBasicInfo *info)
715 {
716 bool addrType[CONNECTION_ADDR_MAX] = {0};
717 if (info == NULL || info->event != LNN_EVENT_NIGHT_MODE_CHANGED) {
718 LNN_LOGE(LNN_BUILDER, "not interest event");
719 return;
720 }
721 if (g_nightOnCache == NULL) {
722 LNN_LOGD(LNN_BUILDER, "init g_nightOnCache");
723 g_nightOnCache = (ListNode *)SoftBusMalloc(sizeof(ListNode));
724 if (g_nightOnCache == NULL) {
725 LNN_LOGE(LNN_BUILDER, "malloc g_nightOnCache fail");
726 return;
727 }
728 ListInit(g_nightOnCache);
729 }
730 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
731 if (event->status == SOFTBUS_NIGHT_MODE_OFF) {
732 LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_NIGHT_MODE_OFF");
733 g_isNightMode = false;
734 RestartCoapDiscovery();
735 DfxRecordWifiTriggerTimestamp(WIFI_NIGHT_MODE_CHANGED);
736 RestoreBrNetworkDevices();
737 return;
738 }
739 if (event->status == SOFTBUS_NIGHT_MODE_ON) {
740 LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_NIGHT_MODE_ON");
741 g_isNightMode = true;
742 SaveBrNetworkDevices();
743 for (int32_t i = 0; i < CONNECTION_ADDR_MAX; i++) {
744 addrType[i] = true;
745 }
746 if (LnnRequestLeaveByAddrType(addrType, CONNECTION_ADDR_MAX) != SOFTBUS_OK) {
747 LNN_LOGE(LNN_BUILDER, "LNN leave network fail");
748 }
749 }
750 }
751
NetAccountStateChangeEventHandler(const LnnEventBasicInfo * info)752 static void NetAccountStateChangeEventHandler(const LnnEventBasicInfo *info)
753 {
754 if (info == NULL || info->event != LNN_EVENT_ACCOUNT_CHANGED) {
755 LNN_LOGE(LNN_BUILDER, "account state change evt handler get invalid param");
756 return;
757 }
758 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent*)info;
759 SoftBusAccountState accountState = (SoftBusAccountState)event->status;
760 switch (accountState) {
761 case SOFTBUS_ACCOUNT_LOG_IN:
762 LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_ACCOUNT_LOG_IN");
763 RestartCoapDiscovery();
764 DfxRecordWifiTriggerTimestamp(WIFI_NET_ACCOUNT_STATE_CHANGED);
765 break;
766 case SOFTBUS_ACCOUNT_LOG_OUT:
767 LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_ACCOUNT_LOG_OUT");
768 LnnHbOnTrustedRelationReduced();
769 break;
770 default:
771 return;
772 }
773 }
774
RegistProtocolManager(void)775 static int32_t RegistProtocolManager(void)
776 {
777 int32_t ret = SOFTBUS_NOT_IMPLEMENT;
778 #ifdef ENABLE_FEATURE_LNN_WIFI
779 ret = RegistIPProtocolManager();
780 if (ret != SOFTBUS_OK) {
781 LNN_LOGE(LNN_BUILDER, "regist ip protocol manager failed, ret=%{public}d", ret);
782 return ret;
783 }
784 LNN_LOGI(LNN_BUILDER, "IP protocol registed.");
785 ret = RegistUsbProtocolManager();
786 if (ret != SOFTBUS_OK) {
787 LNN_LOGE(LNN_BUILDER, "regist usb protocol manager failed, ret=%{public}d", ret);
788 return ret;
789 }
790 LNN_LOGI(LNN_BUILDER, "USB protocol registed.");
791 #endif
792 ret = RegistBtProtocolManager();
793 if (ret != SOFTBUS_OK) {
794 LNN_LOGE(LNN_BUILDER, "regist bt protocol manager failed, ret=%{public}d", ret);
795 return ret;
796 }
797 LNN_LOGI(LNN_BUILDER, "BT protocol registed.");
798 ret = RegistNewIPProtocolManager();
799 if (ret != SOFTBUS_OK) {
800 LNN_LOGE(LNN_BUILDER, "regist newip protocol manager failed, ret=%{public}d", ret);
801 return ret;
802 }
803 return SOFTBUS_OK;
804 }
805
LnnRegisterEvent(void)806 static int32_t LnnRegisterEvent(void)
807 {
808 if (LnnRegisterEventHandler(LNN_EVENT_NIGHT_MODE_CHANGED, NightModeChangeEventHandler) != SOFTBUS_OK) {
809 LNN_LOGE(LNN_BUILDER, "register night mode change event handler fail");
810 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
811 }
812 if (LnnRegisterEventHandler(LNN_EVENT_USER_STATE_CHANGED, NetUserStateEventHandler) != SOFTBUS_OK) {
813 LNN_LOGE(LNN_BUILDER, "Net regist user background evt handler fail");
814 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
815 }
816 if (LnnRegisterEventHandler(LNN_EVENT_SCREEN_LOCK_CHANGED, NetLockStateEventHandler) != SOFTBUS_OK) {
817 LNN_LOGE(LNN_BUILDER, "Net regist user unlock evt handler fail");
818 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
819 }
820 if (LnnRegisterEventHandler(LNN_EVENT_OOBE_STATE_CHANGED, NetOOBEStateEventHandler) != SOFTBUS_OK) {
821 LNN_LOGE(LNN_BUILDER, "Net regist OOBE state evt handler fail");
822 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
823 }
824 if (LnnRegisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, NetAccountStateChangeEventHandler) != SOFTBUS_OK) {
825 LNN_LOGE(LNN_BUILDER, "Net regist account change evt handler fail");
826 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
827 }
828 if (LnnRegisterEventHandler(LNN_EVENT_DATA_SHARE_STATE_CHANGE, DataShareStateEventHandler) != SOFTBUS_OK) {
829 LNN_LOGE(LNN_BUILDER, "Net regist data share evt handler fail");
830 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
831 }
832 if (LnnRegisterEventHandler(LNN_EVENT_DEVICE_ROOT_STATE_CHANGED, NetDeviceRootStateEventHandler) != SOFTBUS_OK) {
833 LNN_LOGE(LNN_BUILDER, "Net regist device root evt handler fail");
834 return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
835 }
836 return SOFTBUS_OK;
837 }
838
LnnInitNetworkManager(void)839 int32_t LnnInitNetworkManager(void)
840 {
841 if (SoftBusMutexInit(&g_dataShareLock, NULL) != SOFTBUS_OK) {
842 LNN_LOGE(LNN_BUILDER, "softbus mutex init fail");
843 return SOFTBUS_NO_INIT;
844 }
845 RegistNetIfMgr(LNN_ETH_TYPE, CreateNetifMgr);
846 RegistNetIfMgr(LNN_WLAN_TYPE, CreateNetifMgr);
847 RegistNetIfMgr(LNN_BR_TYPE, CreateNetifMgr);
848 RegistNetIfMgr(LNN_BLE_TYPE, CreateNetifMgr);
849 RegistNetIfMgr(LNN_USB_TYPE, CreateNetifMgr);
850
851 int32_t ret = LnnInitManagerByConfig();
852 if (ret != SOFTBUS_OK) {
853 LNN_LOGE(LNN_BUILDER, "Read net config failed, ret=%{public}d", ret);
854 return ret;
855 }
856 // Regist default protocols
857 ret = RegistProtocolManager();
858 if (ret != SOFTBUS_OK) {
859 LNN_LOGE(LNN_BUILDER, "regist default protocol manager failed, ret=%{public}d", ret);
860 return ret;
861 }
862 ret = RegGroupChangeListener(&g_groupChangeListener);
863 if (ret != SOFTBUS_OK) {
864 LNN_LOGE(LNN_BUILDER, "register group change listener fail");
865 return ret;
866 }
867 #ifdef ENABLE_FEATURE_LNN_WIFI
868 ret = LnnInitPhysicalSubnetManager();
869 if (ret != SOFTBUS_OK) {
870 LNN_LOGE(LNN_BUILDER, "init subnet manager failed, ret=%{public}d", ret);
871 return ret;
872 }
873 #endif
874 ret = LnnInitUsbChannelManager();
875 if (ret != SOFTBUS_OK) {
876 LNN_LOGE(LNN_BUILDER, "init usb channel manager failed, ret=%{public}d", ret);
877 return ret;
878 }
879 ProtocolType type = 0;
880 if (!LnnVisitProtocol(GetAllProtocols, &type)) {
881 LNN_LOGE(LNN_BUILDER, "Get all protocol failed");
882 return SOFTBUS_NETWORK_MANAGER_INIT_FAILED;
883 }
884 LNN_LOGI(LNN_BUILDER, "set supported protocol type. type=%{public}u", type);
885 ret = LnnSetLocalNum64Info(NUM_KEY_TRANS_PROTOCOLS, (int64_t)type);
886 if (ret != SOFTBUS_OK) {
887 LNN_LOGE(LNN_BUILDER, "set supported protocol failed, ret=%{public}d", ret);
888 return ret;
889 }
890 return LnnRegisterEvent();
891 }
892
LnnSetUnlockState(void)893 void LnnSetUnlockState(void)
894 {
895 if (IsActiveOsAccountUnlocked()) {
896 g_isUnLock = true;
897 }
898 }
899
LnnInitNetworkManagerDelay(void)900 int32_t LnnInitNetworkManagerDelay(void)
901 {
902 uint32_t i;
903 char udid[UDID_BUF_LEN] = {0};
904
905 if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
906 LNN_LOGE(LNN_INIT, "get local udid error");
907 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
908 }
909 LnnNetIfMgr *item = NULL;
910 LIST_FOR_EACH_ENTRY(item, &g_netIfNameList, LnnNetIfMgr, node) {
911 for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; ++i) {
912 if (g_networkProtocols[i] == NULL) {
913 continue;
914 }
915 if ((g_networkProtocols[i]->supportedNetif & item->type) != 0) {
916 int32_t ret = g_networkProtocols[i]->enable(g_networkProtocols[i], item);
917 if (ret != SOFTBUS_OK) {
918 LNN_LOGE(LNN_INIT, "enable for netif failed. protocol=%{public}d, ifName=%{public}s", i,
919 item->ifName);
920 }
921 LNN_LOGI(LNN_INIT, "enable for netif success. protocol=%{public}d, ifName=%{public}s", i, item->ifName);
922 }
923 }
924 }
925 return SOFTBUS_OK;
926 }
927
LnnIsAutoNetWorkingEnabled(void)928 bool LnnIsAutoNetWorkingEnabled(void)
929 {
930 int32_t localDevTypeId = 0;
931 bool isInitCheckSuc = IsLnnInitCheckSucceed(MONITOR_WIFI_NET);
932 if (LnnGetLocalNumInfo(NUM_KEY_DEV_TYPE_ID, &localDevTypeId) == SOFTBUS_OK &&
933 (localDevTypeId == TYPE_WATCH_ID || localDevTypeId == TYPE_GLASS_ID)) {
934 return false;
935 }
936 bool isConfigEnabled = false;
937 if (IsActiveOsAccountUnlocked()) {
938 g_isUnLock = true;
939 }
940 if (SoftbusGetConfig(SOFTBUS_INT_AUTO_NETWORKING_SWITCH, (unsigned char *)&isConfigEnabled,
941 sizeof(isConfigEnabled)) != SOFTBUS_OK) {
942 LNN_LOGE(LNN_BUILDER, "Cannot get autoNetworkingSwitch from config file");
943 return true;
944 }
945 LNN_LOGI(LNN_BUILDER,
946 "wifi condition state:config=%{public}d, background=%{public}d, nightMode=%{public}d, OOBEEnd=%{public}d, "
947 "unlock=%{public}d, init check=%{public}d, deviceRoot=%{public}d",
948 isConfigEnabled, g_backgroundState == SOFTBUS_USER_BACKGROUND, g_isNightMode, g_isOOBEEnd, g_isUnLock,
949 isInitCheckSuc, g_isDeviceRoot);
950 return isConfigEnabled && (g_backgroundState == SOFTBUS_USER_FOREGROUND) && !g_isNightMode &&
951 g_isOOBEEnd && g_isUnLock && isInitCheckSuc && !g_isDeviceRoot;
952 }
953
LnnDeinitNetworkManager(void)954 void LnnDeinitNetworkManager(void)
955 {
956 if (g_nightOnCache != NULL) {
957 DeviceNightMode *item = NULL;
958 DeviceNightMode *next = NULL;
959 LIST_FOR_EACH_ENTRY_SAFE(item, next, g_nightOnCache, DeviceNightMode, node) {
960 ListDelete(&item->node);
961 SoftBusFree(item);
962 }
963 SoftBusFree(g_nightOnCache);
964 g_nightOnCache = NULL;
965 }
966 uint32_t i;
967 if (LnnClearNetConfigList() != SOFTBUS_OK) {
968 LNN_LOGE(LNN_INIT, "deinit network manager failed");
969 }
970 #ifdef ENABLE_FEATURE_LNN_WIFI
971 LnnDeinitPhysicalSubnetManager();
972 #endif
973 LnnDeinitUsbChannelManager();
974 for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; ++i) {
975 if (g_networkProtocols[i] == NULL || g_networkProtocols[i]->deinit == NULL) {
976 continue;
977 }
978 g_networkProtocols[i]->deinit(g_networkProtocols[i]);
979 g_networkProtocols[i] = NULL;
980 }
981 LnnUnregisterEventHandler(LNN_EVENT_NIGHT_MODE_CHANGED, NightModeChangeEventHandler);
982 LnnUnregisterEventHandler(LNN_EVENT_USER_STATE_CHANGED, NetUserStateEventHandler);
983 LnnUnregisterEventHandler(LNN_EVENT_SCREEN_LOCK_CHANGED, NetLockStateEventHandler);
984 LnnUnregisterEventHandler(LNN_EVENT_OOBE_STATE_CHANGED, NetOOBEStateEventHandler);
985 LnnUnregisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, NetAccountStateChangeEventHandler);
986 LnnUnregisterEventHandler(LNN_EVENT_DATA_SHARE_STATE_CHANGE, DataShareStateEventHandler);
987 LnnUnregisterEventHandler(LNN_EVENT_DEVICE_ROOT_STATE_CHANGED, NetDeviceRootStateEventHandler);
988 (void)SoftBusMutexDestroy(&g_dataShareLock);
989 }
990
LnnGetNetIfTypeByName(const char * ifName,LnnNetIfType * type)991 int32_t LnnGetNetIfTypeByName(const char *ifName, LnnNetIfType *type)
992 {
993 if (ifName == NULL || type == NULL) {
994 LNN_LOGE(LNN_BUILDER, "parameters is NULL");
995 return SOFTBUS_INVALID_PARAM;
996 }
997 LnnNetIfMgr *netif = NULL;
998 LIST_FOR_EACH_ENTRY(netif, &g_netIfNameList, LnnNetIfMgr, node) {
999 if (strncmp(ifName, netif->ifName, sizeof(netif->ifName)) == 0) {
1000 *type = netif->type;
1001 return SOFTBUS_OK;
1002 }
1003 }
1004 return SOFTBUS_NETWORK_NOT_FOUND;
1005 }
1006
LnnGetAddrTypeByIfName(const char * ifName,ConnectionAddrType * type)1007 int32_t LnnGetAddrTypeByIfName(const char *ifName, ConnectionAddrType *type)
1008 {
1009 if (type == NULL || ifName == NULL) {
1010 LNN_LOGE(LNN_BUILDER, "parameters is NULL");
1011 return SOFTBUS_INVALID_PARAM;
1012 }
1013 LnnNetIfType netifType;
1014 int32_t ret = LnnGetNetIfTypeByName(ifName, &netifType);
1015 if (ret != SOFTBUS_OK) {
1016 return ret;
1017 }
1018 switch (netifType) {
1019 case LNN_NETIF_TYPE_ETH:
1020 *type = CONNECTION_ADDR_ETH;
1021 break;
1022 case LNN_NETIF_TYPE_WLAN:
1023 *type = CONNECTION_ADDR_WLAN;
1024 break;
1025 case LNN_NETIF_TYPE_BR:
1026 *type = CONNECTION_ADDR_BR;
1027 break;
1028 case LNN_NETIF_TYPE_BLE:
1029 *type = CONNECTION_ADDR_BLE;
1030 break;
1031 case LNN_NETIF_TYPE_USB:
1032 *type = CONNECTION_ADDR_NCM;
1033 break;
1034 default:
1035 ret = SOFTBUS_NETWORK_NOT_SUPPORT;
1036 }
1037 return ret;
1038 }
1039
1040 struct FindProtocolByTypeRequest {
1041 ProtocolType protocol;
1042 const LnnProtocolManager *manager;
1043 };
1044
FindProtocolByType(const LnnProtocolManager * manager,void * data)1045 static VisitNextChoice FindProtocolByType(const LnnProtocolManager *manager, void *data)
1046 {
1047 struct FindProtocolByTypeRequest *request = (struct FindProtocolByTypeRequest *)data;
1048 if (manager->id == request->protocol) {
1049 request->manager = manager;
1050 return CHOICE_FINISH_VISITING;
1051 } else {
1052 return CHOICE_VISIT_NEXT;
1053 }
1054 }
1055
LnnGetProtocolListenerModule(ProtocolType protocol,ListenerMode mode)1056 ListenerModule LnnGetProtocolListenerModule(ProtocolType protocol, ListenerMode mode)
1057 {
1058 struct FindProtocolByTypeRequest request = {.protocol = protocol, .manager = NULL};
1059 if (LnnVisitProtocol(FindProtocolByType, &request)) {
1060 LNN_LOGE(LNN_BUILDER, "not such protocol! protocolId=%{public}d", protocol);
1061 return UNUSE_BUTT;
1062 }
1063 if (request.manager == NULL || request.manager->getListenerModule == NULL) {
1064 LNN_LOGE(LNN_BUILDER, "protocol manager is null, protocolId=%{public}d", protocol);
1065 return UNUSE_BUTT;
1066 }
1067 return request.manager->getListenerModule(mode);
1068 }
1069