1 /*
2  * Copyright (c) 2022 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_heartbeat_utils.h"
17 
18 #include <securec.h>
19 #include <string.h>
20 
21 #include "anonymizer.h"
22 #include "bus_center_manager.h"
23 #include "lnn_device_info.h"
24 #include "lnn_distributed_net_ledger.h"
25 #include "lnn_feature_capability.h"
26 #include "lnn_heartbeat_medium_mgr.h"
27 #include "lnn_log.h"
28 #include "lnn_node_info.h"
29 #include "softbus_adapter_crypto.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_conn_interface.h"
32 #include "softbus_def.h"
33 #include "softbus_errcode.h"
34 #include "softbus_utils.h"
35 #include "wifi_direct_manager.h"
36 
LnnConvertConnAddrTypeToHbType(ConnectionAddrType addrType)37 LnnHeartbeatType LnnConvertConnAddrTypeToHbType(ConnectionAddrType addrType)
38 {
39     switch (addrType) {
40         case CONNECTION_ADDR_WLAN:
41         case CONNECTION_ADDR_ETH:
42             return HEARTBEAT_TYPE_UDP;
43         case CONNECTION_ADDR_BR:
44         case CONNECTION_ADDR_BLE:
45             return HEARTBEAT_TYPE_BLE_V1;
46         default:
47             break;
48     }
49     return HEARTBEAT_TYPE_MAX;
50 }
51 
LnnConvertHbTypeToConnAddrType(LnnHeartbeatType type)52 ConnectionAddrType LnnConvertHbTypeToConnAddrType(LnnHeartbeatType type)
53 {
54     switch (type) {
55         case HEARTBEAT_TYPE_UDP:
56         case HEARTBEAT_TYPE_TCP_FLUSH:
57             return CONNECTION_ADDR_WLAN;
58         case HEARTBEAT_TYPE_BLE_V1:
59         case HEARTBEAT_TYPE_BLE_V0:
60             return CONNECTION_ADDR_BLE;
61         default:
62             break;
63     }
64     return CONNECTION_ADDR_MAX;
65 }
66 
LnnConvertHbTypeToId(LnnHeartbeatType type)67 int32_t LnnConvertHbTypeToId(LnnHeartbeatType type)
68 {
69     int32_t cnt = -1;
70 
71     if (type < HEARTBEAT_TYPE_MIN || type >= HEARTBEAT_TYPE_MAX) {
72         return HB_INVALID_TYPE_ID;
73     }
74     do {
75         type >>= 1;
76         ++cnt;
77     } while (type >= HEARTBEAT_TYPE_MIN);
78     if (cnt < 0 || cnt > HB_MAX_TYPE_COUNT) {
79         return HB_INVALID_TYPE_ID;
80     }
81     return cnt;
82 }
83 
HbHasActiveBrConnection(const char * networkId)84 static bool HbHasActiveBrConnection(const char *networkId)
85 {
86     bool ret = false;
87     ConnectOption option;
88     (void)memset_s(&option, sizeof(ConnectOption), 0, sizeof(ConnectOption));
89     char brMac[BT_MAC_LEN] = { 0 };
90     uint8_t binaryAddr[BT_ADDR_LEN] = { 0 };
91 
92     if (LnnGetRemoteStrInfo(networkId, STRING_KEY_BT_MAC, brMac, sizeof(brMac)) != SOFTBUS_OK) {
93         LNN_LOGE(LNN_HEART_BEAT, "HB get bt mac err");
94         return false;
95     }
96     option.type = CONNECT_BR;
97     if (strcpy_s(option.brOption.brMac, BT_MAC_LEN, brMac) != EOK) {
98         LNN_LOGE(LNN_HEART_BEAT, "HB strcpy_s bt mac err");
99         return false;
100     }
101     if (ConvertBtMacToBinary(brMac, sizeof(brMac), binaryAddr, BT_ADDR_LEN) != SOFTBUS_OK) {
102         LNN_LOGE(LNN_HEART_BEAT, "HB convert bt mac err");
103         return false;
104     }
105     ret = CheckActiveConnection(&option, false);
106     LNN_LOGD(LNN_HEART_BEAT, "HB has active bt connection=%{public}s", ret ? "true" : "false");
107     return ret;
108 }
109 
HbHasActiveBleConnection(const char * networkId)110 static bool HbHasActiveBleConnection(const char *networkId)
111 {
112     bool ret = false;
113     ConnectOption option;
114     (void)memset_s(&option, sizeof(ConnectOption), 0, sizeof(ConnectOption));
115     char udid[UDID_BUF_LEN] = { 0 };
116     char udidHash[UDID_HASH_LEN] = { 0 };
117 
118     if (LnnGetRemoteStrInfo(networkId, STRING_KEY_DEV_UDID, udid, sizeof(udid)) != SOFTBUS_OK) {
119         LNN_LOGE(LNN_HEART_BEAT, "HB get udid err");
120         return false;
121     }
122     if (SoftBusGenerateStrHash((const unsigned char *)udid, strlen(udid), (unsigned char *)udidHash) != SOFTBUS_OK) {
123         LNN_LOGE(LNN_HEART_BEAT, "HB get udid hash err");
124         return false;
125     }
126     option.type = CONNECT_BLE;
127     if (memcpy_s(option.bleOption.deviceIdHash, UDID_HASH_LEN, udidHash, sizeof(udidHash)) != EOK) {
128         LNN_LOGE(LNN_HEART_BEAT, "HB memcpy_s udid hash err");
129         return false;
130     }
131     ret = CheckActiveConnection(&option, false);
132     LNN_LOGD(LNN_HEART_BEAT, "HB has active ble connection=%{public}s", ret ? "true" : "false");
133     return ret;
134 }
135 
HbHasActiveP2pConnection(const char * networkId)136 static bool HbHasActiveP2pConnection(const char *networkId)
137 {
138     char peerMac[MAC_ADDR_STR_LEN] = { 0 };
139     struct WifiDirectManager *pManager = GetWifiDirectManager();
140     if (pManager == NULL) {
141         LNN_LOGE(LNN_HEART_BEAT, "HB not support wifi direct");
142         return false;
143     }
144     if (LnnGetRemoteStrInfo(networkId, STRING_KEY_P2P_MAC, peerMac, sizeof(peerMac)) != SOFTBUS_OK) {
145         LNN_LOGE(LNN_HEART_BEAT, "HB get peer p2p mac err");
146         return false;
147     }
148     bool isOnline = pManager->isDeviceOnline(peerMac);
149     LNN_LOGD(LNN_HEART_BEAT, "HB has active p2p connection=%{public}s", isOnline ? "true" : "false");
150     return isOnline;
151 }
152 
HbHasActiveHmlConnection(const char * networkId)153 static bool HbHasActiveHmlConnection(const char *networkId)
154 {
155     NodeInfo info;
156     char myIp[IP_LEN] = { 0 };
157     struct WifiDirectManager *pManager = GetWifiDirectManager();
158     if (pManager == NULL) {
159         LNN_LOGE(LNN_HEART_BEAT, "HB not support wifi direct");
160         return false;
161     }
162     if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
163         LNN_LOGE(LNN_HEART_BEAT, "HB get node info fail");
164         return false;
165     }
166     if (pManager->getLocalIpByUuid(info.uuid, myIp, sizeof(myIp)) == SOFTBUS_OK) {
167         LNN_LOGI(LNN_HEART_BEAT, "HB get HML ip success");
168         return true;
169     }
170     return false;
171 }
172 
LnnHasActiveConnection(const char * networkId,ConnectionAddrType addrType)173 bool LnnHasActiveConnection(const char *networkId, ConnectionAddrType addrType)
174 {
175     bool ret = false;
176 
177     if (networkId == NULL || addrType >= CONNECTION_ADDR_MAX) {
178         LNN_LOGE(LNN_HEART_BEAT, "HB check active connection get invalid param");
179         return ret;
180     }
181 
182     switch (addrType) {
183         case CONNECTION_ADDR_WLAN:
184         case CONNECTION_ADDR_ETH:
185         case CONNECTION_ADDR_BR:
186             break;
187         case CONNECTION_ADDR_BLE:
188             ret = HbHasActiveBrConnection(networkId) || HbHasActiveBleConnection(networkId) ||
189                 HbHasActiveP2pConnection(networkId) || HbHasActiveHmlConnection(networkId);
190             char *anonyNetworkId = NULL;
191             Anonymize(networkId, &anonyNetworkId);
192             LNN_LOGI(LNN_HEART_BEAT, "HB has active BT/BLE/P2P/HML connection. networkId=%{public}s, ret=%{public}s",
193                 anonyNetworkId, ret ? "true" : "false");
194             AnonymizeFree(anonyNetworkId);
195             return ret;
196         default:
197             break;
198     }
199     return false;
200 }
201 
LnnVisitHbTypeSet(VisitHbTypeCb callback,LnnHeartbeatType * typeSet,void * data)202 bool LnnVisitHbTypeSet(VisitHbTypeCb callback, LnnHeartbeatType *typeSet, void *data)
203 {
204     bool isFinish = false;
205     LnnHeartbeatType i;
206 
207     if (typeSet == NULL || *typeSet < HEARTBEAT_TYPE_MIN || *typeSet >= HEARTBEAT_TYPE_MAX) {
208         LNN_LOGE(LNN_HEART_BEAT, "HB visit typeSet get invalid param");
209         return false;
210     }
211     LnnHeartbeatType tmp = *typeSet;
212     for (i = HEARTBEAT_TYPE_MIN; i < HEARTBEAT_TYPE_MAX; i <<= 1) {
213         if ((i & tmp) == 0) {
214             continue;
215         }
216         isFinish = callback(typeSet, i, data);
217         if (!isFinish) {
218             return false;
219         }
220     }
221     return true;
222 }
223 
VisitCheckSupportedHbType(LnnHeartbeatType * typeSet,LnnHeartbeatType eachType,void * data)224 static bool VisitCheckSupportedHbType(LnnHeartbeatType *typeSet, LnnHeartbeatType eachType, void *data)
225 {
226     (void)typeSet;
227     LnnHeartbeatType *dstType = (LnnHeartbeatType *)data;
228 
229     if ((eachType & *dstType) == 0) {
230         LNN_LOGE(LNN_HEART_BEAT, "HB not support hbType=%{public}d completely", *dstType);
231         return false;
232     }
233     return true;
234 }
235 
LnnCheckSupportedHbType(LnnHeartbeatType * srcType,LnnHeartbeatType * dstType)236 bool LnnCheckSupportedHbType(LnnHeartbeatType *srcType, LnnHeartbeatType *dstType)
237 {
238     if (srcType == NULL || dstType == NULL) {
239         LNN_LOGE(LNN_HEART_BEAT, "HB check supported hbType get invalid param");
240         return false;
241     }
242     return LnnVisitHbTypeSet(VisitCheckSupportedHbType, srcType, dstType);
243 }
244 
LnnGenerateHexStringHash(const unsigned char * str,char * hashStr,uint32_t len)245 int32_t LnnGenerateHexStringHash(const unsigned char *str, char *hashStr, uint32_t len)
246 {
247     int32_t ret;
248     uint8_t hashResult[SHA_256_HASH_LEN] = { 0 };
249 
250     if (str == NULL) {
251         LNN_LOGE(LNN_HEART_BEAT, "HB generate str hash invalid param");
252         return SOFTBUS_INVALID_PARAM;
253     }
254     ret = SoftBusGenerateStrHash(str, strlen((char *)str), hashResult);
255     if (ret != SOFTBUS_OK) {
256         LNN_LOGE(LNN_HEART_BEAT, "HB generate str hash fail, ret=%{public}d", ret);
257         return ret;
258     }
259     ret = ConvertBytesToHexString(hashStr, len + 1, hashResult, len / HEXIFY_UNIT_LEN);
260     if (ret != SOFTBUS_OK) {
261         LNN_LOGE(LNN_HEART_BEAT, "HB convert bytes to str hash fail, ret=%{public}d", ret);
262         return ret;
263     }
264     return SOFTBUS_OK;
265 }
266 
LnnGetShortAccountHash(uint8_t * accountHash,uint32_t len)267 int32_t LnnGetShortAccountHash(uint8_t *accountHash, uint32_t len)
268 {
269     uint8_t localAccountHash[SHA_256_HASH_LEN] = { 0 };
270 
271     if (accountHash == NULL || len < HB_SHORT_ACCOUNT_HASH_LEN || len > SHA_256_HASH_LEN) {
272         LNN_LOGE(LNN_HEART_BEAT, "HB get accountHash get invaild param");
273         return SOFTBUS_INVALID_PARAM;
274     }
275     if (LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, localAccountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
276         LNN_LOGE(LNN_HEART_BEAT, "HB get local accountHash fail");
277         return SOFTBUS_ERR;
278     }
279     if (memcpy_s(accountHash, len, localAccountHash, len) != EOK) {
280         LNN_LOGI(LNN_HEART_BEAT, "HB get accountHash memcpy_s fail");
281         return SOFTBUS_MEM_ERR;
282     }
283     LNN_LOGD(LNN_HEART_BEAT, "HB get accountHash=[%{public}02x, %{public}02x]", accountHash[0], accountHash[1]);
284     return SOFTBUS_OK;
285 }
286 
LnnGenerateBtMacHash(const char * btMac,int32_t brMacLen,char * brMacHash,int32_t hashLen)287 int32_t LnnGenerateBtMacHash(const char *btMac, int32_t brMacLen, char *brMacHash, int32_t hashLen)
288 {
289     if (btMac == NULL || brMacHash == NULL) {
290         LNN_LOGE(LNN_HEART_BEAT, "null point");
291         return SOFTBUS_ERR;
292     }
293     if (brMacLen != BT_MAC_LEN || hashLen != BT_MAC_HASH_STR_LEN) {
294         LNN_LOGE(LNN_HEART_BEAT, "invaild len");
295         return SOFTBUS_ERR;
296     }
297     uint8_t btMacBin[BT_ADDR_LEN] = { 0 };
298     char btMacStr[BT_MAC_NO_COLON_LEN] = { 0 };
299     char hashLower[BT_MAC_HASH_STR_LEN] = { 0 };
300     char hash[BT_MAC_HASH_LEN] = { 0 };
301     if (ConvertBtMacToBinary(btMac, BT_MAC_LEN, btMacBin, BT_ADDR_LEN) != SOFTBUS_OK) {
302         LNN_LOGE(LNN_HEART_BEAT, "convert br mac to bin fail");
303         return SOFTBUS_ERR;
304     }
305     if (ConvertBtMacToStrNoColon(btMacStr, BT_MAC_NO_COLON_LEN, btMacBin, BT_ADDR_LEN)) {
306         LNN_LOGE(LNN_HEART_BEAT, "convert br mac to str fail");
307         return SOFTBUS_ERR;
308     }
309     char brMacUpper[BT_MAC_NO_COLON_LEN] = { 0 };
310     if (StringToUpperCase(btMacStr, brMacUpper, BT_MAC_NO_COLON_LEN) != SOFTBUS_OK) {
311         LNN_LOGE(LNN_HEART_BEAT, "bt mac to upperCase fail");
312         return SOFTBUS_ERR;
313     }
314     char *anonyMac = NULL;
315     Anonymize(brMacUpper, &anonyMac);
316     LNN_LOGI(LNN_HEART_BEAT, "upper BrMac=**:**:**:**:%{public}s", anonyMac);
317     AnonymizeFree(anonyMac);
318     if (SoftBusGenerateStrHash((const unsigned char *)brMacUpper, strlen(brMacUpper), (unsigned char *)hash)) {
319         LNN_LOGE(LNN_HEART_BEAT, "Generate brMac hash fail");
320         return SOFTBUS_ERR;
321     }
322     if (ConvertBytesToHexString(hashLower, BT_MAC_HASH_STR_LEN, (const uint8_t *)hash, BT_MAC_HASH_LEN) != SOFTBUS_OK) {
323         LNN_LOGE(LNN_HEART_BEAT, "ConvertBytesToHexString failed");
324         return SOFTBUS_ERR;
325     }
326     if (StringToUpperCase(hashLower, brMacHash, BT_MAC_HASH_STR_LEN) != SOFTBUS_OK) {
327         LNN_LOGE(LNN_HEART_BEAT, "bt mac to upperCase fail");
328         return SOFTBUS_ERR;
329     }
330     char *anonyUdid = NULL;
331     Anonymize(brMacHash, &anonyUdid);
332     LNN_LOGI(LNN_HEART_BEAT, "brmacHash=%{public}s", anonyUdid);
333     AnonymizeFree(anonyUdid);
334     return SOFTBUS_OK;
335 }
336 
LnnIsSupportBurstFeature(const char * networkId)337 bool LnnIsSupportBurstFeature(const char *networkId)
338 {
339     uint64_t localFeature;
340     uint64_t peerFeature;
341 
342     if (networkId == NULL) {
343         return false;
344     }
345     if (LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, &localFeature) != SOFTBUS_OK ||
346         LnnGetRemoteNumU64Info(networkId, NUM_KEY_FEATURE_CAPA, &peerFeature) != SOFTBUS_OK) {
347         LNN_LOGE(LNN_HEART_BEAT, "get local or remote feature fail");
348         return false;
349     }
350     return IsFeatureSupport(localFeature, BIT_BLE_SUPPORT_LP_HEARTBEAT) &&
351         IsFeatureSupport(peerFeature, BIT_BLE_SUPPORT_LP_HEARTBEAT);
352 }
353 
LnnIsLocalSupportBurstFeature(void)354 bool LnnIsLocalSupportBurstFeature(void)
355 {
356     uint64_t localFeature;
357     if (LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, &localFeature) != SOFTBUS_OK) {
358         LNN_LOGE(LNN_HEART_BEAT, "get local feature fail");
359         return false;
360     }
361     return IsFeatureSupport(localFeature, BIT_BLE_SUPPORT_LP_HEARTBEAT);
362 }
363 
LnnDumpLocalBasicInfo(void)364 void LnnDumpLocalBasicInfo(void)
365 {
366     char *anonyIp = NULL;
367     char *anonyBtMac = NULL;
368     char *anonyUdidHash = NULL;
369     char *anonyNetworkId = NULL;
370     char *anonyP2pMac = NULL;
371     char *anonyUdid = NULL;
372     char *anonyUuid = NULL;
373     char *anonyDeviceName = NULL;
374     char localIp[IP_LEN] = { 0 };
375     char localP2PMac[MAC_LEN] = { 0 };
376     char localBtMac[BT_MAC_LEN] = { 0 };
377     char localUdid[UDID_BUF_LEN] = { 0 };
378     char localUuid[UUID_BUF_LEN] = { 0 };
379     char udidShortHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
380     int32_t onlineNodeNum = 0;
381     NodeBasicInfo localInfo = { 0 };
382 
383     (void)LnnGetLocalDeviceInfo(&localInfo);
384     (void)LnnGetLocalStrInfo(STRING_KEY_UUID, localUuid, UUID_BUF_LEN);
385     (void)LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN);
386     Anonymize(udidShortHash, &anonyUdidHash);
387     Anonymize(localUuid, &anonyUuid);
388     Anonymize(localUdid, &anonyUdid);
389     Anonymize(localInfo.networkId, &anonyNetworkId);
390     LNN_LOGW(LNN_HEART_BEAT,
391         "local DeviceInfo, uuid=%{public}s, udid=%{public}s, udidShortHash=%{public}s, networkId=%{public}s",
392         anonyUuid, anonyUdid, anonyUdidHash, anonyNetworkId);
393     AnonymizeFree(anonyUuid);
394     AnonymizeFree(anonyUdid);
395     AnonymizeFree(anonyUdidHash);
396     AnonymizeFree(anonyNetworkId);
397     const char *devTypeStr = LnnConvertIdToDeviceType(localInfo.deviceTypeId);
398     (void)LnnGetLocalStrInfo(STRING_KEY_WLAN_IP, localIp, IP_LEN);
399     (void)LnnGetLocalStrInfo(STRING_KEY_P2P_MAC, localP2PMac, MAC_LEN);
400     (void)LnnGetLocalStrInfo(STRING_KEY_BT_MAC, localBtMac, BT_MAC_LEN);
401     (void)LnnGetAllOnlineNodeNum(&onlineNodeNum);
402     Anonymize(localIp, &anonyIp);
403     Anonymize(localBtMac, &anonyBtMac);
404     Anonymize(localP2PMac, &anonyP2pMac);
405     Anonymize(localInfo.deviceName, &anonyDeviceName);
406     LNN_LOGI(LNN_HEART_BEAT,
407         "devType=%{public}s, deviceTypeId=%{public}hu, deviceName=%{public}s, ip=%{public}s, brMac=%{public}s, "
408         "p2pMac=%{public}s, onlineNodeNum=%{public}d",
409         devTypeStr, localInfo.deviceTypeId, anonyDeviceName, anonyIp, anonyBtMac, anonyP2pMac, onlineNodeNum);
410     AnonymizeFree(anonyDeviceName);
411     AnonymizeFree(anonyIp);
412     AnonymizeFree(anonyBtMac);
413     AnonymizeFree(anonyP2pMac);
414 }
415 
LnnDumpPrintUdid(const char * networkId)416 static int32_t LnnDumpPrintUdid(const char *networkId)
417 {
418     char udid[UDID_BUF_LEN] = {0};
419     if (LnnGetRemoteStrInfo(networkId, STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
420         LNN_LOGE(LNN_HEART_BEAT, "get udid failed");
421         return SOFTBUS_LANE_GET_LEDGER_INFO_ERR;
422     }
423     char *tmpUdid = NULL;
424     Anonymize(udid, &tmpUdid);
425     LNN_LOGI(LNN_HEART_BEAT, "Udid=%{public}s", tmpUdid);
426     AnonymizeFree(tmpUdid);
427     return SOFTBUS_OK;
428 }
429 
LnnDumpPrintUuid(const char * networkId)430 static int32_t LnnDumpPrintUuid(const char *networkId)
431 {
432     char uuid[UUID_BUF_LEN] = {0};
433     if (LnnGetRemoteStrInfo(networkId, STRING_KEY_UUID, uuid, UUID_BUF_LEN) != SOFTBUS_OK) {
434         LNN_LOGE(LNN_HEART_BEAT, "get uuid failed");
435         return SOFTBUS_LANE_GET_LEDGER_INFO_ERR;
436     }
437     char *tmpUuid = NULL;
438     Anonymize(uuid, &tmpUuid);
439     LNN_LOGI(LNN_HEART_BEAT, "Uuid=%{public}s", tmpUuid);
440     AnonymizeFree(tmpUuid);
441     return SOFTBUS_OK;
442 }
443 
LnnDumpPrintMac(const char * networkId)444 static int32_t LnnDumpPrintMac(const char *networkId)
445 {
446     char brMac[BT_MAC_LEN] = {0};
447     if (LnnGetRemoteStrInfo(networkId, STRING_KEY_BT_MAC, brMac, BT_MAC_LEN) != SOFTBUS_OK) {
448         LNN_LOGE(LNN_HEART_BEAT, "get brMac failed");
449         return SOFTBUS_LANE_GET_LEDGER_INFO_ERR;
450     }
451     char *tmpBrMac = NULL;
452     Anonymize(brMac, &tmpBrMac);
453     LNN_LOGI(LNN_HEART_BEAT, "BrMac=%{public}s", tmpBrMac);
454     AnonymizeFree(tmpBrMac);
455     return SOFTBUS_OK;
456 }
457 
LnnDumpPrintIp(const char * networkId)458 static int32_t LnnDumpPrintIp(const char *networkId)
459 {
460     char ipAddr[IP_STR_MAX_LEN] = {0};
461     if (LnnGetRemoteStrInfo(networkId, STRING_KEY_WLAN_IP, ipAddr, IP_STR_MAX_LEN) != SOFTBUS_OK) {
462         LNN_LOGE(LNN_HEART_BEAT, "get ipAddr failed");
463         return SOFTBUS_LANE_GET_LEDGER_INFO_ERR;
464     }
465     char *tmpIpAddr = NULL;
466     Anonymize(ipAddr, &tmpIpAddr);
467     LNN_LOGI(LNN_HEART_BEAT, "IpAddr=%{public}s", tmpIpAddr);
468     AnonymizeFree(tmpIpAddr);
469     return SOFTBUS_OK;
470 }
471 
LnnDumpPrintNetCapacity(const char * networkId)472 static int32_t LnnDumpPrintNetCapacity(const char *networkId)
473 {
474     uint32_t netCapacity = 0;
475     if (LnnGetRemoteNumU32Info(networkId, NUM_KEY_NET_CAP, &netCapacity) != SOFTBUS_OK) {
476         LNN_LOGE(LNN_HEART_BEAT, "get netCapacity failed");
477         return SOFTBUS_LANE_GET_LEDGER_INFO_ERR;
478     }
479     LNN_LOGI(LNN_HEART_BEAT, "NetCapacity=%{public}u", netCapacity);
480     return SOFTBUS_OK;
481 }
482 
LnnDumpPrintNetType(const char * networkId)483 static int32_t LnnDumpPrintNetType(const char *networkId)
484 {
485     int32_t netType = 0;
486     if (LnnGetRemoteNumInfo(networkId, NUM_KEY_DISCOVERY_TYPE, &netType) != SOFTBUS_OK) {
487         LNN_LOGE(LNN_HEART_BEAT, "get netType fail");
488         return SOFTBUS_LANE_GET_LEDGER_INFO_ERR;
489     }
490     LNN_LOGI(LNN_HEART_BEAT, "NetType=%{public}d", netType);
491     return SOFTBUS_OK;
492 }
493 
LnnDumpOnlinePrintInfo(NodeBasicInfo * nodeInfo)494 static void LnnDumpOnlinePrintInfo(NodeBasicInfo *nodeInfo)
495 {
496     if (nodeInfo == NULL) {
497         LNN_LOGE(LNN_HEART_BEAT, "param is null");
498         return;
499     }
500     char *anonyDeviceName = NULL;
501     Anonymize(nodeInfo->deviceName, &anonyDeviceName);
502     LNN_LOGI(LNN_HEART_BEAT, "DeviceName=%{public}s", anonyDeviceName);
503     AnonymizeFree(anonyDeviceName);
504     char *tmpNetWorkId = NULL;
505     Anonymize(nodeInfo->networkId, &tmpNetWorkId);
506     LNN_LOGI(LNN_HEART_BEAT, "NetworkId=%{public}s", tmpNetWorkId);
507     AnonymizeFree(tmpNetWorkId);
508     if (LnnDumpPrintUdid(nodeInfo->networkId) != SOFTBUS_OK) {
509         LNN_LOGE(LNN_HEART_BEAT, "LnnDumpPrintUdid failed");
510         return;
511     }
512     if (LnnDumpPrintUuid(nodeInfo->networkId) != SOFTBUS_OK) {
513         LNN_LOGE(LNN_HEART_BEAT, "LnnDumpPrintUuid failed");
514         return;
515     }
516     if (LnnDumpPrintMac(nodeInfo->networkId) != SOFTBUS_OK) {
517         LNN_LOGE(LNN_HEART_BEAT, "LnnDumpPrintMac failed");
518         return;
519     }
520     if (LnnDumpPrintIp(nodeInfo->networkId) != SOFTBUS_OK) {
521         LNN_LOGE(LNN_HEART_BEAT, "LnnDumpPrintMac failed");
522         return;
523     }
524     if (LnnDumpPrintNetCapacity(nodeInfo->networkId) != SOFTBUS_OK) {
525         LNN_LOGE(LNN_HEART_BEAT, "LnnDumpPrintNetCapacity failed");
526         return;
527     }
528     if (LnnDumpPrintNetType(nodeInfo->networkId) != SOFTBUS_OK) {
529         LNN_LOGE(LNN_HEART_BEAT, "LnnDumpPrintNetType failed");
530         return;
531     }
532 }
533 
LnnDumpOnlineDeviceInfo(void)534 void LnnDumpOnlineDeviceInfo(void)
535 {
536     NodeBasicInfo *info = NULL;
537     int32_t infoNum = 0;
538     if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
539         LNN_LOGE(LNN_HEART_BEAT, "Lnn get online node fail");
540         return;
541     }
542     if (info == NULL || infoNum == 0) {
543         LNN_LOGE(LNN_HEART_BEAT, "online count is zero");
544         return;
545     }
546     LNN_LOGI(LNN_HEART_BEAT, "online device num=%{public}d", infoNum);
547     for (int32_t i = 0; i < infoNum; i++) {
548         LNN_LOGI(LNN_HEART_BEAT, "[NO.%{public}d]", i + 1);
549         LnnDumpOnlinePrintInfo(info + i);
550     }
551     SoftBusFree(info);
552 }
553 
GenerateRandomNumForHb(uint32_t randMin,uint32_t randMax)554 uint32_t GenerateRandomNumForHb(uint32_t randMin, uint32_t randMax)
555 {
556     if (randMin >= randMax) {
557         return randMin - randMax;
558     }
559 
560     time_t currTime = time(NULL);
561     if (currTime == 0) {
562         LNN_LOGI(LNN_HEART_BEAT, "seed is 0, just ignore");
563     }
564     srand(currTime);
565     uint32_t random = (uint32_t)rand() % (randMax - randMin);
566     return randMin + random;
567 }
568 
GetOnlineInfoNum(int32_t * nums)569 static int32_t GetOnlineInfoNum(int32_t *nums)
570 {
571     int32_t infoNum = 0;
572     NodeBasicInfo *netInfo = NULL;
573     if (LnnGetAllOnlineNodeInfo(&netInfo, &infoNum) != SOFTBUS_OK) {
574         LNN_LOGE(LNN_BUILDER, "get all online node info fail.");
575         return SOFTBUS_ERR;
576     }
577     if (netInfo == NULL || infoNum == 0) {
578         LNN_LOGI(LNN_BUILDER, "online device num is 0, not need to send network info");
579         return SOFTBUS_ERR;
580     }
581     *nums = infoNum;
582     LNN_LOGD(LNN_HEART_BEAT, "online nums=%{public}d", infoNum);
583     SoftBusFree(netInfo);
584     return SOFTBUS_OK;
585 }
586 
LnnIsMultiDeviceOnline(void)587 bool LnnIsMultiDeviceOnline(void)
588 {
589     int32_t onlineNum = 0;
590 
591     return GetOnlineInfoNum(&onlineNum) == SOFTBUS_OK && onlineNum >= HB_MULTI_DEVICE_THRESHOLD;
592 }
593 
LnnIsSupportHeartbeatCap(uint32_t hbCapacity,HeartbeatCapability capaBit)594 bool LnnIsSupportHeartbeatCap(uint32_t hbCapacity, HeartbeatCapability capaBit)
595 {
596     return ((hbCapacity & (1 << (uint32_t) capaBit)) != 0);
597 }
598