1 /*
2 * Copyright (c) 2022-2025 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_info.h"
17
18 #include <securec.h>
19
20 #include "anonymizer.h"
21 #include "bus_center_event.h"
22 #include "bus_center_manager.h"
23 #include "g_enhance_lnn_func_pack.h"
24 #include "lnn_async_callback_utils.h"
25 #include "lnn_distributed_net_ledger.h"
26 #include "lnn_deviceinfo_to_profile.h"
27 #include "lnn_feature_capability.h"
28 #include "lnn_heartbeat_strategy.h"
29 #include "lnn_local_net_ledger.h"
30 #include "lnn_log.h"
31 #include "lnn_net_capability.h"
32 #include "lnn_node_info.h"
33 #include "lnn_net_builder.h"
34 #include "lnn_sync_info_manager.h"
35 #include "softbus_adapter_bt_common.h"
36 #include "softbus_adapter_mem.h"
37 #include "softbus_error_code.h"
38 #include "softbus_wifi_api_adapter.h"
39 #include "softbus_json_utils.h"
40 #include "softbus_def.h"
41 #include "wifi_direct_manager.h"
42
43 #define MSG_LEN 10
44 #define BITS 8
45 #define BITLEN 4
46 #define STRING_INTERFACE_BUFFER_LEN 16
47 #define DP_INACTIVE_DEFAULT_USERID (-1)
48
49 static bool g_isWifiDirectSupported = false;
50 static bool g_isApCoexistSupported = false;
51 static bool g_isWifiEnable = false;
52 static bool g_isApEnable = false;
53
ConvertMsgToCapability(uint32_t * capability,const uint8_t * msg,uint32_t len)54 static uint32_t ConvertMsgToCapability(uint32_t *capability, const uint8_t *msg, uint32_t len)
55 {
56 if (capability == NULL || msg == NULL || len < BITS) {
57 return SOFTBUS_INVALID_PARAM;
58 }
59 for (uint32_t i = 0; i < BITLEN; i++) {
60 *capability = *capability | (*(msg + i) << (BITS * i));
61 }
62 return SOFTBUS_OK;
63 }
64
PostNetchangedInfo(const char * networkId,ConnectionAddrType type)65 static void PostNetchangedInfo(const char *networkId, ConnectionAddrType type)
66 {
67 LNN_LOGI(LNN_BUILDER, "start post offline, conntype=%{public}d", type);
68 if (LnnRequestLeaveSpecific(networkId, type) != SOFTBUS_OK) {
69 LNN_LOGE(LNN_BUILDER, "send request to NetBuilder fail");
70 }
71 }
72
HandlePeerNetCapchanged(const char * networkId,uint32_t capability)73 static void HandlePeerNetCapchanged(const char *networkId, uint32_t capability)
74 {
75 if (!LnnHasCapability(capability, BIT_WIFI) || networkId == NULL) {
76 LNN_LOGI(LNN_BUILDER, "only support close ble");
77 return;
78 }
79 NodeInfo info;
80 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
81 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
82 LNN_LOGE(LNN_BUILDER, "get node info fail");
83 return;
84 }
85 if (LnnHasDiscoveryType(&info, DISCOVERY_TYPE_BLE) && !LnnHasCapability(capability, BIT_BLE)) {
86 LNN_LOGI(LNN_BUILDER, "remote device lost ble, ble need offline");
87 PostNetchangedInfo(networkId, CONNECTION_ADDR_BLE);
88 }
89 if (LnnHasDiscoveryType(&info, DISCOVERY_TYPE_BR) && !LnnHasCapability(capability, BIT_BR)) {
90 LNN_LOGI(LNN_BUILDER, "remote device lost br, br need offline");
91 PostNetchangedInfo(networkId, CONNECTION_ADDR_BR);
92 }
93 }
94
UpdateNetworkInfo(const char * udid)95 static void UpdateNetworkInfo(const char *udid)
96 {
97 NodeBasicInfo basic;
98 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
99 if (LnnGetBasicInfoByUdid(udid, &basic) != SOFTBUS_OK) {
100 LNN_LOGE(LNN_BUILDER, "GetBasicInfoByUdid fail");
101 return;
102 }
103 LnnNotifyBasicInfoChanged(&basic, TYPE_NETWORK_INFO);
104 }
105
OnReceiveCapaSyncInfoMsg(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)106 static void OnReceiveCapaSyncInfoMsg(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
107 {
108 LNN_LOGI(LNN_BUILDER, "Recv capability info. type=%{public}d, len=%{public}d", type, len);
109 if (type != LNN_INFO_TYPE_CAPABILITY) {
110 return;
111 }
112 if (networkId == NULL) {
113 return;
114 }
115 if (msg == NULL || len == 0) {
116 return;
117 }
118 uint32_t capability = 0;
119 if (ConvertMsgToCapability(&capability, msg, len) != SOFTBUS_OK) {
120 LNN_LOGE(LNN_BUILDER, "convert msg to capability fail");
121 return;
122 }
123 char *anonyNetworkId = NULL;
124 Anonymize(networkId, &anonyNetworkId);
125 LNN_LOGI(LNN_BUILDER, "recv capability change=%{public}d, networkId=%{public}s",
126 capability, AnonymizeWrapper(anonyNetworkId));
127 AnonymizeFree(anonyNetworkId);
128 // update ledger
129 NodeInfo info;
130 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
131 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
132 LNN_LOGE(LNN_BUILDER, "get node info fail");
133 return;
134 }
135 if (info.discoveryType != capability) {
136 LNN_LOGI(LNN_BUILDER, "capability change, need to updateProfile");
137 UpdateProfile(&info);
138 UpdateNetworkInfo(info.deviceInfo.deviceUdid);
139 }
140 if (LnnSetDLConnCapability(networkId, capability)) {
141 LNN_LOGE(LNN_BUILDER, "update conn capability fail.");
142 return;
143 }
144 HandlePeerNetCapchanged(networkId, capability);
145 }
146
ConvertMsgToUserId(int32_t * userId,const uint8_t * msg,uint32_t len)147 static uint32_t ConvertMsgToUserId(int32_t *userId, const uint8_t *msg, uint32_t len)
148 {
149 if (userId == NULL || msg == NULL || len < BITLEN) {
150 return SOFTBUS_INVALID_PARAM;
151 }
152 for (uint32_t i = 0; i < BITLEN; i++) {
153 *userId = ((uint32_t)*userId) | (*(msg + i) << (BITS * i));
154 }
155 return SOFTBUS_OK;
156 }
157
OnReceiveUserIdSyncInfoMsg(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)158 static void OnReceiveUserIdSyncInfoMsg(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
159 {
160 LNN_LOGI(LNN_BUILDER, "Recv userId info. type=%{public}d, len=%{public}d", type, len);
161 if (type != LNN_INFO_TYPE_USERID) {
162 return;
163 }
164 if (networkId == NULL) {
165 return;
166 }
167 if (msg == NULL || len == 0) {
168 return;
169 }
170 int32_t userId = 0;
171 if (ConvertMsgToUserId(&userId, msg, len) != SOFTBUS_OK) {
172 LNN_LOGE(LNN_BUILDER, "convert msg to userId fail");
173 return;
174 }
175 char *anonyNetworkId = NULL;
176 Anonymize(networkId, &anonyNetworkId);
177 LNN_LOGI(LNN_BUILDER, "recv userId =%{public}d, networkId=%{public}s",
178 userId, AnonymizeWrapper(anonyNetworkId));
179 AnonymizeFree(anonyNetworkId);
180 // update ledger
181 NodeInfo info;
182 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
183 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
184 LNN_LOGE(LNN_BUILDER, "get node info fail");
185 return;
186 }
187 if (LnnSetDLConnUserId(networkId, userId)) {
188 LNN_LOGE(LNN_BUILDER, "update conn userId fail.");
189 return;
190 }
191 LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_MAX);
192 }
193
ConvertCapabilityToMsg(uint32_t localCapability)194 static uint8_t *ConvertCapabilityToMsg(uint32_t localCapability)
195 {
196 LNN_LOGD(LNN_BUILDER, "convert capability to msg enter");
197 uint8_t *arr = (uint8_t *)SoftBusCalloc(MSG_LEN);
198 if (arr == NULL) {
199 LNN_LOGE(LNN_BUILDER, "convert capability to msg calloc msg fail");
200 return NULL;
201 }
202 for (uint32_t i = 0; i < BITLEN; i++) {
203 *(arr + i) = (localCapability >> (i * BITS)) & 0xFF;
204 }
205 return arr;
206 }
207
IsNeedToSend(NodeInfo * nodeInfo,uint32_t type)208 static bool IsNeedToSend(NodeInfo *nodeInfo, uint32_t type)
209 {
210 if ((type & (1 << (uint32_t)DISCOVERY_TYPE_BR)) && (LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_BR))) {
211 return true;
212 } else if ((type & (1 << (uint32_t)DISCOVERY_TYPE_BLE)) && (LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_BLE))) {
213 return true;
214 } else if ((type & (1 << (uint32_t)DISCOVERY_TYPE_WIFI)) && (LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_WIFI))) {
215 return true;
216 } else {
217 LNN_LOGI(LNN_BUILDER, "online device discovery type not match select link");
218 return false;
219 }
220 }
221
DoSendCapability(NodeInfo nodeInfo,NodeBasicInfo netInfo,uint8_t * msg,uint32_t netCapability,uint32_t type)222 static void DoSendCapability(NodeInfo nodeInfo, NodeBasicInfo netInfo, uint8_t *msg, uint32_t netCapability,
223 uint32_t type)
224 {
225 int32_t ret = SOFTBUS_OK;
226 if (IsNeedToSend(&nodeInfo, type)) {
227 if (!IsFeatureSupport(nodeInfo.feature, BIT_CLOUD_SYNC_DEVICE_INFO)) {
228 ret = LnnSendSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, netInfo.networkId, msg, MSG_LEN, NULL);
229 } else {
230 if (type == ((1 << (uint32_t)DISCOVERY_TYPE_BLE) | (1 << (uint32_t)DISCOVERY_TYPE_BR))) {
231 ret = LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0, STRATEGY_HB_SEND_SINGLE, false);
232 } else {
233 ret = LnnSendSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, netInfo.networkId, msg, MSG_LEN, NULL);
234 }
235 }
236 char *anonyNetworkId = NULL;
237 Anonymize(netInfo.networkId, &anonyNetworkId);
238 LNN_LOGE(LNN_BUILDER,
239 "sync cap info ret=%{public}d, peerNetworkId=%{public}s, type=%{public}u.",
240 ret, AnonymizeWrapper(anonyNetworkId), type);
241 AnonymizeFree(anonyNetworkId);
242 } else if ((type & (1 << (uint32_t)DISCOVERY_TYPE_WIFI)) != 0 && !LnnHasCapability(netCapability, BIT_BLE)) {
243 LnnSendP2pSyncInfoMsg(netInfo.networkId, netCapability);
244 }
245 }
246
SendSleCapabilityToRemote(NodeInfo * nodeInfo,NodeBasicInfo netInfo,uint8_t * msg,uint32_t netCapability)247 static void SendSleCapabilityToRemote(NodeInfo *nodeInfo, NodeBasicInfo netInfo, uint8_t *msg, uint32_t netCapability)
248 {
249 int32_t ret = SOFTBUS_OK;
250 if (LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_BLE) || LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_BR)) {
251 ret = LnnStartHbByTypeAndStrategy(HEARTBEAT_TYPE_BLE_V0, STRATEGY_HB_SEND_SINGLE, false);
252 } else if (LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_WIFI)) {
253 ret = LnnSendSyncInfoMsg(LNN_INFO_TYPE_CAPABILITY, netInfo.networkId, msg, MSG_LEN, NULL);
254 } else {
255 LnnSendP2pSyncInfoMsg(netInfo.networkId, netCapability);
256 }
257 char *anonyNetworkId = NULL;
258 Anonymize(netInfo.networkId, &anonyNetworkId);
259 LNN_LOGE(LNN_BUILDER,
260 "sync cap info ret=%{public}d, peerNetworkId=%{public}s.",
261 ret, AnonymizeWrapper(anonyNetworkId));
262 AnonymizeFree(anonyNetworkId);
263 }
264
SendNetCapabilityToRemote(uint32_t netCapability,uint32_t type,bool isSyncSle)265 static void SendNetCapabilityToRemote(uint32_t netCapability, uint32_t type, bool isSyncSle)
266 {
267 uint8_t *msg = ConvertCapabilityToMsg(netCapability);
268 if (msg ==NULL) {
269 return;
270 }
271 int32_t infoNum = 0;
272 NodeBasicInfo *netInfo = NULL;
273 if (LnnGetAllOnlineNodeInfo(&netInfo, &infoNum) != SOFTBUS_OK) {
274 LNN_LOGE(LNN_BUILDER, "get all online node info fail.");
275 SoftBusFree(msg);
276 return;
277 }
278 if (infoNum == 0) {
279 LNN_LOGI(LNN_BUILDER, "online device num is 0, not need to send network info");
280 SoftBusFree(msg);
281 return;
282 }
283 NodeInfo nodeInfo;
284 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
285 for (int32_t i = 0; i < infoNum; i++) {
286 if (LnnIsLSANode(&netInfo[i])) {
287 continue;
288 }
289 if (LnnGetRemoteNodeInfoById(netInfo[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
290 continue;
291 }
292 if (!isSyncSle) {
293 DoSendCapability(nodeInfo, netInfo[i], msg, netCapability, type);
294 } else {
295 SendSleCapabilityToRemote(&nodeInfo, netInfo[i], msg, netCapability);
296 }
297 }
298 SoftBusFree(netInfo);
299 SoftBusFree(msg);
300 }
301
WifiStateProcess(uint32_t netCapability,bool isSend)302 static void WifiStateProcess(uint32_t netCapability, bool isSend)
303 {
304 if (LnnSetLocalNumInfo(NUM_KEY_NET_CAP, (int32_t)netCapability) != SOFTBUS_OK) {
305 return;
306 }
307 if (!isSend) {
308 return;
309 }
310 uint32_t type = (1 << (uint32_t)DISCOVERY_TYPE_BLE) | (1 << (uint32_t)DISCOVERY_TYPE_BR);
311 SendNetCapabilityToRemote(netCapability, type, false);
312 LNN_LOGI(LNN_BUILDER, "WifiStateEventHandler exit");
313 return;
314 }
315
IsP2pAvailable(void)316 static bool IsP2pAvailable(void)
317 {
318 return g_isWifiDirectSupported && g_isWifiEnable;
319 }
320
LnnSetNetworkCapability(uint32_t * capability)321 static void LnnSetNetworkCapability(uint32_t *capability)
322 {
323 (void)LnnSetNetCapability(capability, BIT_WIFI);
324 (void)LnnSetNetCapability(capability, BIT_WIFI_5G);
325 (void)LnnSetNetCapability(capability, BIT_WIFI_24G);
326 }
327
LnnClearNetworkCapability(uint32_t * capability)328 static void LnnClearNetworkCapability(uint32_t *capability)
329 {
330 (void)LnnClearNetCapability(capability, BIT_WIFI);
331 (void)LnnClearNetCapability(capability, BIT_WIFI_5G);
332 (void)LnnClearNetCapability(capability, BIT_WIFI_24G);
333 }
334
LnnSetNetBandCapability(uint32_t * capability)335 static void LnnSetNetBandCapability(uint32_t *capability)
336 {
337 SoftBusBand band = SoftBusGetLinkBand();
338 if (band == BAND_24G) {
339 (void)LnnSetNetCapability(capability, BIT_WIFI_24G);
340 (void)LnnClearNetCapability(capability, BIT_WIFI_5G);
341 } else if (band == BAND_5G) {
342 (void)LnnSetNetCapability(capability, BIT_WIFI_5G);
343 (void)LnnClearNetCapability(capability, BIT_WIFI_24G);
344 } else {
345 (void)LnnSetNetCapability(capability, BIT_WIFI_5G);
346 (void)LnnSetNetCapability(capability, BIT_WIFI_24G);
347 }
348 }
349
LnnClearNetBandCapability(uint32_t * capability)350 static void LnnClearNetBandCapability(uint32_t *capability)
351 {
352 if (!g_isApEnable) {
353 (void)LnnClearNetCapability(capability, BIT_WIFI_5G);
354 (void)LnnClearNetCapability(capability, BIT_WIFI_24G);
355 }
356 }
357
LnnSetP2pNetCapability(uint32_t * capability)358 static void LnnSetP2pNetCapability(uint32_t *capability)
359 {
360 SoftBusWifiDetailState wifiState = SoftBusGetWifiState();
361 if (wifiState == SOFTBUS_WIFI_STATE_INACTIVE || wifiState == SOFTBUS_WIFI_STATE_DEACTIVATING) {
362 (void)LnnClearNetCapability(capability, BIT_WIFI_P2P);
363 } else {
364 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
365 }
366 }
367
ProcessApEnabled(uint32_t * capability,bool * needSync)368 static void ProcessApEnabled(uint32_t *capability, bool *needSync)
369 {
370 g_isApEnable = true;
371 LnnSetNetworkCapability(capability);
372 if (IsP2pAvailable()) {
373 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
374 }
375 *needSync = true;
376 }
377
ProcessApDisabled(uint32_t * capability,bool * needSync)378 static void ProcessApDisabled(uint32_t *capability, bool *needSync)
379 {
380 g_isApEnable = false;
381 SoftBusWifiDetailState wifiState = SoftBusGetWifiState();
382 if (IsP2pAvailable()) {
383 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
384 }
385 if (!g_isWifiEnable || (wifiState != SOFTBUS_WIFI_STATE_ACTIVED && wifiState != SOFTBUS_WIFI_STATE_ACTIVATING)) {
386 LnnClearNetworkCapability(capability);
387 }
388 *needSync = true;
389 }
390
GetNetworkCapability(SoftBusWifiState wifiState,uint32_t * capability,bool * needSync)391 static void GetNetworkCapability(SoftBusWifiState wifiState, uint32_t *capability, bool *needSync)
392 {
393 switch (wifiState) {
394 case SOFTBUS_WIFI_OBTAINING_IPADDR:
395 (void)LnnSetNetCapability(capability, BIT_WIFI);
396 LnnSetNetBandCapability(capability);
397 break;
398 case SOFTBUS_WIFI_ENABLED:
399 g_isWifiEnable = true;
400 (void)LnnSetNetCapability(capability, BIT_WIFI);
401 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
402 *needSync = true;
403 break;
404 case SOFTBUS_WIFI_CONNECTED:
405 (void)LnnSetNetCapability(capability, BIT_WIFI);
406 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
407 LnnSetNetBandCapability(capability);
408 *needSync = true;
409 break;
410 case SOFTBUS_WIFI_DISCONNECTED:
411 LnnClearNetBandCapability(capability);
412 *needSync = true;
413 break;
414 case SOFTBUS_WIFI_DISABLED:
415 g_isWifiEnable = false;
416 if (!g_isApEnable) {
417 LnnClearNetworkCapability(capability);
418 LnnSetP2pNetCapability(capability);
419 } else if (!IsP2pAvailable()) {
420 (void)LnnClearNetCapability(capability, BIT_WIFI_P2P);
421 }
422 *needSync = true;
423 break;
424 case SOFTBUS_AP_ENABLED:
425 ProcessApEnabled(capability, needSync);
426 break;
427 case SOFTBUS_AP_DISABLED:
428 ProcessApDisabled(capability, needSync);
429 break;
430 case SOFTBUS_WIFI_SEMI_ACTIVE:
431 g_isWifiEnable = true;
432 (void)LnnSetNetCapability(capability, BIT_WIFI_P2P);
433 *needSync = true;
434 break;
435 default:
436 break;
437 }
438 }
439
WifiStateEventHandler(const LnnEventBasicInfo * info)440 static void WifiStateEventHandler(const LnnEventBasicInfo *info)
441 {
442 if (info == NULL || info->event != LNN_EVENT_WIFI_STATE_CHANGED) {
443 LNN_LOGE(LNN_BUILDER, "bt state change evt handler get invalid param");
444 return;
445 }
446 const LnnMonitorWlanStateChangedEvent *event = (const LnnMonitorWlanStateChangedEvent *)info;
447 SoftBusWifiState wifiState = (SoftBusWifiState)event->status;
448 uint32_t oldNetCap = 0;
449 if (LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &oldNetCap) != SOFTBUS_OK) {
450 LNN_LOGE(LNN_BUILDER, "wifi state handler get capability fail from local.");
451 return;
452 }
453 bool needSync = false;
454 uint32_t netCapability = oldNetCap;
455 GetNetworkCapability(wifiState, &netCapability, &needSync);
456 LNN_LOGI(LNN_BUILDER, "WifiState=%{public}d, local capabilty change:%{public}u->%{public}u, needSync=%{public}d",
457 wifiState, oldNetCap, netCapability, needSync);
458 WifiStateProcess(netCapability, needSync);
459 }
460
BtStateChangeEventHandler(const LnnEventBasicInfo * info)461 static void BtStateChangeEventHandler(const LnnEventBasicInfo *info)
462 {
463 if (info == NULL || info->event != LNN_EVENT_BT_STATE_CHANGED) {
464 LNN_LOGE(LNN_BUILDER, "HB bt state change evt handler get invalid param");
465 return;
466 }
467 uint32_t netCapability = 0;
468 if (LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &netCapability) != SOFTBUS_OK) {
469 LNN_LOGE(LNN_BUILDER, "get netcap fail");
470 return;
471 }
472 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
473 SoftBusBtState btState = (SoftBusBtState)event->status;
474 bool isSend = false;
475 LNN_LOGI(LNN_BUILDER, "bt state change btState=%{public}d", btState);
476 switch (btState) {
477 case SOFTBUS_BR_TURN_ON:
478 (void)LnnSetNetCapability(&netCapability, BIT_BR);
479 break;
480 case SOFTBUS_BLE_TURN_ON:
481 (void)LnnSetNetCapability(&netCapability, BIT_BLE);
482 break;
483 case SOFTBUS_BR_TURN_OFF:
484 (void)LnnClearNetCapability(&netCapability, BIT_BR);
485 break;
486 case SOFTBUS_BLE_TURN_OFF:
487 (void)LnnClearNetCapability(&netCapability, BIT_BLE);
488 isSend = true;
489 break;
490 default:
491 return;
492 }
493
494 LNN_LOGI(LNN_BUILDER, "bt state change. netCapability=%{public}d, isSend=%{public}d",
495 netCapability, isSend);
496 if (LnnSetLocalNumInfo(NUM_KEY_NET_CAP, (int32_t)netCapability) != SOFTBUS_OK) {
497 LNN_LOGE(LNN_BUILDER, "set cap to local ledger fail");
498 return;
499 }
500 if (!isSend) {
501 return;
502 }
503 SendNetCapabilityToRemote(netCapability, 1 << (uint32_t)DISCOVERY_TYPE_WIFI, false);
504 return;
505 }
506
SleStateChangeEventHandle(const LnnEventBasicInfo * info)507 static void SleStateChangeEventHandle(const LnnEventBasicInfo *info)
508 {
509 if (info == NULL || info->event != LNN_EVENT_SLE_STATE_CHANGED) {
510 LNN_LOGE(LNN_BUILDER, "sle state change evt handler get invalid param");
511 return;
512 }
513 uint32_t netCapability = 0;
514 if (LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &netCapability) != SOFTBUS_OK) {
515 LNN_LOGE(LNN_BUILDER, "get netcap fail");
516 return;
517 }
518 const LnnMonitorSleStateChangedEvent *event = (const LnnMonitorSleStateChangedEvent *)info;
519 SoftBusSleState sleState = (SoftBusSleState)event->status;
520 uint32_t delayTime = 0;
521 TriggerSparkGroupClearPacked((uint32_t)sleState, delayTime);
522 if (sleState == SOFTBUS_SLE_TURN_ON) {
523 (void)LnnSetNetCapability(&netCapability, BIT_SLE);
524 } else if (sleState == SOFTBUS_SLE_TURN_OFF) {
525 (void)LnnClearNetCapability(&netCapability, BIT_SLE);
526 }
527 if (LnnSetLocalNumInfo(NUM_KEY_NET_CAP, (int32_t)netCapability) != SOFTBUS_OK) {
528 LNN_LOGE(LNN_BUILDER, "set cap to local ledger fail");
529 return;
530 }
531 LNN_LOGI(LNN_BUILDER, "sle netCapability=%{public}d", netCapability);
532 SendNetCapabilityToRemote(netCapability, 0, true);
533 }
534
GetEnhancedFLFeature(uint64_t * feature)535 static int32_t GetEnhancedFLFeature(uint64_t *feature)
536 {
537 if (feature == NULL) {
538 return SOFTBUS_INVALID_PARAM;
539 }
540 if (GetWifiDirectManager() == NULL || GetWifiDirectManager()->getVspCapabilityCode == NULL) {
541 LNN_LOGI(LNN_BUILDER, "failed to get wifi direct manager.");
542 return SOFTBUS_WIFI_DIRECT_INIT_FAILED;
543 }
544 VspCapabilityCode vspCapability = GetWifiDirectManager()->getVspCapabilityCode();
545 LNN_LOGI(LNN_BUILDER, "GetEnhancedFLFeature vspCap=%{public}d", vspCapability);
546 int32_t ret;
547 if (CONN_VSP_SUPPORT == vspCapability) {
548 ret = LnnSetFeatureCapability(feature, BIT_FL_CAPABILITY);
549 if (ret != SOFTBUS_OK) {
550 LNN_LOGE(LNN_BUILDER, "set feature capability failed, ret=%{public}d.", ret);
551 return ret;
552 }
553 }
554 return SOFTBUS_OK;
555 }
556
UpdateLocalFeatureByWifiVspRes()557 static void UpdateLocalFeatureByWifiVspRes()
558 {
559 uint64_t localFeatureCap = 0;
560 if (LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, &localFeatureCap) != SOFTBUS_OK) {
561 LNN_LOGE(LNN_BUILDER, "wifi service FL feature, get local feature cap failed");
562 return;
563 }
564 uint64_t oldFeature = localFeatureCap;
565 if (GetEnhancedFLFeature(&localFeatureCap) != SOFTBUS_OK) {
566 LNN_LOGE(LNN_BUILDER, "get local fl feature fail");
567 // fall-through
568 }
569 if (oldFeature == localFeatureCap) {
570 return;
571 }
572 int32_t ret = LnnSetLocalNum64Info(NUM_KEY_FEATURE_CAPA, localFeatureCap);
573 if (ret != SOFTBUS_OK) {
574 LNN_LOGE(LNN_BUILDER, "set localFeatureCap failed, ret=%{public}d.", ret);
575 return;
576 }
577 LNN_LOGI(LNN_BUILDER, "local feature changed:%{public}" PRIu64 "->%{public}" PRIu64, oldFeature, localFeatureCap);
578 }
579
UpdateHmlStaticCap(void)580 static int32_t UpdateHmlStaticCap(void)
581 {
582 uint32_t staticNetCap = 0;
583 int32_t ret = LnnGetLocalNumU32Info(NUM_KEY_STATIC_NET_CAP, &staticNetCap);
584 if (ret != SOFTBUS_OK) {
585 LNN_LOGE(LNN_BUILDER, "get staticNetCap failed, ret=%{public}d.", ret);
586 return ret;
587 }
588 uint32_t oldCap = staticNetCap;
589 if (GetWifiDirectManager() == NULL || GetWifiDirectManager()->getHmlCapabilityCode == NULL) {
590 LNN_LOGI(LNN_BUILDER, "failed to get wifi direct manager.");
591 return SOFTBUS_WIFI_DIRECT_INIT_FAILED;
592 }
593 HmlCapabilityCode code = GetWifiDirectManager()->getHmlCapabilityCode();
594 LNN_LOGI(LNN_BUILDER, "hml capability code=%{public}d.", code);
595 if (code == CONN_HML_SUPPORT) {
596 ret = LnnSetStaticNetCap(&staticNetCap, STATIC_CAP_BIT_ENHANCED_P2P);
597 if (ret != SOFTBUS_OK) {
598 LNN_LOGE(LNN_BUILDER, "clear staticNetCap failed, ret=%{public}d.", ret);
599 return ret;
600 }
601 }
602 if (code == CONN_HML_CAP_UNKNOWN || code == CONN_HML_NOT_SUPPORT) {
603 ret = LnnClearStaticNetCap(&staticNetCap, STATIC_CAP_BIT_ENHANCED_P2P);
604 if (ret != SOFTBUS_OK) {
605 LNN_LOGE(LNN_BUILDER, "clear staticNetCap failed, ret=%{public}d.", ret);
606 return ret;
607 }
608 }
609 if (oldCap == staticNetCap) {
610 return SOFTBUS_OK;
611 }
612 ret = LnnSetLocalNumU32Info(NUM_KEY_STATIC_NET_CAP, staticNetCap);
613 if (ret != SOFTBUS_OK) {
614 LNN_LOGE(LNN_BUILDER, "set staticNetCap failed, ret=%{public}d.", ret);
615 return ret;
616 }
617 LNN_LOGI(LNN_BUILDER, "static netCap changed:%{public}u->%{public}u.", oldCap, staticNetCap);
618 return SOFTBUS_OK;
619 }
620
OnHmlServiceStart(void * state)621 static void OnHmlServiceStart(void *state)
622 {
623 if (state == NULL) {
624 LNN_LOGE(LNN_EVENT, "state is empty");
625 return;
626 }
627 SoftBusHmlState *curState = (SoftBusHmlState *)state;
628 if (*curState == CONN_HML_ENABLED) {
629 int32_t ret = UpdateHmlStaticCap();
630 if (ret != SOFTBUS_OK) {
631 LNN_LOGE(LNN_BUILDER, "update hml static cap failed, ret=%{public}d.", ret);
632 }
633 UpdateLocalFeatureByWifiVspRes();
634 }
635 SoftBusFree(curState);
636 }
637
HmlStateOnStartCb(SoftBusHmlState state)638 static void HmlStateOnStartCb(SoftBusHmlState state)
639 {
640 if (state != CONN_HML_ENABLED) {
641 LNN_LOGI(LNN_BUILDER, "ignore it.");
642 return;
643 }
644 SoftBusHmlState *notifyState = (SoftBusHmlState *)SoftBusCalloc(sizeof(SoftBusHmlState));
645 if (notifyState == NULL) {
646 LNN_LOGE(LNN_BUILDER, "notifyState malloc err");
647 return;
648 }
649 *notifyState = state;
650 if (LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), OnHmlServiceStart, (void *)notifyState) != SOFTBUS_OK) {
651 LNN_LOGE(LNN_BUILDER, "async fail");
652 SoftBusFree(notifyState);
653 }
654 }
655
WifiServiceOnStartHandle(const LnnEventBasicInfo * info)656 static void WifiServiceOnStartHandle(const LnnEventBasicInfo *info)
657 {
658 LNN_LOGI(LNN_BUILDER, "wifi service on start.");
659 if (info == NULL || info->event != LNN_EVENT_WIFI_SERVICE_START) {
660 LNN_LOGE(LNN_BUILDER, "invalid param.");
661 return;
662 }
663 int32_t ret = UpdateHmlStaticCap();
664 if (ret != SOFTBUS_OK) {
665 LNN_LOGE(LNN_BUILDER, "update hml static cap failed, ret=%{public}d.", ret);
666 }
667 UpdateLocalFeatureByWifiVspRes();
668 }
669
IsSupportApCoexist(const char * coexistCap)670 static bool IsSupportApCoexist(const char *coexistCap)
671 {
672 cJSON *coexistObj = cJSON_ParseWithLength(coexistCap, strlen(coexistCap) + 1);
673 LNN_CHECK_AND_RETURN_RET_LOGE(coexistObj, false, LNN_BUILDER, "create json object failed");
674
675 if (!cJSON_IsArray(coexistObj)) {
676 cJSON_Delete(coexistObj);
677 LNN_LOGE(LNN_BUILDER, "coexistObj is not a array");
678 return false;
679 }
680
681 for (int i = 0; i < cJSON_GetArraySize(coexistObj); i++) {
682 cJSON *subItems = cJSON_GetArrayItem(coexistObj, i);
683 if (!cJSON_IsArray(subItems)) {
684 LNN_LOGE(LNN_BUILDER, "item is not array, i=%{public}d", i);
685 continue;
686 }
687
688 bool apCap = false;
689 bool p2pCap = false;
690 for (int j = 0; j < cJSON_GetArraySize(subItems); j++) {
691 cJSON *subItem = cJSON_GetArrayItem(subItems, j);
692 char interface[NET_IF_NAME_LEN] = {0};
693 if (!GetJsonObjectStringItem(subItem, "IF", interface, sizeof(interface))) {
694 LNN_LOGE(LNN_BUILDER, "get interface failed");
695 continue;
696 }
697
698 enum WifiDirectApiRole mode = WIFI_DIRECT_API_ROLE_NONE;
699 if (!GetJsonObjectInt32Item(subItem, "MODE", (int32_t *)&mode)) {
700 LNN_LOGE(LNN_BUILDER, "interface get mode failed. interface=%{public}s", interface);
701 continue;
702 }
703
704 LNN_LOGI(LNN_BUILDER, "interface=%{public}s, mode=%{public}d", interface, mode);
705 if ((mode & WIFI_DIRECT_API_ROLE_AP)) {
706 apCap = true;
707 } else if ((mode & WIFI_DIRECT_API_ROLE_GC) || (mode & WIFI_DIRECT_API_ROLE_GO)) {
708 p2pCap = true;
709 }
710 if (apCap && p2pCap) {
711 cJSON_Delete(coexistObj);
712 return true;
713 }
714 }
715 }
716
717 cJSON_Delete(coexistObj);
718 return false;
719 }
720
InitWifiDirectCapability(void)721 static void InitWifiDirectCapability(void)
722 {
723 g_isWifiDirectSupported = SoftBusHasWifiDirectCapability();
724 char *coexistCap = SoftBusGetWifiInterfaceCoexistCap();
725 LNN_CHECK_AND_RETURN_LOGE(coexistCap != NULL, LNN_INIT, "coexistCap is null");
726 LNN_LOGI(LNN_BUILDER, "coexistCap=%{public}s", coexistCap);
727 g_isApCoexistSupported = IsSupportApCoexist(coexistCap);
728 SoftBusFree(coexistCap);
729 LNN_LOGI(LNN_BUILDER, "g_isWifiDirectSupported=%{public}d, g_isApCoexistSupported=%{public}d",
730 g_isWifiDirectSupported, g_isApCoexistSupported);
731 }
732
InitWifiDirectListener(void)733 static void InitWifiDirectListener(void)
734 {
735 struct WifiDirectManager *pManager = GetWifiDirectManager();
736 if (pManager == NULL) {
737 LNN_LOGE(LNN_BUILDER, "get wifi direct manager fail");
738 return;
739 }
740 if (pManager->addHmlStateListener == NULL) {
741 LNN_LOGE(LNN_BUILDER, "addHmlStateListener null");
742 return;
743 }
744 pManager->addHmlStateListener(HmlStateOnStartCb);
745 }
746
LnnInitNetworkInfo(void)747 int32_t LnnInitNetworkInfo(void)
748 {
749 InitWifiDirectCapability();
750 InitWifiDirectListener();
751 int32_t ret = LnnRegisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, BtStateChangeEventHandler);
752 if (ret != SOFTBUS_OK) {
753 LNN_LOGE(LNN_BUILDER, "network info register bt state change fail, ret=%{public}d", ret);
754 return ret;
755 }
756 ret = LnnRegisterEventHandler(LNN_EVENT_SLE_STATE_CHANGED, SleStateChangeEventHandle);
757 LNN_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK,
758 ret, LNN_BUILDER, "register sle state change event failed. ret=%{public}d", ret);
759 ret = LnnRegisterEventHandler(LNN_EVENT_WIFI_STATE_CHANGED, WifiStateEventHandler);
760 if (ret != SOFTBUS_OK) {
761 LNN_LOGE(LNN_BUILDER, "network info register wifi state change fail, ret=%{public}d", ret);
762 return ret;
763 }
764 ret = LnnRegisterEventHandler(LNN_EVENT_WIFI_SERVICE_START, WifiServiceOnStartHandle);
765 if (ret != SOFTBUS_OK) {
766 LNN_LOGE(LNN_BUILDER, "register wifi service start fail, ret=%{public}d", ret);
767 return ret;
768 }
769 ret = LnnRegSyncInfoHandler(LNN_INFO_TYPE_CAPABILITY, OnReceiveCapaSyncInfoMsg);
770 if (ret != SOFTBUS_OK) {
771 return ret;
772 }
773 ret = LnnRegSyncInfoHandler(LNN_INFO_TYPE_USERID, OnReceiveUserIdSyncInfoMsg);
774 if (ret != SOFTBUS_OK) {
775 return ret;
776 }
777 LNN_LOGE(LNN_BUILDER, "lnn init network info sync done");
778 return SOFTBUS_OK;
779 }
780
LnnDeinitNetworkInfo(void)781 void LnnDeinitNetworkInfo(void)
782 {
783 (void)LnnUnregisterEventHandler(LNN_EVENT_BT_STATE_CHANGED, BtStateChangeEventHandler);
784 (void)LnnUnregisterEventHandler(LNN_EVENT_WIFI_STATE_CHANGED, WifiStateEventHandler);
785 (void)LnnUnregSyncInfoHandler(LNN_INFO_TYPE_CAPABILITY, OnReceiveCapaSyncInfoMsg);
786 (void)LnnUnregSyncInfoHandler(LNN_INFO_TYPE_USERID, OnReceiveUserIdSyncInfoMsg);
787 (void)LnnUnregisterEventHandler(LNN_EVENT_WIFI_SERVICE_START, WifiServiceOnStartHandle);
788 }
789
LnnProcessUserChangeMsg(LnnSyncInfoType syncType,const char * networkId,const uint8_t * msg,uint32_t len)790 static void LnnProcessUserChangeMsg(LnnSyncInfoType syncType, const char *networkId, const uint8_t *msg, uint32_t len)
791 {
792 LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_MAX);
793 }
794
OnLnnProcessUserChangeMsgDelay(void * para)795 void OnLnnProcessUserChangeMsgDelay(void *para)
796 {
797 if (para == NULL) {
798 LNN_LOGE(LNN_BUILDER, "invalid para");
799 return;
800 }
801
802 LnnRequestLeaveSpecific((char *)para, CONNECTION_ADDR_MAX);
803 SoftBusFree(para);
804 }
805
LnnAsyncSendUserId(void * param)806 static void LnnAsyncSendUserId(void *param)
807 {
808 SendSyncInfoParam *data = (SendSyncInfoParam *)param;
809 if (data == NULL) {
810 LNN_LOGE(LNN_BUILDER, "invalid para");
811 return;
812 }
813 if (data->msg == NULL) {
814 LNN_LOGE(LNN_BUILDER, "invalid para");
815 SoftBusFree(data);
816 return;
817 }
818 int32_t ret = LnnSendSyncInfoMsg(data->type, data->networkId, data->msg, data->len, data->complete);
819 if (ret != SOFTBUS_OK) {
820 LNN_LOGE(LNN_BUILDER, "send info msg type=%{public}d fail, ret:%{public}d", data->type, ret);
821 LnnRequestLeaveSpecific(data->networkId, CONNECTION_ADDR_MAX);
822 }
823 SoftBusFree(data->msg);
824 SoftBusFree(data);
825 }
826
DoSendUserId(const char * udid,uint8_t * msg)827 static void DoSendUserId(const char *udid, uint8_t *msg)
828 {
829 #define USER_CHANGE_DELAY_TIME 5
830 NodeInfo nodeInfo;
831 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
832 int32_t ret = LnnGetRemoteNodeInfoById(udid, CATEGORY_UDID, &nodeInfo);
833 if (ret != SOFTBUS_OK) {
834 LNN_LOGE(LNN_BUILDER, "LnnGetRemoteNodeInfoById failed! ret:%{public}d", ret);
835 return;
836 }
837 if (LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_BLE)) {
838 LNN_LOGI(LNN_BUILDER, "ble online, no need notify offline by adv");
839 LnnRequestLeaveSpecific(nodeInfo.networkId, CONNECTION_ADDR_MAX);
840 return;
841 }
842
843 SendSyncInfoParam *data =
844 CreateSyncInfoParam(LNN_INFO_TYPE_USERID, nodeInfo.networkId, msg, MSG_LEN, LnnProcessUserChangeMsg);
845 if (data == NULL) {
846 LNN_LOGE(LNN_BUILDER, "create async info fail");
847 LnnRequestLeaveSpecific(nodeInfo.networkId, CONNECTION_ADDR_MAX);
848 return;
849 }
850 ret = LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), LnnAsyncSendUserId, (void *)data);
851 if (ret != SOFTBUS_OK) {
852 SoftBusFree(data->msg);
853 SoftBusFree(data);
854 LNN_LOGE(LNN_BUILDER, "async userid to peer fail");
855 LnnRequestLeaveSpecific(nodeInfo.networkId, CONNECTION_ADDR_MAX);
856 return;
857 }
858
859 char *networkId = (char *)SoftBusCalloc(NETWORK_ID_BUF_LEN);
860 if (networkId == NULL) {
861 LNN_LOGI(LNN_BUILDER, "malloc fail");
862 return;
863 }
864 ret = memcpy_s(networkId, NETWORK_ID_BUF_LEN, nodeInfo.networkId, NETWORK_ID_BUF_LEN);
865 if (ret != EOK) {
866 LNN_LOGI(LNN_BUILDER, "memcpy_s failed! ret:%{public}d", ret);
867 SoftBusFree(networkId);
868 return;
869 }
870
871 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), OnLnnProcessUserChangeMsgDelay,
872 (void *)networkId, USER_CHANGE_DELAY_TIME) != SOFTBUS_OK) {
873 LNN_LOGE(LNN_BUILDER, "async userid to peer delay fail");
874 SoftBusFree(networkId);
875 }
876 }
877
ConvertUserIdToMsg(int32_t userId)878 static uint8_t *ConvertUserIdToMsg(int32_t userId)
879 {
880 LNN_LOGD(LNN_BUILDER, "convert userId to msg enter");
881 uint8_t *arr = (uint8_t *)SoftBusCalloc(MSG_LEN);
882 if (arr == NULL) {
883 LNN_LOGE(LNN_BUILDER, "convert userId to msg calloc msg fail");
884 return NULL;
885 }
886 for (uint32_t i = 0; i < BITLEN; i++) {
887 *(arr + i) = ((uint32_t)userId >> (i * BITS)) & 0xFF;
888 }
889 return arr;
890 }
891
NotifyRemoteDevOffLineByUserId(int32_t userId,const char * udid)892 void NotifyRemoteDevOffLineByUserId(int32_t userId, const char *udid)
893 {
894 NodeInfo nodeInfo;
895 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
896 int32_t ret = LnnGetRemoteNodeInfoById(udid, CATEGORY_UDID, &nodeInfo);
897 if (ret != SOFTBUS_OK) {
898 LNN_LOGE(LNN_BUILDER, "LnnGetRemoteNodeInfoById failed! ret=%{public}d", ret);
899 return;
900 }
901 if (userId != DP_INACTIVE_DEFAULT_USERID && nodeInfo.userId != 0 && nodeInfo.userId != userId) {
902 LNN_LOGI(LNN_BUILDER, "ledger userid=%{public}d, inactive userid=%{public}d", nodeInfo.userId, userId);
903 return;
904 }
905 uint8_t *msg = ConvertUserIdToMsg(userId);
906 if (msg == NULL) {
907 LNN_LOGE(LNN_BUILDER, "convert userId to msg is null");
908 return;
909 }
910 DoSendUserId(udid, msg);
911 SoftBusFree(msg);
912 }
913