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