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 <securec.h>
19 
20 #include "auth_interface.h"
21 #include "bus_center_event.h"
22 #include "bus_center_manager.h"
23 #include "disc_interface.h"
24 #include "lnn_async_callback_utils.h"
25 #include "lnn_common_utils.h"
26 #include "lnn_discovery_manager.h"
27 #include "lnn_distributed_net_ledger.h"
28 #include "lnn_fast_offline.h"
29 #include "lnn_heartbeat_ctrl.h"
30 #include "lnn_log.h"
31 #include "lnn_net_builder.h"
32 #include "lnn_ohos_account.h"
33 #include "lnn_physical_subnet_manager.h"
34 #include "softbus_adapter_mem.h"
35 #include "softbus_def.h"
36 #include "softbus_errcode.h"
37 #include "softbus_feature_config.h"
38 
39 #define LNN_MAX_IF_NAME_LEN   256
40 #define LNN_DELIMITER_OUTSIDE ","
41 #define LNN_DELIMITER_INSIDE  ":"
42 
43 #define LNN_DEFAULT_IF_NAME_WLAN "wlan0"
44 #define LNN_DEFAULT_IF_NAME_ETH  "eth0"
45 #define LNN_DEFAULT_IF_NAME_BR   "br0"
46 #define LNN_DEFAULT_IF_NAME_BLE  "ble0"
47 
48 #define LNN_CHECK_OOBE_DELAY_LEN (5 * 60 * 1000LL)
49 
50 typedef enum {
51     LNN_ETH_TYPE = 0,
52     LNN_WLAN_TYPE,
53     LNN_BR_TYPE,
54     LNN_BLE_TYPE,
55     LNN_MAX_NUM_TYPE,
56 } LnnNetIfNameType;
57 
58 static ListNode g_netIfNameList = {
59     .prev = &g_netIfNameList,
60     .next = &g_netIfNameList,
61 };
62 
63 static ListNode *g_nightOnCache = NULL;
64 
65 typedef struct {
66     ListNode node;
67     ConnectionAddr addrs;
68 } DeviceNightMode;
69 
70 static bool g_isNightMode = false;
71 static bool g_isOOBEEnd = false;
72 static bool g_isUnLock = false;
73 static SoftBusUserState g_backgroundState = SOFTBUS_USER_FOREGROUND;
74 
75 int32_t RegistIPProtocolManager(void);
76 int32_t RegistNewIPProtocolManager(void);
77 
RegistNewIPProtocolManager(void)78 int32_t __attribute__((weak)) RegistNewIPProtocolManager(void)
79 {
80     return SOFTBUS_OK;
81 }
82 
RegistBtProtocolManager(void)83 int32_t __attribute__((weak)) RegistBtProtocolManager(void)
84 {
85     LNN_LOGW(LNN_BUILDER, "regist virtual bt protocol manager");
86     return SOFTBUS_OK;
87 }
88 
89 static LnnNetIfManagerBuilder g_netifBuilders[LNN_MAX_NUM_TYPE] = {0};
90 
91 static LnnProtocolManager *g_networkProtocols[LNN_NETWORK_MAX_PROTOCOL_COUNT] = {0};
92 
CreateNetifMgr(const char * netIfName)93 static LnnNetIfMgr *CreateNetifMgr(const char *netIfName)
94 {
95     if (netIfName == NULL) {
96         LNN_LOGE(LNN_BUILDER, "parameters invalid");
97         return NULL;
98     }
99     LnnNetIfMgr *netIfMgr = (LnnNetIfMgr *)SoftBusCalloc(sizeof(LnnNetIfMgr));
100     if (netIfMgr == NULL) {
101         LNN_LOGE(LNN_BUILDER, "malloc LnnNetIfMgr fail");
102         return NULL;
103     }
104     do {
105         ListInit(&netIfMgr->node);
106         if (strncpy_s(netIfMgr->ifName, NET_IF_NAME_LEN, netIfName, strlen(netIfName)) != EOK) {
107             LNN_LOGE(LNN_BUILDER, "copy netIfName fail");
108             break;
109         }
110         return netIfMgr;
111     } while (false);
112 
113     SoftBusFree(netIfMgr);
114     return NULL;
115 }
116 
RegistNetIfMgr(LnnNetIfNameType type,LnnNetIfManagerBuilder builder)117 static int32_t RegistNetIfMgr(LnnNetIfNameType type, LnnNetIfManagerBuilder builder)
118 {
119     if (type >= LNN_MAX_NUM_TYPE) {
120         LNN_LOGE(LNN_BUILDER, "type too big");
121         return SOFTBUS_ERR;
122     }
123     if (g_netifBuilders[type] != NULL && g_netifBuilders[type] != builder) {
124         LNN_LOGE(LNN_BUILDER, "type already registed");
125         return SOFTBUS_ERR;
126     }
127     g_netifBuilders[type] = builder;
128     return SOFTBUS_OK;
129 }
130 
ConvertToNetIfType(LnnNetIfNameType nameType)131 static LnnNetIfType ConvertToNetIfType(LnnNetIfNameType nameType)
132 {
133     return nameType >= LNN_MAX_NUM_TYPE ? 0 : (0x1 << nameType);
134 }
135 
NetifMgrFactory(LnnNetIfNameType type,const char * ifName)136 static LnnNetIfMgr *NetifMgrFactory(LnnNetIfNameType type, const char *ifName)
137 {
138     if (type >= LNN_MAX_NUM_TYPE) {
139         return NULL;
140     }
141     if (g_netifBuilders[type] == NULL) {
142         LNN_LOGE(LNN_BUILDER, "netif type not supported. type=%{public}d", type);
143         return NULL;
144     }
145     LnnNetIfMgr *netifMgr = g_netifBuilders[type](ifName);
146     if (netifMgr != NULL) {
147         netifMgr->type = ConvertToNetIfType(type);
148     }
149     return netifMgr;
150 }
151 
ParseIfNameConfig(char * buf,uint32_t bufLen)152 static int32_t ParseIfNameConfig(char *buf, uint32_t bufLen)
153 {
154     char *outerPtr = NULL;
155     char *innerPtr = NULL;
156     char *value1 = NULL;
157     char *value2 = NULL;
158     if (buf == NULL || bufLen == 0) {
159         LNN_LOGE(LNN_BUILDER, "parameters invalid");
160         return SOFTBUS_INVALID_PARAM;
161     }
162     char *key = strtok_s(buf, LNN_DELIMITER_OUTSIDE, &outerPtr);
163     while (key != NULL) {
164         value1 = strtok_s(key, LNN_DELIMITER_INSIDE, &innerPtr);
165         value2 = strtok_s(NULL, LNN_DELIMITER_INSIDE, &innerPtr);
166 
167         LnnNetIfMgr *netIfMgr = NetifMgrFactory((LnnNetIfNameType)atoi(value1), value2);
168         if (netIfMgr != NULL) {
169             LNN_LOGW(LNN_BUILDER, "Create netif mgr. value1=%{public}s, value2=%{public}s", value1, value2);
170             ListTailInsert(&g_netIfNameList, &netIfMgr->node);
171         } else {
172             LNN_LOGE(LNN_BUILDER, "Create netif mgr failed, value1=%{public}s, value2=%{public}s", value1, value2);
173         }
174         key = strtok_s(NULL, LNN_DELIMITER_OUTSIDE, &outerPtr);
175     }
176     return SOFTBUS_OK;
177 }
178 
SetIfNameDefaultVal(void)179 static int32_t SetIfNameDefaultVal(void)
180 {
181     LnnNetIfMgr *netIfMgr = NetifMgrFactory(LNN_ETH_TYPE, LNN_DEFAULT_IF_NAME_ETH);
182     if (netIfMgr == NULL) {
183         LNN_LOGE(LNN_BUILDER, "add default ETH port failed");
184         return SOFTBUS_ERR;
185     }
186     ListTailInsert(&g_netIfNameList, &netIfMgr->node);
187     netIfMgr = NetifMgrFactory(LNN_WLAN_TYPE, LNN_DEFAULT_IF_NAME_WLAN);
188     if (netIfMgr == NULL) {
189         LNN_LOGE(LNN_BUILDER, "add default ETH port failed");
190         return SOFTBUS_ERR;
191     }
192     ListTailInsert(&g_netIfNameList, &netIfMgr->node);
193     netIfMgr = NetifMgrFactory(LNN_BR_TYPE, LNN_DEFAULT_IF_NAME_BR);
194     if (netIfMgr == NULL) {
195         LNN_LOGE(LNN_BUILDER, "add default BR netIfMgr failed");
196         return SOFTBUS_ERR;
197     }
198     ListTailInsert(&g_netIfNameList, &netIfMgr->node);
199     netIfMgr = NetifMgrFactory(LNN_BLE_TYPE, LNN_DEFAULT_IF_NAME_BLE);
200     if (netIfMgr == NULL) {
201         LNN_LOGE(LNN_BUILDER, "add default BLE netIfMgr failed");
202         return SOFTBUS_ERR;
203     }
204     ListTailInsert(&g_netIfNameList, &netIfMgr->node);
205     return SOFTBUS_OK;
206 }
207 
LnnInitManagerByConfig(void)208 static int32_t LnnInitManagerByConfig(void)
209 {
210     char netIfName[LNN_MAX_IF_NAME_LEN] = {0};
211     if (SoftbusGetConfig(SOFTBUS_STR_LNN_NET_IF_NAME, (unsigned char *)netIfName, sizeof(netIfName)) != SOFTBUS_OK) {
212         LNN_LOGE(LNN_BUILDER, "get lnn net ifName fail, use default value");
213         if (SetIfNameDefaultVal() != SOFTBUS_OK) {
214             LNN_LOGE(LNN_BUILDER, "default value set fail");
215             return SOFTBUS_ERR;
216         }
217         return SOFTBUS_OK;
218     }
219     int32_t ret = ParseIfNameConfig(netIfName, strlen(netIfName));
220     if (ret != SOFTBUS_OK) {
221         LNN_LOGE(LNN_BUILDER, "ifName str parse fail!");
222         return ret;
223     }
224     return SOFTBUS_OK;
225 }
226 
NetUserStateEventHandler(const LnnEventBasicInfo * info)227 static void NetUserStateEventHandler(const LnnEventBasicInfo *info)
228 {
229     if (info == NULL || info->event != LNN_EVENT_USER_STATE_CHANGED) {
230         LNN_LOGE(LNN_BUILDER, "wifi user background state change evt handler get invalid param");
231         return;
232     }
233     bool addrType[CONNECTION_ADDR_MAX] = {0};
234     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
235     SoftBusUserState userState = (SoftBusUserState)event->status;
236     switch (userState) {
237         case SOFTBUS_USER_FOREGROUND:
238             g_backgroundState = userState;
239             LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_USER_FOREGROUND");
240             RestartCoapDiscovery();
241             break;
242         case SOFTBUS_USER_BACKGROUND:
243             g_backgroundState = userState;
244             LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_USER_BACKGROUND");
245             for (int32_t i = 0; i < CONNECTION_ADDR_MAX; i++) {
246                 addrType[i] = true;
247             }
248             if (LnnRequestLeaveByAddrType(addrType, CONNECTION_ADDR_MAX) != SOFTBUS_OK) {
249                 LNN_LOGE(LNN_BUILDER, "LNN leave network fail");
250             }
251             break;
252         default:
253             return;
254     }
255 }
256 
NetLockStateEventHandler(const LnnEventBasicInfo * info)257 static void NetLockStateEventHandler(const LnnEventBasicInfo *info)
258 {
259     if (info == NULL || info->event != LNN_EVENT_SCREEN_LOCK_CHANGED) {
260         LNN_LOGE(LNN_BUILDER, "wifi user background state change evt handler get invalid param");
261         return;
262     }
263     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
264     SoftBusScreenLockState lockState = (SoftBusScreenLockState)event->status;
265     if (lockState != SOFTBUS_USER_UNLOCK && g_isUnLock) {
266         LNN_LOGI(LNN_BUILDER, "ignore wifi SOFTBUS_SCREEN_UNLOCK");
267         return;
268     }
269     switch (lockState) {
270         case SOFTBUS_USER_UNLOCK:
271         case SOFTBUS_SCREEN_UNLOCK:
272             g_isUnLock = true;
273             LNN_LOGI(LNN_BUILDER, "wifi handle %{public}d", lockState);
274             RestartCoapDiscovery();
275             break;
276         case SOFTBUS_SCREEN_LOCK:
277             LNN_LOGI(LNN_BUILDER, "ignore wifi SOFTBUS_SCREEN_LOCK");
278             break;
279         default:
280             return;
281     }
282 }
283 
NetOOBEStateEventHandler(const LnnEventBasicInfo * info)284 static void NetOOBEStateEventHandler(const LnnEventBasicInfo *info)
285 {
286     if (info == NULL || info->event != LNN_EVENT_OOBE_STATE_CHANGED) {
287         LNN_LOGE(LNN_BUILDER, "OOBE state change evt handler get invalid param");
288         return;
289     }
290     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
291     SoftBusOOBEState state = (SoftBusOOBEState)event->status;
292     switch (state) {
293         case SOFTBUS_OOBE_RUNNING:
294             LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_OOBE_RUNNING");
295             break;
296         case SOFTBUS_OOBE_END:
297             __attribute__((fallthrough));
298         case SOFTBUS_FACK_OOBE_END:
299             LNN_LOGI(LNN_BUILDER, "wifi handle oobe state=%{public}d", state);
300             if (!g_isOOBEEnd) {
301                 g_isOOBEEnd = true;
302                 RestartCoapDiscovery();
303             }
304             break;
305         default:
306             return;
307     }
308 }
309 
LnnClearNetConfigList(void)310 int32_t LnnClearNetConfigList(void)
311 {
312     LnnNetIfMgr *item = NULL;
313     LnnNetIfMgr *next = NULL;
314 
315     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_netIfNameList, LnnNetIfMgr, node)
316     {
317         ListDelete(&item->node);
318         SoftBusFree(item);
319     }
320     return SOFTBUS_OK;
321 }
322 
LnnRegistProtocol(LnnProtocolManager * protocolMgr)323 int32_t LnnRegistProtocol(LnnProtocolManager *protocolMgr)
324 {
325     int32_t ret = SOFTBUS_OK;
326 
327     if (protocolMgr == NULL || protocolMgr->getListenerModule == NULL || protocolMgr->init == NULL ||
328         protocolMgr->enable == NULL) {
329         LNN_LOGE(LNN_BUILDER, "bad input protocol");
330         return SOFTBUS_INVALID_PARAM;
331     }
332     for (uint8_t i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
333         if (g_networkProtocols[i] != NULL) {
334             continue;
335         }
336         if (protocolMgr->init != NULL) {
337             ret = protocolMgr->init(protocolMgr);
338             if (ret != SOFTBUS_OK) {
339                 LNN_LOGE(LNN_BUILDER, "init network protocol failed! ret=%{public}d", ret);
340                 break;
341             }
342         } else {
343             LNN_LOGW(LNN_BUILDER, "network protocol have no init. supportedNetif=%{public}u",
344                 protocolMgr->supportedNetif);
345         }
346         g_networkProtocols[i] = protocolMgr;
347         break;
348     }
349     return ret;
350 }
351 
UnregistProtocol(LnnProtocolManager * protocolMgr)352 int32_t UnregistProtocol(LnnProtocolManager *protocolMgr)
353 {
354     uint8_t i;
355     if (protocolMgr == NULL) {
356         LNN_LOGE(LNN_BUILDER, "protocoMgr is null");
357         return SOFTBUS_INVALID_PARAM;
358     }
359     for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
360         if (g_networkProtocols[i] == protocolMgr) {
361             g_networkProtocols[i] = NULL;
362             if (protocolMgr->deinit != NULL) {
363                 protocolMgr->deinit(protocolMgr);
364             }
365             return SOFTBUS_OK;
366         }
367     }
368     LNN_LOGE(LNN_BUILDER, "no such protocol!");
369     return SOFTBUS_ERR;
370 }
371 
LnnVisitNetif(VisitNetifCallback callback,void * data)372 bool LnnVisitNetif(VisitNetifCallback callback, void *data)
373 {
374     LnnNetIfMgr *item = NULL;
375     VisitNextChoice result = CHOICE_VISIT_NEXT;
376     LIST_FOR_EACH_ENTRY(item, &g_netIfNameList, LnnNetIfMgr, node)
377     {
378         result = callback(item, data);
379         if (result == CHOICE_FINISH_VISITING) {
380             return false;
381         }
382     }
383     return true;
384 }
385 
LnnVisitProtocol(VisitProtocolCallback callback,void * data)386 bool LnnVisitProtocol(VisitProtocolCallback callback, void *data)
387 {
388     VisitNextChoice result = CHOICE_VISIT_NEXT;
389     for (uint8_t i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) {
390         if (g_networkProtocols[i] == NULL) {
391             continue;
392         }
393         result = callback(g_networkProtocols[i], data);
394         if (result == CHOICE_FINISH_VISITING) {
395             return false;
396         }
397     }
398     return true;
399 }
400 
RestartCoapDiscovery(void)401 void RestartCoapDiscovery(void)
402 {
403     char ifName[NET_IF_NAME_LEN] = {0};
404     int32_t authPort = 0;
405     if (!LnnIsAutoNetWorkingEnabled()) {
406         LNN_LOGW(LNN_BUILDER, "network is disabled yet, dont restart coap discovery");
407         return;
408     }
409     if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifName, NET_IF_NAME_LEN) != SOFTBUS_OK) {
410         LNN_LOGE(LNN_BUILDER, "get local ifName error!");
411         return;
412     }
413     if (strncmp(ifName, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) == 0) {
414         LNN_LOGI(LNN_BUILDER, "ip invalid now, stop restart coap discovery");
415         return;
416     }
417     if (LnnGetLocalNumInfo(NUM_KEY_AUTH_PORT, &authPort) != SOFTBUS_OK) {
418         LNN_LOGE(LNN_BUILDER, "get local auth port failed.");
419         return;
420     }
421     LNN_LOGI(LNN_BUILDER, "open previous discovery again");
422     DiscLinkStatusChanged(LINK_STATUS_UP, COAP);
423     LnnStopPublish();
424     if (LnnStartPublish() != SOFTBUS_OK) {
425         LNN_LOGE(LNN_BUILDER, "start publish failed");
426     }
427     LnnStopDiscovery();
428     if (LnnStartDiscovery() != SOFTBUS_OK) {
429         LNN_LOGE(LNN_BUILDER, "start discovery failed");
430     }
431 }
432 
OnGroupCreated(const char * groupId,int32_t groupType)433 static void OnGroupCreated(const char *groupId, int32_t groupType)
434 {
435     (void)groupId;
436     LNN_LOGI(LNN_BUILDER, "OnGroupCreated, groupType=%{public}d", groupType);
437     LnnUpdateOhosAccount(false);
438     LnnHbOnTrustedRelationIncreased(groupType);
439     if (groupType == AUTH_IDENTICAL_ACCOUNT_GROUP) {
440         LnnNotifyAccountStateChangeEvent(SOFTBUS_ACCOUNT_LOG_IN);
441     }
442     RestartCoapDiscovery();
443     EhLoginEventHandler();
444 }
445 
OnGroupDeleted(const char * groupId,int32_t groupType)446 static void OnGroupDeleted(const char *groupId, int32_t groupType)
447 {
448     (void)groupId;
449     LNN_LOGD(LNN_BUILDER, "wifi handle OnGroupDeleted");
450     if (groupType == AUTH_IDENTICAL_ACCOUNT_GROUP) {
451         LnnOnOhosAccountLogout();
452     }
453     LnnHbOnTrustedRelationReduced();
454 }
455 
OnDeviceBound(const char * udid,const char * groupInfo)456 static void OnDeviceBound(const char *udid, const char *groupInfo)
457 {
458     (void)groupInfo;
459     if (LnnGetOnlineStateById(udid, CATEGORY_UDID)) {
460         LNN_LOGD(LNN_BUILDER, "device is online, no need to start discovery");
461         return;
462     }
463     LnnHbOnTrustedRelationIncreased(AUTH_PEER_TO_PEER_GROUP);
464     LNN_LOGD(LNN_BUILDER, "wifi handle OnDeviceBound");
465     RestartCoapDiscovery();
466 }
467 
468 static GroupChangeListener g_groupChangeListener = {
469     .onGroupCreated = OnGroupCreated,
470     .onGroupDeleted = OnGroupDeleted,
471     .onDeviceBound = OnDeviceBound,
472 };
473 
GetAllProtocols(const LnnProtocolManager * manager,void * data)474 static VisitNextChoice GetAllProtocols(const LnnProtocolManager *manager, void *data)
475 {
476     if (manager == NULL || data == NULL) {
477         return CHOICE_FINISH_VISITING;
478     }
479 
480     ProtocolType *type = (ProtocolType *)data;
481     *type |= manager->id;
482     return CHOICE_VISIT_NEXT;
483 }
484 
RestoreBrNetworkDevices(void)485 static void RestoreBrNetworkDevices(void)
486 {
487     DeviceNightMode *item = NULL;
488     DeviceNightMode *next = NULL;
489     LnnDfxDeviceInfoReport infoReport;
490     (void)memset_s(&infoReport, sizeof(LnnDfxDeviceInfoReport), 0, sizeof(LnnDfxDeviceInfoReport));
491     LIST_FOR_EACH_ENTRY_SAFE(item, next, g_nightOnCache, DeviceNightMode, node) {
492         if (LnnNotifyDiscoveryDevice(&(item->addrs), &infoReport, true) != SOFTBUS_OK) {
493             LNN_LOGE(LNN_BUILDER, "notify device found failed\n");
494         }
495         ListDelete(&item->node);
496         SoftBusFree(item);
497     }
498     SoftBusFree(g_nightOnCache);
499     g_nightOnCache = NULL;
500 }
501 
SaveBrNetworkDevices(void)502 static void SaveBrNetworkDevices(void)
503 {
504     int32_t infoNum = 0;
505     NodeBasicInfo *netInfo = NULL;
506     if (LnnGetAllOnlineNodeInfo(&netInfo, &infoNum) != SOFTBUS_OK) {
507         LNN_LOGE(LNN_BUILDER, "night mode on: get all online node info fail.");
508     }
509 
510     NodeInfo nodeInfo;
511     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
512     for (int32_t i = 0; i < infoNum; i++) {
513         if (LnnGetRemoteNodeInfoById(netInfo[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
514             LNN_LOGE(LNN_BUILDER, "night mode on: GetRemoteNodeInfo fail.");
515             continue;
516         }
517         if (!LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_BR)) {
518             LNN_LOGE(LNN_BUILDER, "night mode on: ignore no br network device.");
519             continue;
520         }
521         DeviceNightMode *modeInfo = (DeviceNightMode *)SoftBusMalloc(sizeof(DeviceNightMode));
522         if (modeInfo == NULL) {
523             LNN_LOGE(LNN_BUILDER, "mode info malloc fail.");
524             continue;
525         }
526         if (strcpy_s(modeInfo->addrs.info.br.brMac, BT_MAC_LEN, nodeInfo.connectInfo.macAddr) != EOK) {
527             LNN_LOGE(LNN_BUILDER, "night mode on: str copy fail.");
528             SoftBusFree(modeInfo);
529             continue;
530         }
531         modeInfo->addrs.type = CONNECTION_ADDR_BR;
532         ListNodeInsert(g_nightOnCache, &modeInfo->node);
533     }
534     SoftBusFree(netInfo);
535 }
536 
NightModeChangeEventHandler(const LnnEventBasicInfo * info)537 static void NightModeChangeEventHandler(const LnnEventBasicInfo *info)
538 {
539     bool addrType[CONNECTION_ADDR_MAX] = {0};
540     if (info == NULL || info->event != LNN_EVENT_NIGHT_MODE_CHANGED) {
541         LNN_LOGE(LNN_BUILDER, "not interest event");
542         return;
543     }
544     if (g_nightOnCache == NULL) {
545         LNN_LOGD(LNN_BUILDER, "init g_nightOnCache");
546         g_nightOnCache = (ListNode *)SoftBusMalloc(sizeof(ListNode));
547         if (g_nightOnCache == NULL) {
548             LNN_LOGE(LNN_BUILDER, "malloc g_nightOnCache fail");
549             return;
550         }
551         ListInit(g_nightOnCache);
552     }
553     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
554     if (event->status == SOFTBUS_NIGHT_MODE_OFF) {
555         LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_NIGHT_MODE_OFF");
556         g_isNightMode = false;
557         RestartCoapDiscovery();
558         RestoreBrNetworkDevices();
559         return;
560     }
561     if (event->status == SOFTBUS_NIGHT_MODE_ON) {
562         LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_NIGHT_MODE_ON");
563         g_isNightMode = true;
564         SaveBrNetworkDevices();
565         for (int32_t i = 0; i < CONNECTION_ADDR_MAX; i++) {
566             addrType[i] = true;
567         }
568         if (LnnRequestLeaveByAddrType(addrType, CONNECTION_ADDR_MAX) != SOFTBUS_OK) {
569             LNN_LOGE(LNN_BUILDER, "LNN leave network fail");
570         }
571     }
572 }
573 
NetAccountStateChangeEventHandler(const LnnEventBasicInfo * info)574 static void NetAccountStateChangeEventHandler(const LnnEventBasicInfo *info)
575 {
576     if (info == NULL || info->event != LNN_EVENT_ACCOUNT_CHANGED) {
577         LNN_LOGE(LNN_BUILDER, "account state change evt handler get invalid param");
578         return;
579     }
580     const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent*)info;
581     SoftBusAccountState accountState = (SoftBusAccountState)event->status;
582     switch (accountState) {
583         case SOFTBUS_ACCOUNT_LOG_IN:
584             LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_ACCOUNT_LOG_IN");
585             RestartCoapDiscovery();
586             break;
587         case SOFTBUS_ACCOUNT_LOG_OUT:
588             LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_ACCOUNT_LOG_OUT");
589             LnnHbOnTrustedRelationReduced();
590             break;
591         default:
592             return;
593     }
594 }
595 
RegistProtocolManager(void)596 static int32_t RegistProtocolManager(void)
597 {
598     int32_t ret = RegistIPProtocolManager();
599     if (ret != SOFTBUS_OK) {
600         LNN_LOGE(LNN_BUILDER, "regist ip protocol manager failed, ret=%{public}d", ret);
601         return ret;
602     }
603     LNN_LOGI(LNN_BUILDER, "IP protocol registed.");
604     ret = RegistBtProtocolManager();
605     if (ret != SOFTBUS_OK) {
606         LNN_LOGE(LNN_BUILDER, "regist bt protocol manager failed, ret=%{public}d", ret);
607         return ret;
608     }
609     LNN_LOGI(LNN_BUILDER, "BT protocol registed.");
610     ret = RegistNewIPProtocolManager();
611     if (ret != SOFTBUS_OK) {
612         LNN_LOGE(LNN_BUILDER, "regist newip protocol manager failed, ret=%{public}d", ret);
613         return ret;
614     }
615     return SOFTBUS_OK;
616 }
617 
618 
LnnRegisterEvent(void)619 static int32_t LnnRegisterEvent(void)
620 {
621     if (LnnRegisterEventHandler(LNN_EVENT_NIGHT_MODE_CHANGED, NightModeChangeEventHandler) != SOFTBUS_OK) {
622         LNN_LOGE(LNN_BUILDER, "register night mode change event handler fail");
623         return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
624     }
625     if (LnnRegisterEventHandler(LNN_EVENT_USER_STATE_CHANGED, NetUserStateEventHandler) != SOFTBUS_OK) {
626         LNN_LOGE(LNN_BUILDER, "Net regist user background evt handler fail");
627         return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
628     }
629     if (LnnRegisterEventHandler(LNN_EVENT_SCREEN_LOCK_CHANGED, NetLockStateEventHandler) != SOFTBUS_OK) {
630         LNN_LOGE(LNN_BUILDER, "Net regist user unlock evt handler fail");
631         return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
632     }
633     if (LnnRegisterEventHandler(LNN_EVENT_OOBE_STATE_CHANGED, NetOOBEStateEventHandler) != SOFTBUS_OK) {
634         LNN_LOGE(LNN_BUILDER, "Net regist OOBE state evt handler fail");
635         return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
636     }
637     if (LnnRegisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, NetAccountStateChangeEventHandler) != SOFTBUS_OK) {
638         LNN_LOGE(LNN_BUILDER, "Net regist account change evt handler fail");
639         return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
640     }
641     return SOFTBUS_OK;
642 }
643 
LnnInitNetworkManager(void)644 int32_t LnnInitNetworkManager(void)
645 {
646     RegistNetIfMgr(LNN_ETH_TYPE, CreateNetifMgr);
647     RegistNetIfMgr(LNN_WLAN_TYPE, CreateNetifMgr);
648     RegistNetIfMgr(LNN_BR_TYPE, CreateNetifMgr);
649     RegistNetIfMgr(LNN_BLE_TYPE, CreateNetifMgr);
650 
651     int32_t ret = LnnInitManagerByConfig();
652     if (ret != SOFTBUS_OK) {
653         LNN_LOGE(LNN_BUILDER, "Read net config failed, ret=%{public}d", ret);
654         return ret;
655     }
656     // Regist default protocols
657     ret = RegistProtocolManager();
658     if (ret != SOFTBUS_OK) {
659         LNN_LOGE(LNN_BUILDER, "regist default protocol manager failed, ret=%{public}d", ret);
660         return ret;
661     }
662     ret = RegGroupChangeListener(&g_groupChangeListener);
663     if (ret != SOFTBUS_OK) {
664         LNN_LOGE(LNN_BUILDER, "register group change listener fail");
665         return ret;
666     }
667     ret = LnnInitPhysicalSubnetManager();
668     if (ret != SOFTBUS_OK) {
669         LNN_LOGE(LNN_BUILDER, "init subnet manager failed, ret=%{public}d", ret);
670         return ret;
671     }
672     ProtocolType type = 0;
673     if (!LnnVisitProtocol(GetAllProtocols, &type)) {
674         LNN_LOGE(LNN_BUILDER, "Get all protocol failed");
675         return SOFTBUS_ERR;
676     }
677     LNN_LOGI(LNN_BUILDER, "set supported protocol type. type=%{public}u", type);
678     ret = LnnSetLocalNum64Info(NUM_KEY_TRANS_PROTOCOLS, (int64_t)type);
679     if (ret != SOFTBUS_OK) {
680         LNN_LOGE(LNN_BUILDER, "set supported protocol failed, ret=%{public}d", ret);
681         return ret;
682     }
683     return LnnRegisterEvent();
684 }
685 
RetryCheckOOBEState(void * para)686 static void RetryCheckOOBEState(void *para)
687 {
688     (void)para;
689 
690     if (!IsOOBEState()) {
691         LNN_LOGI(LNN_BUILDER, "wifi handle SOFTBUS_OOBE_END");
692         LnnNotifyOOBEStateChangeEvent(SOFTBUS_OOBE_END);
693     } else {
694         LNN_LOGD(LNN_BUILDER, "check OOBE again after a delay. delay=%{public}" PRIu64 "ms",
695             (uint64_t)LNN_CHECK_OOBE_DELAY_LEN);
696         LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), RetryCheckOOBEState, NULL, LNN_CHECK_OOBE_DELAY_LEN);
697     }
698 }
699 
LnnSetUnlockState(void)700 void LnnSetUnlockState(void)
701 {
702     if (IsActiveOsAccountUnlocked()) {
703         g_isUnLock = true;
704     }
705 }
706 
LnnInitNetworkManagerDelay(void)707 int32_t LnnInitNetworkManagerDelay(void)
708 {
709     uint32_t i;
710 
711     char udid[UDID_BUF_LEN] = {0};
712     if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
713         LNN_LOGE(LNN_INIT, "get local udid error");
714         return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
715     }
716     LnnNetIfMgr *item = NULL;
717     LIST_FOR_EACH_ENTRY(item, &g_netIfNameList, LnnNetIfMgr, node) {
718         for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; ++i) {
719             if (g_networkProtocols[i] == NULL) {
720                 continue;
721             }
722             if ((g_networkProtocols[i]->supportedNetif & item->type) != 0) {
723                 int32_t ret = g_networkProtocols[i]->enable(g_networkProtocols[i], item);
724                 if (ret != SOFTBUS_OK) {
725                     LNN_LOGE(LNN_INIT, "enable for netif failed. protocol=%{public}d, ifName=%{public}s", i,
726                         item->ifName);
727                 }
728                 LNN_LOGI(LNN_INIT, "enable for netif success. protocol=%{public}d, ifName=%{public}s", i, item->ifName);
729             }
730         }
731     }
732     RetryCheckOOBEState(NULL);
733     return SOFTBUS_OK;
734 }
735 
LnnIsAutoNetWorkingEnabled(void)736 bool LnnIsAutoNetWorkingEnabled(void)
737 {
738     bool isConfigEnabled = false;
739     if (IsActiveOsAccountUnlocked()) {
740         g_isUnLock = true;
741     }
742     if (SoftbusGetConfig(SOFTBUS_INT_AUTO_NETWORKING_SWITCH, (unsigned char *)&isConfigEnabled,
743         sizeof(isConfigEnabled)) != SOFTBUS_OK) {
744         LNN_LOGE(LNN_BUILDER, "Cannot get autoNetworkingSwitch from config file");
745         return true;
746     }
747     LNN_LOGI(LNN_BUILDER,
748         "wifi condition state:config=%{public}d, background=%{public}d, nightMode=%{public}d, OOBEEnd=%{public}d, "
749         "unlock=%{public}d",
750         isConfigEnabled, g_backgroundState == SOFTBUS_USER_BACKGROUND, g_isNightMode, g_isOOBEEnd, g_isUnLock);
751     return isConfigEnabled && (g_backgroundState == SOFTBUS_USER_FOREGROUND) && !g_isNightMode &&
752         g_isOOBEEnd && g_isUnLock;
753 }
754 
LnnDeinitNetworkManager(void)755 void LnnDeinitNetworkManager(void)
756 {
757     if (g_nightOnCache != NULL) {
758         DeviceNightMode *item = NULL;
759         DeviceNightMode *next = NULL;
760         LIST_FOR_EACH_ENTRY_SAFE(item, next, g_nightOnCache, DeviceNightMode, node) {
761             ListDelete(&item->node);
762             SoftBusFree(item);
763         }
764         SoftBusFree(g_nightOnCache);
765         g_nightOnCache = NULL;
766     }
767     uint32_t i;
768     if (LnnClearNetConfigList() != SOFTBUS_OK) {
769         LNN_LOGE(LNN_INIT, "deinit network manager failed");
770     }
771     LnnDeinitPhysicalSubnetManager();
772     for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; ++i) {
773         if (g_networkProtocols[i] == NULL || g_networkProtocols[i]->deinit == NULL) {
774             continue;
775         }
776         g_networkProtocols[i]->deinit(g_networkProtocols[i]);
777         g_networkProtocols[i] = NULL;
778     }
779     LnnUnregisterEventHandler(LNN_EVENT_NIGHT_MODE_CHANGED, NightModeChangeEventHandler);
780     LnnUnregisterEventHandler(LNN_EVENT_USER_STATE_CHANGED, NetUserStateEventHandler);
781     LnnUnregisterEventHandler(LNN_EVENT_SCREEN_LOCK_CHANGED, NetLockStateEventHandler);
782     LnnUnregisterEventHandler(LNN_EVENT_OOBE_STATE_CHANGED, NetOOBEStateEventHandler);
783     LnnUnregisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, NetAccountStateChangeEventHandler);
784 }
785 
LnnGetNetIfTypeByName(const char * ifName,LnnNetIfType * type)786 int32_t LnnGetNetIfTypeByName(const char *ifName, LnnNetIfType *type)
787 {
788     if (ifName == NULL || type == NULL) {
789         LNN_LOGE(LNN_BUILDER, "parameters is NULL");
790         return SOFTBUS_INVALID_PARAM;
791     }
792     LnnNetIfMgr *netif = NULL;
793     LIST_FOR_EACH_ENTRY(netif, &g_netIfNameList, LnnNetIfMgr, node) {
794         if (strncmp(ifName, netif->ifName, sizeof(netif->ifName)) == 0) {
795             *type = netif->type;
796             return SOFTBUS_OK;
797         }
798     }
799     return SOFTBUS_ERR;
800 }
801 
LnnGetAddrTypeByIfName(const char * ifName,ConnectionAddrType * type)802 int32_t LnnGetAddrTypeByIfName(const char *ifName, ConnectionAddrType *type)
803 {
804     if (type == NULL || ifName == NULL) {
805         LNN_LOGE(LNN_BUILDER, "parameters is NULL");
806         return SOFTBUS_INVALID_PARAM;
807     }
808     LnnNetIfType netifType;
809     int32_t ret = LnnGetNetIfTypeByName(ifName, &netifType);
810     if (ret != SOFTBUS_OK) {
811         return ret;
812     }
813     switch (netifType) {
814         case LNN_NETIF_TYPE_ETH:
815             *type = CONNECTION_ADDR_ETH;
816             break;
817         case LNN_NETIF_TYPE_WLAN:
818             *type = CONNECTION_ADDR_WLAN;
819             break;
820         case LNN_NETIF_TYPE_BR:
821             *type = CONNECTION_ADDR_BR;
822             break;
823         case LNN_NETIF_TYPE_BLE:
824             *type = CONNECTION_ADDR_BLE;
825             break;
826         default:
827             ret = SOFTBUS_ERR;
828     }
829     return ret;
830 }
831 
832 struct FindProtocolByTypeRequest {
833     ProtocolType protocol;
834     const LnnProtocolManager *manager;
835 };
836 
FindProtocolByType(const LnnProtocolManager * manager,void * data)837 static VisitNextChoice FindProtocolByType(const LnnProtocolManager *manager, void *data)
838 {
839     struct FindProtocolByTypeRequest *request = (struct FindProtocolByTypeRequest *)data;
840     if (manager->id == request->protocol) {
841         request->manager = manager;
842         return CHOICE_FINISH_VISITING;
843     } else {
844         return CHOICE_VISIT_NEXT;
845     }
846 }
847 
LnnGetProtocolListenerModule(ProtocolType protocol,ListenerMode mode)848 ListenerModule LnnGetProtocolListenerModule(ProtocolType protocol, ListenerMode mode)
849 {
850     struct FindProtocolByTypeRequest request = {.protocol = protocol, .manager = NULL};
851     if (LnnVisitProtocol(FindProtocolByType, &request)) {
852         LNN_LOGE(LNN_BUILDER, "not such protocol! protocolId=%{public}d", protocol);
853         return UNUSE_BUTT;
854     }
855     if (request.manager == NULL || request.manager->getListenerModule == NULL) {
856         LNN_LOGE(LNN_BUILDER, "protocol manager is null, protocolId=%{public}d", protocol);
857         return UNUSE_BUTT;
858     }
859     return request.manager->getListenerModule(mode);
860 }
861