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