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_net_builder.h"
17 
18 #include <securec.h>
19 #include <stdlib.h>
20 #include <inttypes.h>
21 
22 #include "anonymizer.h"
23 #include "auth_common.h"
24 #include "auth_deviceprofile.h"
25 #include "auth_interface.h"
26 #include "auth_request.h"
27 #include "auth_request.h"
28 #include "auth_hichain_adapter.h"
29 #include "bus_center_event.h"
30 #include "bus_center_manager.h"
31 #include "common_list.h"
32 #include "lnn_async_callback_utils.h"
33 #include "lnn_battery_info.h"
34 #include "lnn_cipherkey_manager.h"
35 #include "lnn_connection_addr_utils.h"
36 #include "lnn_connection_fsm.h"
37 #include "lnn_deviceinfo_to_profile.h"
38 #include "lnn_devicename_info.h"
39 #include "lnn_discovery_manager.h"
40 #include "lnn_distributed_net_ledger.h"
41 #include "lnn_fast_offline.h"
42 #include "lnn_heartbeat_utils.h"
43 #include "lnn_kv_adapter_wrapper.h"
44 #include "lnn_link_finder.h"
45 #include "lnn_local_net_ledger.h"
46 #include "lnn_log.h"
47 #include "lnn_map.h"
48 #include "lnn_network_id.h"
49 #include "lnn_network_info.h"
50 #include "lnn_network_manager.h"
51 #include "lnn_node_info.h"
52 #include "lnn_node_weight.h"
53 #include "lnn_ohos_account.h"
54 #include "lnn_p2p_info.h"
55 #include "lnn_physical_subnet_manager.h"
56 #include "lnn_sync_info_manager.h"
57 #include "lnn_sync_item_info.h"
58 #include "lnn_topo_manager.h"
59 #include "softbus_adapter_bt_common.h"
60 #include "softbus_adapter_crypto.h"
61 #include "softbus_adapter_json.h"
62 #include "softbus_adapter_mem.h"
63 #include "softbus_errcode.h"
64 #include "softbus_feature_config.h"
65 #include "softbus_hisysevt_bus_center.h"
66 #include "softbus_json_utils.h"
67 #include "softbus_adapter_json.h"
68 #include "softbus_utils.h"
69 #include "softbus_wifi_api_adapter.h"
70 #include "lnn_net_builder_process.h"
71 #include "lnn_net_builder_init.h"
72 
73 #define LNN_CONN_CAPABILITY_MSG_LEN      8
74 #define JSON_KEY_MASTER_UDID             "MasterUdid"
75 #define JSON_KEY_MASTER_WEIGHT           "MasterWeight"
76 #define NOT_TRUSTED_DEVICE_MSG_DELAY     5000
77 #define SHORT_UDID_HASH_STR_LEN          16
78 #define DEFAULT_PKG_NAME                 "com.huawei.nearby"
79 #define WAIT_SEND_NOT_TRUST_MSG          200
80 #define PROOF_INFO_MAX_BUFFER_LEN        (2 * 1024)
81 
82 static NetBuilder g_netBuilder;
83 static bool g_watchdogFlag = true;
84 
85 static Map g_lnnDfxReportMap;
86 static SoftBusMutex g_lnnDfxReportMutex;
87 static bool g_lnnDfxReportIsInit = false;
88 
89 static Map g_lnnDfxPcMap;
90 static SoftBusMutex g_lnnDfxPcMutex;
91 static bool g_lnnDfxPcIsInit = false;
92 
SfcSyncNodeAddrHandle(const char * networkId,int32_t code)93 void __attribute__((weak)) SfcSyncNodeAddrHandle(const char *networkId, int32_t code)
94 {
95     (void)networkId;
96     (void)code;
97 }
98 
SetWatchdogFlag(bool flag)99 void SetWatchdogFlag(bool flag)
100 {
101     g_watchdogFlag = flag;
102 }
103 
GetWatchdogFlag(void)104 bool GetWatchdogFlag(void)
105 {
106     return g_watchdogFlag;
107 }
108 
LnnGetNetBuilder(void)109 NetBuilder* LnnGetNetBuilder(void)
110 {
111     return &g_netBuilder;
112 }
CreateNetBuilderMessage(int32_t msgType,void * para)113 static SoftBusMessage *CreateNetBuilderMessage(int32_t msgType, void *para)
114 {
115     SoftBusMessage *msg = (SoftBusMessage *)SoftBusCalloc(sizeof(SoftBusMessage));
116     if (msg == NULL) {
117         LNN_LOGE(LNN_BUILDER, "malloc softbus message failed");
118         return NULL;
119     }
120     msg->what = msgType;
121     msg->obj = para;
122     msg->handler = &g_netBuilder.handler;
123     return msg;
124 }
125 
PostBuildMessageToHandler(int32_t msgType,void * para)126 int32_t PostBuildMessageToHandler(int32_t msgType, void *para)
127 {
128     SoftBusMessage *msg = CreateNetBuilderMessage(msgType, para);
129     if (msg == NULL) {
130         LNN_LOGE(LNN_BUILDER, "create softbus message failed");
131         return SOFTBUS_ERR;
132     }
133     g_netBuilder.looper->PostMessage(g_netBuilder.looper, msg);
134     return SOFTBUS_OK;
135 }
136 
IsNodeOnline(const char * networkId)137 bool IsNodeOnline(const char *networkId)
138 {
139     return LnnGetOnlineStateById(networkId, CATEGORY_NETWORK_ID);
140 }
141 
UpdateLocalMasterNode(bool isCurrentNode,const char * masterUdid,int32_t weight)142 void UpdateLocalMasterNode(bool isCurrentNode, const char *masterUdid, int32_t weight)
143 {
144     if (LnnSetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, masterUdid) != SOFTBUS_OK) {
145         LNN_LOGE(LNN_BUILDER, "set local master udid failed");
146         return;
147     }
148     if (LnnSetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, weight) != SOFTBUS_OK) {
149         LNN_LOGE(LNN_BUILDER, "set local master weight failed");
150     }
151     LnnNotifyMasterNodeChanged(isCurrentNode, masterUdid, weight);
152     LNN_LOGI(LNN_BUILDER, "update local master weight. weight=%{public}d", weight);
153 }
154 
IsNeedSyncElectMsg(const char * networkId)155 static bool IsNeedSyncElectMsg(const char *networkId)
156 {
157     NodeInfo nodeInfo;
158     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
159     if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
160         return false;
161     }
162     return LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_WIFI);
163 }
164 
SyncElectMessage(const char * networkId)165 int32_t SyncElectMessage(const char *networkId)
166 {
167     char masterUdid[UDID_BUF_LEN] = { 0 };
168     int32_t masterWeight;
169     char *data = NULL;
170     cJSON *json = NULL;
171     int32_t rc;
172 
173     if (!IsNeedSyncElectMsg(networkId)) {
174         char *anonyNetworkId = NULL;
175         Anonymize(networkId, &anonyNetworkId);
176         LNN_LOGW(LNN_BUILDER, "no ip networking, dont sync elect msg, networkId=%{public}s", anonyNetworkId);
177         AnonymizeFree(anonyNetworkId);
178         return SOFTBUS_OK;
179     }
180     if (LnnGetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, masterUdid, UDID_BUF_LEN) != SOFTBUS_OK ||
181         LnnGetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, &masterWeight) != SOFTBUS_OK) {
182         LNN_LOGE(LNN_BUILDER, "get local master node info failed");
183         return SOFTBUS_INVALID_PARAM;
184     }
185     json = cJSON_CreateObject();
186     if (json == NULL) {
187         LNN_LOGE(LNN_BUILDER, "create elect json object failed");
188         return SOFTBUS_CREATE_JSON_ERR;
189     }
190     if (!AddStringToJsonObject(json, JSON_KEY_MASTER_UDID, masterUdid) ||
191         !AddNumberToJsonObject(json, JSON_KEY_MASTER_WEIGHT, masterWeight)) {
192         LNN_LOGE(LNN_BUILDER, "add elect info to json failed");
193         cJSON_Delete(json);
194         return SOFTBUS_ERR;
195     }
196     data = cJSON_PrintUnformatted(json);
197     cJSON_Delete(json);
198     if (data == NULL) {
199         LNN_LOGE(LNN_BUILDER, "format elect packet fail");
200         return SOFTBUS_ERR;
201     }
202     rc = LnnSendSyncInfoMsg(LNN_INFO_TYPE_MASTER_ELECT, networkId, (uint8_t *)data, strlen(data) + 1, NULL);
203     cJSON_free(data);
204     return rc;
205 }
206 
SendElectMessageToAll(const char * skipNetworkId)207 void SendElectMessageToAll(const char *skipNetworkId)
208 {
209     LnnConnectionFsm *item = NULL;
210 
211     LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
212         if (skipNetworkId != NULL && strcmp(item->connInfo.peerNetworkId, skipNetworkId) == 0) {
213             continue;
214         }
215         if (!IsNodeOnline(item->connInfo.peerNetworkId)) {
216             continue;
217         }
218         if (SyncElectMessage(item->connInfo.peerNetworkId) != SOFTBUS_OK) {
219             LNN_LOGE(LNN_BUILDER, "sync elect info to conn failed. connFsm=%{public}u", item->id);
220         }
221     }
222 }
223 
FreeJoinLnnMsgPara(const JoinLnnMsgPara * para)224 static void FreeJoinLnnMsgPara(const JoinLnnMsgPara *para)
225 {
226     if (para == NULL) {
227         return;
228     }
229     if (para->dupInfo != NULL) {
230         SoftBusFree((void *)para->dupInfo);
231     }
232     SoftBusFree((void *)para);
233 }
234 
TrySendJoinLNNRequest(const JoinLnnMsgPara * para,bool needReportFailure,bool isShort)235 int32_t TrySendJoinLNNRequest(const JoinLnnMsgPara *para, bool needReportFailure, bool isShort)
236 {
237     int32_t ret = SOFTBUS_OK;
238     LNN_CHECK_AND_RETURN_RET_LOGW(para != NULL, SOFTBUS_INVALID_PARAM, LNN_BUILDER, "para is NULL");
239     DfxRecordLnnServerjoinStart(&para->addr, para->pkgName, needReportFailure);
240     isShort = para->isNeedConnect ? false : true;
241     LnnConnectionFsm *connFsm = FindConnectionFsmByAddr(&para->addr, isShort);
242     if (connFsm == NULL || connFsm->isDead || CheckRemoteBasicInfoChanged(para->dupInfo)) {
243         if (TryPendingJoinRequest(para, needReportFailure)) {
244             LNN_LOGI(LNN_BUILDER, "join request is pending, peerAddr=%{public}s", LnnPrintConnectionAddr(&para->addr));
245             FreeJoinLnnMsgPara(para);
246             return SOFTBUS_OK;
247         }
248         ret = PostJoinRequestToConnFsm(connFsm, para, needReportFailure);
249         FreeJoinLnnMsgPara(para);
250         return ret;
251     }
252     connFsm->connInfo.flag |= (needReportFailure ? LNN_CONN_INFO_FLAG_JOIN_REQUEST : LNN_CONN_INFO_FLAG_JOIN_AUTO);
253     connFsm->connInfo.infoReport = para->infoReport;
254     if ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_ONLINE) != 0) {
255         if (connFsm->connInfo.addr.type == CONNECTION_ADDR_WLAN || connFsm->connInfo.addr.type == CONNECTION_ADDR_ETH) {
256             char uuid[UUID_BUF_LEN] = {0};
257             (void)LnnConvertDlId(connFsm->connInfo.peerNetworkId, CATEGORY_NETWORK_ID, CATEGORY_UUID,
258                 uuid, UUID_BUF_LEN);
259             (void)AuthFlushDevice(uuid);
260         }
261         if ((LnnSendJoinRequestToConnFsm(connFsm) != SOFTBUS_OK) && needReportFailure) {
262             LNN_LOGE(LNN_BUILDER, "online status, process join lnn request failed");
263             LnnNotifyJoinResult((ConnectionAddr *)&para->addr, NULL, SOFTBUS_ERR);
264         }
265     }
266     LNN_LOGI(LNN_BUILDER, "addr same to before, peerAddr=%{public}s", LnnPrintConnectionAddr(&para->addr));
267     ConnectionAddr addr = para->addr;
268     if (addr.type != CONNECTION_ADDR_WLAN ||
269         !IsNeedWifiReauth(connFsm->connInfo.peerNetworkId, addr.peerUid, MAX_ACCOUNT_HASH_LEN)) {
270         LNN_LOGI(LNN_BUILDER, "account not change no need reauth");
271         FreeJoinLnnMsgPara(para);
272         return SOFTBUS_OK;
273     }
274     AuthConnInfo authConn;
275     uint32_t requestId = AuthGenRequestId();
276     (void)LnnConvertAddrToAuthConnInfo(&addr, &authConn);
277     DfxRecordLnnAuthStart(&authConn, para, requestId);
278     FreeJoinLnnMsgPara(para);
279     if (AuthStartVerify(&authConn, requestId, LnnGetReAuthVerifyCallback(), AUTH_MODULE_LNN, false) != SOFTBUS_OK) {
280         LNN_LOGI(LNN_BUILDER, "AuthStartVerify error");
281         return SOFTBUS_ERR;
282     }
283     return SOFTBUS_OK;
284 }
285 
NeedPendingJoinRequest(void)286 bool NeedPendingJoinRequest(void)
287 {
288     int32_t count = 0;
289     LnnConnectionFsm *item = NULL;
290 
291     if (g_netBuilder.maxConcurrentCount == 0) { // do not limit concurent
292         return false;
293     }
294     LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
295         if (item->isDead) {
296             continue;
297         }
298         if ((item->connInfo.flag & LNN_CONN_INFO_FLAG_ONLINE) != 0) {
299             continue;
300         }
301         ++count;
302         if (count >= g_netBuilder.maxConcurrentCount) {
303             return true;
304         }
305     }
306     return false;
307 }
308 
IsSamePendingRequest(const PendingJoinRequestNode * request)309 static bool IsSamePendingRequest(const PendingJoinRequestNode *request)
310 {
311     PendingJoinRequestNode *item = NULL;
312 
313     LIST_FOR_EACH_ENTRY(item, &g_netBuilder.pendingList, PendingJoinRequestNode, node) {
314         if (LnnIsSameConnectionAddr(&item->addr, &request->addr, false) &&
315             item->needReportFailure == request->needReportFailure) {
316             LNN_LOGD(LNN_BUILDER, "have the same pending join request");
317             return true;
318         }
319     }
320     return false;
321 }
322 
TryPendingJoinRequest(const JoinLnnMsgPara * para,bool needReportFailure)323 bool TryPendingJoinRequest(const JoinLnnMsgPara *para, bool needReportFailure)
324 {
325     PendingJoinRequestNode *request = NULL;
326     if (para == NULL || !para->isNeedConnect) {
327         LNN_LOGI(LNN_BUILDER, "no connect online, no need pending");
328         return false;
329     }
330     if (!NeedPendingJoinRequest()) {
331         return false;
332     }
333     request = (PendingJoinRequestNode *)SoftBusCalloc(sizeof(PendingJoinRequestNode));
334     if (request == NULL) {
335         LNN_LOGE(LNN_BUILDER, "malloc pending join request fail, go on it");
336         return false;
337     }
338     ListInit(&request->node);
339     request->addr = para->addr;
340     request->needReportFailure = needReportFailure;
341     if (IsSamePendingRequest(request)) {
342         SoftBusFree(request);
343         return true;
344     }
345     ListTailInsert(&g_netBuilder.pendingList, &request->node);
346     return true;
347 }
348 
RemovePendingRequestByAddrType(const bool * addrType,uint32_t typeLen)349 void RemovePendingRequestByAddrType(const bool *addrType, uint32_t typeLen)
350 {
351     PendingJoinRequestNode *item = NULL;
352     PendingJoinRequestNode *next = NULL;
353 
354     if (addrType == NULL || typeLen != CONNECTION_ADDR_MAX) {
355         LNN_LOGE(LNN_BUILDER, "invalid typeLen=%{public}d", typeLen);
356         return;
357     }
358     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_netBuilder.pendingList, PendingJoinRequestNode, node) {
359         if (!addrType[item->addr.type]) {
360             continue;
361         }
362         ListDelete(&item->node);
363         LNN_LOGI(LNN_BUILDER, "clean a pending join request, peerAddr=%{public}s", LnnPrintConnectionAddr(&item->addr));
364         SoftBusFree(item);
365     }
366 }
367 
IsNeedWifiReauth(const char * networkId,const char * newAccountHash,int32_t len)368 bool IsNeedWifiReauth(const char *networkId, const char *newAccountHash, int32_t len)
369 {
370     if (LnnIsDefaultOhosAccount()) {
371         LNN_LOGE(LNN_BUILDER, "local account is default");
372         return false;
373     }
374     NodeInfo info;
375     (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
376     if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
377         LNN_LOGE(LNN_BUILDER, "get node info fail");
378         return false;
379     }
380     char *anonyNetworkId = NULL;
381     Anonymize(networkId, &anonyNetworkId);
382     LNN_LOGI(LNN_BUILDER, "peer networkId=%{public}s, accountHash:%{public}02x%{public}02x->%{public}02x%{public}02x",
383         anonyNetworkId, info.accountHash[0], info.accountHash[1], newAccountHash[0], newAccountHash[1]);
384     AnonymizeFree(anonyNetworkId);
385     uint8_t defaultAccountHash[SHA_256_HASH_LEN] = {0};
386     const char *defaultUserId = "0";
387     if (SoftBusGenerateStrHash((const unsigned char *)defaultUserId, strlen(defaultUserId), defaultAccountHash) !=
388         SOFTBUS_OK) {
389         LNN_LOGE(LNN_BUILDER, "generate default str hash fail");
390         return false;
391     }
392     bool isNullAccount = true;
393     for (int32_t i = 0; i < len; ++i) {
394         if (newAccountHash[i] != 0) {
395             isNullAccount = false;
396             break;
397         }
398     }
399     if (isNullAccount || memcmp(newAccountHash, defaultAccountHash, HB_SHORT_ACCOUNT_HASH_LEN) == 0) {
400         LNN_LOGE(LNN_BUILDER, "accountHash is null or account is default");
401         return false;
402     }
403     return memcmp(info.accountHash, newAccountHash, HB_SHORT_ACCOUNT_HASH_LEN) != 0;
404 }
405 
BuildLnnEvent(LnnEventExtra * lnnEventExtra,const ConnectionAddr * addr)406 static void BuildLnnEvent(LnnEventExtra *lnnEventExtra, const ConnectionAddr *addr)
407 {
408     if (lnnEventExtra == NULL || addr == NULL) {
409         LNN_LOGW(LNN_STATE, "lnnEventExtra or addr is null");
410         return;
411     }
412     switch (addr->type) {
413         case CONNECTION_ADDR_BR:
414             lnnEventExtra->peerBrMac = addr->info.br.brMac;
415             break;
416         case CONNECTION_ADDR_BLE:
417             lnnEventExtra->peerBleMac = addr->info.ble.bleMac;
418             break;
419         case CONNECTION_ADDR_WLAN:
420             /* fall-through */
421         case CONNECTION_ADDR_ETH:
422             lnnEventExtra->peerIp = addr->info.ip.ip;
423             break;
424         default:
425             LNN_LOGE(LNN_BUILDER, "unknown param type!");
426             break;
427     }
428 }
429 
DfxRecordLnnServerjoinStart(const ConnectionAddr * addr,const char * packageName,bool needReportFailure)430 void DfxRecordLnnServerjoinStart(const ConnectionAddr *addr, const char *packageName, bool needReportFailure)
431 {
432     LnnEventExtra extra = { 0 };
433     LnnEventExtraInit(&extra);
434 
435     char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
436     if (packageName != NULL && IsValidString(packageName, PKG_NAME_SIZE_MAX - 1) && strncpy_s(pkgName,
437         PKG_NAME_SIZE_MAX, packageName, PKG_NAME_SIZE_MAX - 1) == EOK) {
438         extra.callerPkg = pkgName;
439     }
440     if (addr != NULL) {
441         BuildLnnEvent(&extra, addr);
442     }
443     LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_JOIN_LNN_START, extra);
444 }
445 
DfxRecordLnnAuthStart(const AuthConnInfo * connInfo,const JoinLnnMsgPara * para,uint32_t requestId)446 void DfxRecordLnnAuthStart(const AuthConnInfo *connInfo, const JoinLnnMsgPara *para, uint32_t requestId)
447 {
448     LnnEventExtra extra = { 0 };
449     LnnEventExtraInit(&extra);
450     extra.authRequestId = (int32_t)requestId;
451 
452     if (connInfo != NULL) {
453         extra.authLinkType = connInfo->type;
454     }
455     if (para != NULL && IsValidString(para->pkgName, PKG_NAME_SIZE_MAX - 1)) {
456         extra.callerPkg = para->pkgName;
457     }
458     LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH, extra);
459 }
460 
DupNodeInfo(const NodeInfo * nodeInfo)461 NodeInfo *DupNodeInfo(const NodeInfo *nodeInfo)
462 {
463     NodeInfo *node = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
464     if (node == NULL) {
465         LNN_LOGE(LNN_BUILDER, "malloc NodeInfo fail");
466         return NULL;
467     }
468     if (memcpy_s(node, sizeof(NodeInfo), nodeInfo, sizeof(NodeInfo)) != EOK) {
469         LNN_LOGE(LNN_BUILDER, "copy NodeInfo fail");
470         SoftBusFree(node);
471         return NULL;
472     }
473     return node;
474 }
475 
GetCurrentConnectType(void)476 ConnectionAddrType GetCurrentConnectType(void)
477 {
478     char ifCurrentName[NET_IF_NAME_LEN] = { 0 };
479     ConnectionAddrType type = CONNECTION_ADDR_MAX;
480 
481     if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifCurrentName, NET_IF_NAME_LEN) != SOFTBUS_OK) {
482         LNN_LOGE(LNN_BUILDER, "LnnGetLocalStrInfo getCurrentConnectType failed");
483         return type;
484     }
485     if (LnnGetAddrTypeByIfName(ifCurrentName, &type) != SOFTBUS_OK) {
486         LNN_LOGE(LNN_BUILDER, "getCurrentConnectType unknown connect type");
487     }
488     return type;
489 }
490 
OnLnnProcessNotTrustedMsgDelay(void * para)491 void OnLnnProcessNotTrustedMsgDelay(void *para)
492 {
493     if (para == NULL) {
494         LNN_LOGW(LNN_BUILDER, "invalid para");
495         return;
496     }
497     int64_t authSeq[DISCOVERY_TYPE_COUNT] = { 0 };
498     NotTrustedDelayInfo *info = (NotTrustedDelayInfo *)para;
499     if (!LnnGetOnlineStateById(info->udid, CATEGORY_UDID)) {
500         LNN_LOGI(LNN_BUILDER, "device is offline");
501         SoftBusFree(info);
502         return;
503     }
504     if (AuthGetLatestAuthSeqList(info->udid, authSeq, DISCOVERY_TYPE_COUNT) != SOFTBUS_OK) {
505         LNN_LOGE(LNN_BUILDER, "get latest authSeq list fail");
506         SoftBusFree(info);
507         return;
508     }
509     char networkId[NETWORK_ID_BUF_LEN] = { 0 };
510     if (LnnConvertDlId(info->udid, CATEGORY_UDID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
511         LNN_LOGE(LNN_BUILDER, "LnnConvertDlId fail");
512         SoftBusFree(info);
513         return;
514     }
515     uint32_t type;
516     for (type = DISCOVERY_TYPE_WIFI; type < DISCOVERY_TYPE_P2P; type++) {
517         LNN_LOGI(
518             LNN_BUILDER, "after 5s, authSeq:%{public}" PRId64 "->%{public}" PRId64, info->authSeq[type], authSeq[type]);
519         if (authSeq[type] == info->authSeq[type] && authSeq[type] != 0 && info->authSeq[type] != 0) {
520             char *anonyNetworkId = NULL;
521             Anonymize(networkId, &anonyNetworkId);
522             LNN_LOGI(LNN_BUILDER, "networkId=%{public}s, LnnRequestLeaveSpecificType=%{public}d", anonyNetworkId, type);
523             AnonymizeFree(anonyNetworkId);
524             LnnRequestLeaveSpecific(networkId, LnnDiscTypeToConnAddrType((DiscoveryType)type));
525             continue;
526         }
527     }
528     SoftBusFree(info);
529 }
530 
LnnProcessCompleteNotTrustedMsg(LnnSyncInfoType syncType,const char * networkId,const uint8_t * msg,uint32_t len)531 void LnnProcessCompleteNotTrustedMsg(LnnSyncInfoType syncType, const char *networkId,
532     const uint8_t *msg, uint32_t len)
533 {
534     if (networkId == NULL || syncType != LNN_INFO_TYPE_NOT_TRUSTED || msg == NULL) {
535         LNN_LOGW(LNN_BUILDER, "invalid param");
536         return;
537     }
538     if (!LnnGetOnlineStateById(networkId, CATEGORY_NETWORK_ID)) {
539         LNN_LOGI(LNN_BUILDER, "device is offline");
540         return;
541     }
542     JsonObj *json = JSON_Parse((const char *)msg, len);
543     if (json == NULL) {
544         LNN_LOGE(LNN_BUILDER, "json parse fail");
545         return;
546     }
547     int64_t authSeq[DISCOVERY_TYPE_COUNT] = { 0 };
548     (void)JSON_GetInt64FromOject(json, NETWORK_TYPE_WIFI, &authSeq[DISCOVERY_TYPE_WIFI]);
549     (void)JSON_GetInt64FromOject(json, NETWORK_TYPE_BLE, &authSeq[DISCOVERY_TYPE_BLE]);
550     (void)JSON_GetInt64FromOject(json, NETWORK_TYPE_BR, &authSeq[DISCOVERY_TYPE_BR]);
551     JSON_Delete(json);
552     int64_t curAuthSeq[DISCOVERY_TYPE_COUNT] = { 0 };
553     char udid[UDID_BUF_LEN] = { 0 };
554     (void)LnnConvertDlId(networkId, CATEGORY_NETWORK_ID, CATEGORY_UDID, udid, UDID_BUF_LEN);
555     if (AuthGetLatestAuthSeqList(udid, curAuthSeq, DISCOVERY_TYPE_COUNT) != SOFTBUS_OK) {
556         LNN_LOGE(LNN_BUILDER, "get latest authSeq fail");
557         return;
558     }
559     uint32_t type;
560     for (type = DISCOVERY_TYPE_WIFI; type < DISCOVERY_TYPE_P2P; type++) {
561         LNN_LOGI(LNN_BUILDER, "authSeq:%{public}" PRId64 "->%{public}" PRId64, curAuthSeq[type], authSeq[type]);
562         if (authSeq[type] == curAuthSeq[type] && authSeq[type] != 0 && curAuthSeq[type] != 0) {
563             if (type == DISCOVERY_TYPE_WIFI) {
564                 SoftBusSleepMs(WAIT_SEND_NOT_TRUST_MSG);
565             }
566             char *anonyNetworkId = NULL;
567             Anonymize(networkId, &anonyNetworkId);
568             LNN_LOGI(LNN_BUILDER, "networkId=%{public}s, LnnRequestLeaveSpecificType=%{public}d", anonyNetworkId, type);
569             AnonymizeFree(anonyNetworkId);
570             LnnRequestLeaveSpecific(networkId, LnnDiscTypeToConnAddrType((DiscoveryType)type));
571             continue;
572         }
573     }
574 }
575 
DeletePcNodeInfo(const char * peerUdid)576 bool DeletePcNodeInfo(const char *peerUdid)
577 {
578     NodeInfo *localNodeInfo = NULL;
579     NodeInfo remoteNodeInfo;
580     (void)memset_s(&remoteNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
581     if (LnnGetRemoteNodeInfoById(peerUdid, CATEGORY_UDID, &remoteNodeInfo)) {
582         LNN_LOGE(LNN_BUILDER, "get nodeInfo fail");
583         return false;
584     }
585     if (strcmp(remoteNodeInfo.deviceInfo.deviceUdid, remoteNodeInfo.uuid) != 0) {
586         LNN_LOGW(LNN_BUILDER, "isn't pc without softbus");
587         return false;
588     }
589     localNodeInfo = (NodeInfo *)LnnGetLocalNodeInfo();
590     if (localNodeInfo == NULL) {
591         LNN_LOGE(LNN_BUILDER, "get localinfo fail");
592         return false;
593     }
594     if (remoteNodeInfo.accountId == localNodeInfo->accountId) {
595         LNN_LOGI(LNN_BUILDER, "exist sameAccount, don't handle offline");
596         return false;
597     }
598     LNN_LOGI(LNN_BUILDER, "device not trust, delete pc online node");
599     DeleteFromProfile(remoteNodeInfo.deviceInfo.deviceUdid);
600     LnnRemoveNode(remoteNodeInfo.deviceInfo.deviceUdid);
601     return true;
602 }
603 
SelectUseUdid(const char * peerUdid,const char * lowerUdid)604 const char *SelectUseUdid(const char *peerUdid, const char *lowerUdid)
605 {
606     char *anonyPeerUdid = NULL;
607     Anonymize(peerUdid, &anonyPeerUdid);
608     if (LnnGetOnlineStateById(peerUdid, CATEGORY_UDID)) {
609         LNN_LOGD(LNN_BUILDER, "not trusted device online! peerUdid=%{public}s", anonyPeerUdid);
610         AnonymizeFree(anonyPeerUdid);
611         return peerUdid;
612     } else if (LnnGetOnlineStateById(lowerUdid, CATEGORY_UDID)) {
613         char *anonyLowerUdid = NULL;
614         Anonymize(peerUdid, &anonyLowerUdid);
615         LNN_LOGD(LNN_BUILDER, "not trusted device online! peerUdid=%{public}s", anonyLowerUdid);
616         AnonymizeFree(anonyLowerUdid);
617         AnonymizeFree(anonyPeerUdid);
618         return lowerUdid;
619     } else {
620         LNN_LOGW(LNN_BUILDER, "not trusted device not online! peerUdid=%{public}s", anonyPeerUdid);
621         AnonymizeFree(anonyPeerUdid);
622         return NULL;
623     }
624 }
625 
LnnDeleteLinkFinderInfo(const char * peerUdid)626 void LnnDeleteLinkFinderInfo(const char *peerUdid)
627 {
628     char networkId[NETWORK_ID_BUF_LEN] = { 0 };
629     if (LnnGetNetworkIdByUdid(peerUdid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
630         LNN_LOGE(LNN_BUILDER, "get networkId fail.");
631         return;
632     }
633 
634     if (LnnRemoveLinkFinderInfo(networkId) != SOFTBUS_OK) {
635         LNN_LOGE(LNN_BUILDER, "remove a rpa info fail.");
636         return;
637     }
638 }
639 
PostVerifyResult(uint32_t requestId,int32_t retCode,AuthHandle authHandle,const NodeInfo * info)640 void PostVerifyResult(uint32_t requestId, int32_t retCode, AuthHandle authHandle, const NodeInfo *info)
641 {
642     VerifyResultMsgPara *para = NULL;
643     para = (VerifyResultMsgPara *)SoftBusCalloc(sizeof(VerifyResultMsgPara));
644     if (para == NULL) {
645         LNN_LOGE(LNN_BUILDER, "malloc verify result msg para fail");
646         return;
647     }
648     para->requestId = requestId;
649     para->retCode = retCode;
650     if (retCode == SOFTBUS_OK) {
651         para->nodeInfo = (info == NULL) ? NULL : DupNodeInfo(info);
652         para->authHandle = authHandle;
653     }
654     if (PostBuildMessageToHandler(MSG_TYPE_VERIFY_RESULT, para) != SOFTBUS_OK) {
655         LNN_LOGE(LNN_BUILDER, "post verify result message failed");
656         SoftBusFree(para->nodeInfo);
657         SoftBusFree(para);
658     }
659     if (info != NULL && retCode == SOFTBUS_OK) {
660         LnnNotifyDeviceVerified(info->deviceInfo.deviceUdid);
661     }
662 }
663 
OnVerifyPassed(uint32_t requestId,AuthHandle authHandle,const NodeInfo * info)664 static void OnVerifyPassed(uint32_t requestId, AuthHandle authHandle, const NodeInfo *info)
665 {
666     LNN_LOGI(LNN_BUILDER, "verify passed. requestId=%{public}u, authId=%{public}" PRId64, requestId, authHandle.authId);
667     if (authHandle.type < AUTH_LINK_TYPE_WIFI || authHandle.type >= AUTH_LINK_TYPE_MAX) {
668         LNN_LOGE(LNN_BUILDER, "authHandle type error");
669         return;
670     }
671     PostVerifyResult(requestId, SOFTBUS_OK, authHandle, info);
672 }
673 
OnVerifyFailed(uint32_t requestId,int32_t reason)674 static void OnVerifyFailed(uint32_t requestId, int32_t reason)
675 {
676     LNN_LOGI(LNN_BUILDER, "verify failed: requestId=%{public}u, reason=%{public}d", requestId, reason);
677     AuthHandle authHandle = { .authId = AUTH_INVALID_ID };
678     PostVerifyResult(requestId, reason, authHandle, NULL);
679 }
680 
681 static AuthVerifyCallback g_verifyCallback = {
682     .onVerifyPassed = OnVerifyPassed,
683     .onVerifyFailed = OnVerifyFailed,
684 };
685 
LnnGetVerifyCallback(void)686 AuthVerifyCallback *LnnGetVerifyCallback(void)
687 {
688     return &g_verifyCallback;
689 }
690 
CreateConnectionAddrMsgPara(const ConnectionAddr * addr)691 static ConnectionAddr *CreateConnectionAddrMsgPara(const ConnectionAddr *addr)
692 {
693     ConnectionAddr *para = NULL;
694 
695     if (addr == NULL) {
696         LNN_LOGE(LNN_BUILDER, "addr is null");
697         return NULL;
698     }
699     para = (ConnectionAddr *)SoftBusCalloc(sizeof(ConnectionAddr));
700     if (para == NULL) {
701         LNN_LOGE(LNN_BUILDER, "malloc connecton addr message fail");
702         return NULL;
703     }
704     *para = *addr;
705     return para;
706 }
707 
CreateJoinLnnMsgPara(const ConnectionAddr * addr,const LnnDfxDeviceInfoReport * infoReport,const char * pkgName,bool isNeedConnect)708 static JoinLnnMsgPara *CreateJoinLnnMsgPara(const ConnectionAddr *addr, const LnnDfxDeviceInfoReport *infoReport,
709     const char *pkgName, bool isNeedConnect)
710 {
711     JoinLnnMsgPara *para = NULL;
712 
713     if (addr == NULL || infoReport == NULL || pkgName == NULL) {
714         LNN_LOGE(LNN_BUILDER, "create join lnn msg para is null");
715         return NULL;
716     }
717     para = (JoinLnnMsgPara *)SoftBusCalloc(sizeof(JoinLnnMsgPara));
718     if (para == NULL) {
719         LNN_LOGE(LNN_BUILDER, "malloc connecton addr message fail");
720         return NULL;
721     }
722     if (strcpy_s(para->pkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
723         LNN_LOGE(LNN_BUILDER, "copy pkgName fail");
724         SoftBusFree(para);
725         return NULL;
726     }
727     para->isNeedConnect = isNeedConnect;
728     para->addr = *addr;
729     para->infoReport = *infoReport;
730     return para;
731 }
732 
CreateNetworkIdMsgPara(const char * networkId)733 static char *CreateNetworkIdMsgPara(const char *networkId)
734 {
735     char *para = NULL;
736 
737     if (networkId == NULL) {
738         LNN_LOGE(LNN_BUILDER, "networkId is null");
739         return NULL;
740     }
741     para = (char *)SoftBusMalloc(NETWORK_ID_BUF_LEN);
742     if (para == NULL) {
743         LNN_LOGE(LNN_BUILDER, "malloc networkId message fail");
744         return NULL;
745     }
746     if (strncpy_s(para, NETWORK_ID_BUF_LEN, networkId, strlen(networkId)) != EOK) {
747         LNN_LOGE(LNN_BUILDER, "copy network id fail");
748         SoftBusFree(para);
749         return NULL;
750     }
751     return para;
752 }
753 
ConifgLocalLedger(void)754 int32_t ConifgLocalLedger(void)
755 {
756     char uuid[UUID_BUF_LEN] = { 0 };
757     char networkId[NETWORK_ID_BUF_LEN] = { 0 };
758     unsigned char irk[LFINDER_IRK_LEN] = { 0 };
759 
760     // set local networkId and uuid
761     if (LnnGenLocalNetworkId(networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK ||
762         LnnGenLocalUuid(uuid, UUID_BUF_LEN) != SOFTBUS_OK) {
763         LNN_LOGE(LNN_BUILDER, "get local id fail");
764         return SOFTBUS_NOT_FIND;
765     }
766 
767     // irk fail should not cause softbus init fail
768     if (LnnGenLocalIrk(irk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
769         LNN_LOGE(LNN_BUILDER, "get local irk fail");
770     }
771 
772     LnnSetLocalStrInfo(STRING_KEY_UUID, uuid);
773     LnnSetLocalStrInfo(STRING_KEY_NETWORKID, networkId);
774     LnnSetLocalByteInfo(BYTE_KEY_IRK, irk, LFINDER_IRK_LEN);
775     return SOFTBUS_OK;
776 }
777 
OnReceiveMasterElectMsg(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)778 void OnReceiveMasterElectMsg(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
779 {
780     JsonObj *json = NULL;
781     ElectMsgPara *para = NULL;
782 
783     LNN_LOGI(LNN_BUILDER, "recv master elect msg, type=%{public}d, len=%{public}d", type, len);
784     if (g_netBuilder.isInit == false) {
785         LNN_LOGE(LNN_BUILDER, "no init");
786         return;
787     }
788     if (type != LNN_INFO_TYPE_MASTER_ELECT) {
789         return;
790     }
791     json = JSON_Parse((char *)msg, len);
792     if (json == NULL) {
793         LNN_LOGE(LNN_BUILDER, "parse elect msg json fail");
794         return;
795     }
796     para = (ElectMsgPara *)SoftBusMalloc(sizeof(ElectMsgPara));
797     if (para == NULL) {
798         LNN_LOGE(LNN_BUILDER, "malloc elect msg para fail");
799         JSON_Delete(json);
800         return;
801     }
802     if (!JSON_GetInt32FromOject(json, JSON_KEY_MASTER_WEIGHT, &para->masterWeight) ||
803         !JSON_GetStringFromOject(json, JSON_KEY_MASTER_UDID, para->masterUdid, UDID_BUF_LEN)) {
804         LNN_LOGE(LNN_BUILDER, "parse master info json fail");
805         JSON_Delete(json);
806         SoftBusFree(para);
807         return;
808     }
809     JSON_Delete(json);
810     if (strcpy_s(para->networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
811         LNN_LOGE(LNN_BUILDER, "copy network id fail");
812         SoftBusFree(para);
813         return;
814     }
815     if (PostBuildMessageToHandler(MSG_TYPE_MASTER_ELECT, para) != SOFTBUS_OK) {
816         LNN_LOGE(LNN_BUILDER, "post elect message fail");
817         SoftBusFree(para);
818     }
819 }
820 
LnnUnpackNodeAddr(const uint8_t * data,uint32_t dataLen,LnnNodeAddr * addr)821 static int32_t LnnUnpackNodeAddr(const uint8_t *data, uint32_t dataLen, LnnNodeAddr *addr)
822 {
823     cJSON *json = cJSON_Parse((char *)data);
824     if (json == NULL) {
825         LNN_LOGE(LNN_BUILDER, "json parse failed");
826         return SOFTBUS_PARSE_JSON_ERR;
827     }
828     if (!GetJsonObjectNumberItem(json, JSON_KEY_NODE_CODE, &addr->code) ||
829         !GetJsonObjectStringItem(json, JSON_KEY_NODE_ADDR, addr->nodeAddr, SHORT_ADDRESS_MAX_LEN) ||
830         !GetJsonObjectNumberItem(json, JSON_KEY_NODE_PROXY_PORT, &addr->proxyPort) ||
831         !GetJsonObjectNumberItem(json, JSON_KEY_NODE_SESSION_PORT, &addr->sessionPort)) {
832         LNN_LOGE(LNN_BUILDER, "parse addr info failed");
833         cJSON_Delete(json);
834         return SOFTBUS_PARSE_JSON_ERR;
835     }
836 
837     cJSON_Delete(json);
838     return SOFTBUS_OK;
839 }
840 
OnReceiveNodeAddrChangedMsg(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t size)841 void OnReceiveNodeAddrChangedMsg(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t size)
842 {
843     if (type != LNN_INFO_TYPE_NODE_ADDR) {
844         return;
845     }
846     uint32_t addrLen = (uint32_t)strnlen((const char *)msg, size);
847     if (size == 0 || addrLen != size - 1 || addrLen == 0) {
848         return;
849     }
850     char *anonyNetworkId = NULL;
851     Anonymize(networkId, &anonyNetworkId);
852     LNN_LOGI(LNN_BUILDER, "networkId=%{public}s", anonyNetworkId);
853     AnonymizeFree(anonyNetworkId);
854 
855     LnnNodeAddr addr;
856     (void)memset_s(&addr, sizeof(LnnNodeAddr), 0, sizeof(LnnNodeAddr));
857     if (LnnUnpackNodeAddr(msg, size, &addr) != SOFTBUS_OK) {
858         return;
859     }
860 
861     SfcSyncNodeAddrHandle(networkId, addr.code);
862 
863     if (LnnSetDLNodeAddr(networkId, CATEGORY_NETWORK_ID, addr.nodeAddr) != SOFTBUS_OK) {
864         return;
865     }
866 
867     if (addr.proxyPort > 0) {
868         (void)LnnSetDLProxyPort(networkId, CATEGORY_NETWORK_ID, addr.proxyPort);
869     }
870 
871     if (addr.sessionPort > 0) {
872         (void)LnnSetDLSessionPort(networkId, CATEGORY_NETWORK_ID, addr.sessionPort);
873     }
874 
875     if (addr.authPort > 0) {
876         (void)LnnSetDLAuthPort(networkId, CATEGORY_NETWORK_ID, addr.authPort);
877     }
878 
879     LnnNotifyNodeAddressChanged(addr.nodeAddr, networkId, false);
880 }
881 
LnnUpdateNodeAddr(const char * addr)882 int32_t LnnUpdateNodeAddr(const char *addr)
883 {
884     if (addr == NULL) {
885         return SOFTBUS_INVALID_PARAM;
886     }
887 
888     int32_t ret = LnnSetLocalStrInfo(STRING_KEY_NODE_ADDR, addr);
889     if (ret != SOFTBUS_OK) {
890         LNN_LOGE(LNN_BUILDER, "set local node addr failed");
891         return ret;
892     }
893 
894     char localNetworkId[NETWORK_ID_BUF_LEN] = { 0 };
895     ret = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, sizeof(localNetworkId));
896     if (ret != SOFTBUS_OK) {
897         LNN_LOGE(LNN_BUILDER, "get local network id failed");
898         return SOFTBUS_NETWORK_NOT_FOUND;
899     }
900     LnnNotifyNodeAddressChanged(addr, localNetworkId, true);
901 
902     return SOFTBUS_OK;
903 }
904 
UpdateLocalNetCapability(void)905 void UpdateLocalNetCapability(void)
906 {
907     uint32_t oldNetCap = 0;
908     if (LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &oldNetCap) != SOFTBUS_OK) {
909         LNN_LOGE(LNN_INIT, "get cap from local ledger fail");
910         return;
911     }
912     uint32_t netCapability = oldNetCap;
913     int btState = SoftBusGetBtState();
914     if (btState == BLE_ENABLE) {
915         LNN_LOGI(LNN_INIT, "ble state is on");
916         (void)LnnSetNetCapability(&netCapability, BIT_BLE);
917     } else if (btState == BLE_DISABLE) {
918         LNN_LOGI(LNN_INIT, "ble state is off");
919         (void)LnnClearNetCapability(&netCapability, BIT_BLE);
920     }
921 
922     int brState = SoftBusGetBrState();
923     if (brState == BR_ENABLE) {
924         (void)LnnSetNetCapability(&netCapability, BIT_BR);
925     } else if (brState == BR_DISABLE) {
926         (void)LnnClearNetCapability(&netCapability, BIT_BR);
927     }
928 
929     bool isWifiActive = SoftBusIsWifiActive();
930     if (!isWifiActive) {
931         (void)LnnClearNetCapability(&netCapability, BIT_WIFI);
932         (void)LnnClearNetCapability(&netCapability, BIT_WIFI_24G);
933         (void)LnnClearNetCapability(&netCapability, BIT_WIFI_5G);
934     } else {
935         SoftBusBand band = SoftBusGetLinkBand();
936         if (band == BAND_24G) {
937             (void)LnnSetNetCapability(&netCapability, BIT_WIFI_24G);
938             (void)LnnClearNetCapability(&netCapability, BIT_WIFI_5G);
939         } else if (band == BAND_5G) {
940             (void)LnnSetNetCapability(&netCapability, BIT_WIFI_5G);
941             (void)LnnClearNetCapability(&netCapability, BIT_WIFI_24G);
942         } else {
943             (void)LnnSetNetCapability(&netCapability, BIT_WIFI_5G);
944             (void)LnnSetNetCapability(&netCapability, BIT_WIFI_24G);
945         }
946     }
947     SoftBusWifiDetailState wifiState = SoftBusGetWifiState();
948     if (wifiState == SOFTBUS_WIFI_STATE_INACTIVE || wifiState == SOFTBUS_WIFI_STATE_DEACTIVATING) {
949         (void)LnnClearNetCapability(&netCapability, BIT_WIFI_P2P);
950     }
951 
952     if (LnnSetLocalNumInfo(NUM_KEY_NET_CAP, netCapability) != SOFTBUS_OK) {
953         LNN_LOGE(LNN_INIT, "set cap to local ledger fail");
954     }
955     LNN_LOGI(LNN_INIT, "local capability change:%{public}u->%{public}u, brState=%{public}d, isWifiActive=%{public}d,",
956         oldNetCap, netCapability, brState, isWifiActive);
957 }
958 
JoinLnnWithNodeInfo(ConnectionAddr * addr,NodeInfo * info)959 int32_t JoinLnnWithNodeInfo(ConnectionAddr *addr, NodeInfo *info)
960 {
961     if (addr == NULL || info == NULL) {
962         LNN_LOGE(LNN_BUILDER, "prepare join with nodeinfo message fail");
963         return SOFTBUS_INVALID_PARAM;
964     }
965     LnnDfxDeviceInfoReport infoReport;
966     (void)memset_s(&infoReport, sizeof(LnnDfxDeviceInfoReport), 0, sizeof(LnnDfxDeviceInfoReport));
967     JoinLnnMsgPara *para = CreateJoinLnnMsgPara(addr, &infoReport, DEFAULT_PKG_NAME, false);
968     if (para == NULL) {
969         LNN_LOGE(LNN_BUILDER, "prepare join with nodeinfo create lnn msg para fail");
970         return SOFTBUS_MALLOC_ERR;
971     }
972     para->dupInfo = DupNodeInfo(info);
973     if (para->dupInfo == NULL) {
974         LNN_LOGE(LNN_BUILDER, "join with nodeinfo dup node info fail");
975         SoftBusFree(para);
976         return SOFTBUS_MALLOC_ERR;
977     }
978     if (PostBuildMessageToHandler(MSG_TYPE_DISCOVERY_DEVICE, para) != SOFTBUS_OK) {
979         LNN_LOGE(LNN_BUILDER, "post notify discovery device message failed");
980         SoftBusFree(para->dupInfo);
981         SoftBusFree(para);
982         return SOFTBUS_ERR;
983     }
984     return SOFTBUS_OK;
985 }
986 
LnnServerJoin(ConnectionAddr * addr,const char * pkgName)987 int32_t LnnServerJoin(ConnectionAddr *addr, const char *pkgName)
988 {
989     JoinLnnMsgPara *para = NULL;
990 
991     LNN_LOGI(LNN_BUILDER, "enter!");
992     if (g_netBuilder.isInit == false) {
993         LNN_LOGE(LNN_BUILDER, "no init");
994         return SOFTBUS_NO_INIT;
995     }
996     LnnDfxDeviceInfoReport infoReport;
997     (void)memset_s(&infoReport, sizeof(LnnDfxDeviceInfoReport), 0, sizeof(LnnDfxDeviceInfoReport));
998     para = CreateJoinLnnMsgPara(addr, &infoReport, pkgName, true);
999     if (para == NULL) {
1000         LNN_LOGE(LNN_BUILDER, "prepare join lnn message fail");
1001         return SOFTBUS_MALLOC_ERR;
1002     }
1003     if (PostBuildMessageToHandler(MSG_TYPE_JOIN_LNN, para) != SOFTBUS_OK) {
1004         LNN_LOGE(LNN_BUILDER, "post join lnn message fail");
1005         SoftBusFree(para);
1006         return SOFTBUS_NETWORK_LOOPER_ERR;
1007     }
1008     return SOFTBUS_OK;
1009 }
1010 
LnnServerLeave(const char * networkId,const char * pkgName)1011 int32_t LnnServerLeave(const char *networkId, const char *pkgName)
1012 {
1013     (void)pkgName;
1014     char *para = NULL;
1015 
1016     LNN_LOGI(LNN_BUILDER, "enter");
1017     if (g_netBuilder.isInit == false) {
1018         LNN_LOGE(LNN_BUILDER, "no init");
1019         return SOFTBUS_NO_INIT;
1020     }
1021     para = CreateNetworkIdMsgPara(networkId);
1022     if (para == NULL) {
1023         LNN_LOGE(LNN_BUILDER, "prepare leave lnn message fail");
1024         return SOFTBUS_MALLOC_ERR;
1025     }
1026     if (PostBuildMessageToHandler(MSG_TYPE_LEAVE_LNN, para) != SOFTBUS_OK) {
1027         LNN_LOGE(LNN_BUILDER, "post leave lnn message fail");
1028         SoftBusFree(para);
1029         return SOFTBUS_NETWORK_LOOPER_ERR;
1030     }
1031     return SOFTBUS_OK;
1032 }
1033 
LnnNotifyDiscoveryDevice(const ConnectionAddr * addr,const LnnDfxDeviceInfoReport * infoReport,bool isNeedConnect)1034 int32_t LnnNotifyDiscoveryDevice(
1035     const ConnectionAddr *addr, const LnnDfxDeviceInfoReport *infoReport, bool isNeedConnect)
1036 {
1037     JoinLnnMsgPara *para = NULL;
1038     if (LnnIsConnectionAddrInvalid(addr)) {
1039         LNN_LOGE(LNN_BUILDER, "invalid connection addr");
1040         return SOFTBUS_INVALID_PARAM;
1041     }
1042     LNN_LOGI(LNN_BUILDER, "notify discovery device enter! peer%{public}s, isNeedConnect=%{public}d",
1043         addr != NULL ? LnnPrintConnectionAddr(addr) : "", isNeedConnect);
1044     if (g_netBuilder.isInit == false) {
1045         LNN_LOGE(LNN_BUILDER, "no init");
1046         return SOFTBUS_NO_INIT;
1047     }
1048     if (infoReport == NULL) {
1049         LNN_LOGE(LNN_BUILDER, "infoReport is null");
1050         return SOFTBUS_INVALID_PARAM;
1051     }
1052     para = CreateJoinLnnMsgPara(addr, infoReport, DEFAULT_PKG_NAME, isNeedConnect);
1053     if (para == NULL) {
1054         LNN_LOGE(LNN_BUILDER, "malloc discovery device message fail");
1055         return SOFTBUS_MALLOC_ERR;
1056     }
1057     if (PostBuildMessageToHandler(MSG_TYPE_DISCOVERY_DEVICE, para) != SOFTBUS_OK) {
1058         LNN_LOGE(LNN_BUILDER, "post notify discovery device message failed");
1059         SoftBusFree(para);
1060         return SOFTBUS_ERR;
1061     }
1062     return SOFTBUS_OK;
1063 }
1064 
LnnRequestLeaveInvalidConn(const char * oldNetworkId,ConnectionAddrType addrType,const char * newNetworkId)1065 int32_t LnnRequestLeaveInvalidConn(const char *oldNetworkId, ConnectionAddrType addrType, const char *newNetworkId)
1066 {
1067     LeaveInvalidConnMsgPara *para = NULL;
1068 
1069     if (g_netBuilder.isInit == false) {
1070         LNN_LOGE(LNN_BUILDER, "no init");
1071         return SOFTBUS_NO_INIT;
1072     }
1073     para = (LeaveInvalidConnMsgPara *)SoftBusMalloc(sizeof(LeaveInvalidConnMsgPara));
1074     if (para == NULL) {
1075         LNN_LOGE(LNN_BUILDER, "prepare leave invalid connection message fail");
1076         return SOFTBUS_MALLOC_ERR;
1077     }
1078     if (strncpy_s(para->oldNetworkId, NETWORK_ID_BUF_LEN, oldNetworkId, strlen(oldNetworkId)) != EOK ||
1079         strncpy_s(para->newNetworkId, NETWORK_ID_BUF_LEN, newNetworkId, strlen(newNetworkId)) != EOK) {
1080         LNN_LOGE(LNN_BUILDER, "copy old networkId or new networkId fail");
1081         SoftBusFree(para);
1082         return SOFTBUS_MALLOC_ERR;
1083     }
1084     para->addrType = addrType;
1085     if (PostBuildMessageToHandler(MSG_TYPE_LEAVE_INVALID_CONN, para) != SOFTBUS_OK) {
1086         LNN_LOGE(LNN_BUILDER, "post leave invalid connection message failed");
1087         SoftBusFree(para);
1088         return SOFTBUS_ERR;
1089     }
1090     return SOFTBUS_OK;
1091 }
1092 
LnnRequestCleanConnFsm(uint16_t connFsmId)1093 int32_t LnnRequestCleanConnFsm(uint16_t connFsmId)
1094 {
1095     uint16_t *para = NULL;
1096 
1097     if (g_netBuilder.isInit == false) {
1098         LNN_LOGE(LNN_BUILDER, "no init");
1099         return SOFTBUS_ERR;
1100     }
1101     para = (uint16_t *)SoftBusMalloc(sizeof(uint16_t));
1102     if (para == NULL) {
1103         LNN_LOGE(LNN_BUILDER, "malloc clean connection fsm msg failed");
1104         return SOFTBUS_MALLOC_ERR;
1105     }
1106     *para = connFsmId;
1107     if (PostBuildMessageToHandler(MSG_TYPE_CLEAN_CONN_FSM, para) != SOFTBUS_OK) {
1108         LNN_LOGE(LNN_BUILDER, "post request clean connectionlnn message failed");
1109         SoftBusFree(para);
1110         return SOFTBUS_ERR;
1111     }
1112     return SOFTBUS_OK;
1113 }
1114 
LnnSyncOfflineComplete(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)1115 void LnnSyncOfflineComplete(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
1116 {
1117     char *para = NULL;
1118 
1119     (void)type;
1120     (void)msg;
1121     (void)len;
1122     if (g_netBuilder.isInit == false) {
1123         LNN_LOGE(LNN_BUILDER, "no init");
1124         return;
1125     }
1126     para = CreateNetworkIdMsgPara(networkId);
1127     if (para == NULL) {
1128         LNN_LOGE(LNN_BUILDER, "prepare notify sync offline message fail");
1129         return;
1130     }
1131     if (PostBuildMessageToHandler(MSG_TYPE_SYNC_OFFLINE_FINISH, para) != SOFTBUS_OK) {
1132         LNN_LOGE(LNN_BUILDER, "post sync offline finish message failed");
1133         SoftBusFree(para);
1134     }
1135 }
1136 
LnnNotifyNodeStateChanged(const ConnectionAddr * addr)1137 int32_t LnnNotifyNodeStateChanged(const ConnectionAddr *addr)
1138 {
1139     ConnectionAddr *para = NULL;
1140 
1141     if (g_netBuilder.isInit == false) {
1142         LNN_LOGE(LNN_BUILDER, "no init");
1143         return SOFTBUS_NO_INIT;
1144     }
1145     para = CreateConnectionAddrMsgPara(addr);
1146     if (para == NULL) {
1147         LNN_LOGE(LNN_BUILDER, "create node state changed msg failed");
1148         return SOFTBUS_MALLOC_ERR;
1149     }
1150     if (PostBuildMessageToHandler(MSG_TYPE_NODE_STATE_CHANGED, para) != SOFTBUS_OK) {
1151         LNN_LOGE(LNN_BUILDER, "post node state changed message failed");
1152         SoftBusFree(para);
1153         return SOFTBUS_ERR;
1154     }
1155     return SOFTBUS_OK;
1156 }
1157 
LnnNotifyMasterElect(const char * networkId,const char * masterUdid,int32_t masterWeight)1158 int32_t LnnNotifyMasterElect(const char *networkId, const char *masterUdid, int32_t masterWeight)
1159 {
1160     ElectMsgPara *para = NULL;
1161 
1162     if (g_netBuilder.isInit == false) {
1163         LNN_LOGE(LNN_BUILDER, "no init");
1164         return SOFTBUS_NO_INIT;
1165     }
1166     if (networkId == NULL || masterUdid == NULL) {
1167         LNN_LOGE(LNN_BUILDER, "invalid elect msg para");
1168         return SOFTBUS_INVALID_PARAM;
1169     }
1170     para = (ElectMsgPara *)SoftBusMalloc(sizeof(ElectMsgPara));
1171     if (para == NULL) {
1172         LNN_LOGE(LNN_BUILDER, "malloc elect msg para failed");
1173         return SOFTBUS_MEM_ERR;
1174     }
1175     if (strncpy_s(para->networkId, NETWORK_ID_BUF_LEN, networkId, strlen(networkId)) != EOK ||
1176         strncpy_s(para->masterUdid, UDID_BUF_LEN, masterUdid, strlen(masterUdid)) != EOK) {
1177         LNN_LOGE(LNN_BUILDER, "copy udid and maser udid failed");
1178         SoftBusFree(para);
1179         return SOFTBUS_ERR;
1180     }
1181     para->masterWeight = masterWeight;
1182     if (PostBuildMessageToHandler(MSG_TYPE_MASTER_ELECT, para) != SOFTBUS_OK) {
1183         LNN_LOGE(LNN_BUILDER, "post elect message failed");
1184         SoftBusFree(para);
1185         return SOFTBUS_ERR;
1186     }
1187     return SOFTBUS_OK;
1188 }
1189 
1190 /* Note: must called in connection fsm. */
LnnNotifyAuthHandleLeaveLNN(AuthHandle authHandle)1191 int32_t LnnNotifyAuthHandleLeaveLNN(AuthHandle authHandle)
1192 {
1193     LnnConnectionFsm *item = NULL;
1194 
1195     if (g_netBuilder.isInit == false) {
1196         LNN_LOGE(LNN_BUILDER, "no init");
1197         return SOFTBUS_NO_INIT;
1198     }
1199 
1200     LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
1201         if (item->isDead) {
1202             continue;
1203         }
1204         if (item->connInfo.authHandle.authId == authHandle.authId &&
1205             item->connInfo.authHandle.type == authHandle.type) {
1206             LNN_LOGI(
1207                 LNN_BUILDER, "fsmId=%{public}u connection fsm already use type=%{public}d authId=%{public}" PRId64,
1208                 item->id, authHandle.type, authHandle.authId);
1209             return SOFTBUS_OK;
1210         }
1211     }
1212     AuthHandleLeaveLNN(authHandle);
1213     return SOFTBUS_OK;
1214 }
1215 
LnnRequestLeaveByAddrType(const bool * type,uint32_t typeLen)1216 int32_t LnnRequestLeaveByAddrType(const bool *type, uint32_t typeLen)
1217 {
1218     if (type == NULL) {
1219         LNN_LOGE(LNN_BUILDER, "para is null");
1220         return SOFTBUS_INVALID_PARAM;
1221     }
1222     bool *para = NULL;
1223     if (typeLen != CONNECTION_ADDR_MAX) {
1224         LNN_LOGE(LNN_BUILDER, "invalid typeLen");
1225         return SOFTBUS_ERR;
1226     }
1227     LNN_LOGD(LNN_BUILDER, "wlan=%{public}d, br=%{public}d, ble=%{public}d, eth=%{public}d", type[CONNECTION_ADDR_WLAN],
1228         type[CONNECTION_ADDR_BR], type[CONNECTION_ADDR_BLE], type[CONNECTION_ADDR_ETH]);
1229     if (g_netBuilder.isInit == false) {
1230         LNN_LOGE(LNN_BUILDER, "no init");
1231         return SOFTBUS_NO_INIT;
1232     }
1233     para = (bool *)SoftBusMalloc(sizeof(bool) * typeLen);
1234     if (para == NULL) {
1235         LNN_LOGE(LNN_BUILDER, "malloc leave by addr type msg para failed");
1236         return SOFTBUS_MALLOC_ERR;
1237     }
1238     if (memcpy_s(para, sizeof(bool) * typeLen, type, sizeof(bool) * typeLen) != EOK) {
1239         LNN_LOGE(LNN_BUILDER, "memcopy para fail");
1240         SoftBusFree(para);
1241         return SOFTBUS_MEM_ERR;
1242     }
1243     if (PostBuildMessageToHandler(MSG_TYPE_LEAVE_BY_ADDR_TYPE, para) != SOFTBUS_OK) {
1244         LNN_LOGE(LNN_BUILDER, "post leave by addr type message failed");
1245         SoftBusFree(para);
1246         return SOFTBUS_ERR;
1247     }
1248     return SOFTBUS_OK;
1249 }
1250 
LnnRequestLeaveSpecific(const char * networkId,ConnectionAddrType addrType)1251 int32_t LnnRequestLeaveSpecific(const char *networkId, ConnectionAddrType addrType)
1252 {
1253     SpecificLeaveMsgPara *para = NULL;
1254 
1255     if (networkId == NULL) {
1256         return SOFTBUS_INVALID_PARAM;
1257     }
1258     if (g_netBuilder.isInit == false) {
1259         LNN_LOGE(LNN_BUILDER, "no init");
1260         return SOFTBUS_NO_INIT;
1261     }
1262     para = (SpecificLeaveMsgPara *)SoftBusCalloc(sizeof(SpecificLeaveMsgPara));
1263     if (para == NULL) {
1264         LNN_LOGE(LNN_BUILDER, "malloc specific msg fail");
1265         return SOFTBUS_MALLOC_ERR;
1266     }
1267     if (strcpy_s(para->networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
1268         LNN_LOGE(LNN_BUILDER, "copy networkId fail");
1269         SoftBusFree(para);
1270         return SOFTBUS_STRCPY_ERR;
1271     }
1272     para->addrType = addrType;
1273     if (PostBuildMessageToHandler(MSG_TYPE_LEAVE_SPECIFIC, para) != SOFTBUS_OK) {
1274         LNN_LOGE(LNN_BUILDER, "post leave specific msg failed");
1275         SoftBusFree(para);
1276         return SOFTBUS_ERR;
1277     }
1278     return SOFTBUS_OK;
1279 }
1280 
LnnNotifyLeaveLnnByAuthHandle(AuthHandle * authHandle)1281 int32_t LnnNotifyLeaveLnnByAuthHandle(AuthHandle *authHandle)
1282 {
1283     AuthHandle *para = NULL;
1284     para = (AuthHandle *)SoftBusMalloc(sizeof(AuthHandle));
1285     if (para == NULL) {
1286         LNN_LOGE(LNN_BUILDER, "malloc para fail");
1287         return SOFTBUS_MALLOC_ERR;
1288     }
1289     *para = *authHandle;
1290     if (PostBuildMessageToHandler(MSG_TYPE_DEVICE_DISCONNECT, para) != SOFTBUS_OK) {
1291         LNN_LOGE(LNN_BUILDER, "post device disconnect fail");
1292         SoftBusFree(para);
1293         return SOFTBUS_ERR;
1294     }
1295     return SOFTBUS_OK;
1296 }
1297 
LnnNotifyEmptySessionKey(int64_t authId)1298 int32_t LnnNotifyEmptySessionKey(int64_t authId)
1299 {
1300     int64_t *para = NULL;
1301     para = (int64_t *)SoftBusMalloc(sizeof(int64_t));
1302     if (para == NULL) {
1303         LNN_LOGE(LNN_BUILDER, "malloc para fail");
1304         return SOFTBUS_MALLOC_ERR;
1305     }
1306     *para = authId;
1307     if (PostBuildMessageToHandler(MSG_TYPE_LEAVE_BY_AUTH_ID, para) != SOFTBUS_OK) {
1308         LNN_LOGE(LNN_BUILDER, "post empty sessionKey msg fail");
1309         SoftBusFree(para);
1310         return SOFTBUS_ERR;
1311     }
1312     return SOFTBUS_OK;
1313 }
1314 
LnnRequestLeaveAllOnlineNodes(void)1315 void LnnRequestLeaveAllOnlineNodes(void)
1316 {
1317     int32_t onlineNum;
1318     NodeBasicInfo *info;
1319     char *para = NULL;
1320     if (LnnGetAllOnlineNodeInfo(&info, &onlineNum) != 0) {
1321         LNN_LOGE(LNN_BUILDER, "LnnGetAllOnlineNodeInfo failed");
1322         return;
1323     }
1324     if (info == NULL || onlineNum == 0) {
1325         LNN_LOGW(LNN_BUILDER, "none online node");
1326         return;
1327     }
1328     for (int32_t i = 0; i < onlineNum; i++) {
1329         para = CreateNetworkIdMsgPara(info[i].networkId);
1330         if (para == NULL) {
1331             LNN_LOGE(LNN_BUILDER, "prepare leave lnn message fail");
1332             break;
1333         }
1334         if (PostBuildMessageToHandler(MSG_TYPE_LEAVE_LNN, para) != SOFTBUS_OK) {
1335             LNN_LOGE(LNN_BUILDER, "post leave lnn message failed");
1336             SoftBusFree(para);
1337             break;
1338         }
1339     }
1340     SoftBusFree(info);
1341 }
1342 
LnnBleReportExtraMapInit(void)1343 static bool LnnBleReportExtraMapInit(void)
1344 {
1345     if (SoftBusMutexInit(&g_lnnDfxReportMutex, NULL) != SOFTBUS_OK) {
1346         LNN_LOGE(LNN_BUILDER, "lnnDfxReport mutex init fail");
1347         return false;
1348     }
1349     LnnMapInit(&g_lnnDfxReportMap);
1350     g_lnnDfxReportIsInit = true;
1351     LNN_LOGI(LNN_BUILDER, "lnnDfxReport map init success");
1352     return true;
1353 }
1354 
AddNodeToLnnBleReportExtraMap(const char * udidHash,const LnnBleReportExtra * bleExtra)1355 void AddNodeToLnnBleReportExtraMap(const char *udidHash, const LnnBleReportExtra *bleExtra)
1356 {
1357     if (!g_lnnDfxReportIsInit || udidHash == NULL || bleExtra == NULL) {
1358         LNN_LOGE(LNN_BUILDER, "invalid param");
1359         return;
1360     }
1361     if (SoftBusMutexLock(&g_lnnDfxReportMutex) != SOFTBUS_OK) {
1362         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1363         return;
1364     }
1365     if (LnnMapSet(&g_lnnDfxReportMap, udidHash, bleExtra, sizeof(LnnBleReportExtra)) != SOFTBUS_OK) {
1366         LNN_LOGE(LNN_BUILDER, "LnnMapSet fail");
1367         (void)SoftBusMutexUnlock(&g_lnnDfxReportMutex);
1368         return;
1369     }
1370     (void)SoftBusMutexUnlock(&g_lnnDfxReportMutex);
1371 }
1372 
GetNodeFromLnnBleReportExtraMap(const char * udidHash,LnnBleReportExtra * bleExtra)1373 int32_t GetNodeFromLnnBleReportExtraMap(const char *udidHash, LnnBleReportExtra *bleExtra)
1374 {
1375     if (!g_lnnDfxReportIsInit || udidHash == NULL || bleExtra == NULL) {
1376         return SOFTBUS_INVALID_PARAM;
1377     }
1378     if (SoftBusMutexLock(&g_lnnDfxReportMutex) != SOFTBUS_OK) {
1379         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1380         return SOFTBUS_LOCK_ERR;
1381     }
1382     LnnBleReportExtra *extra = NULL;
1383     extra = (LnnBleReportExtra *)LnnMapGet(&g_lnnDfxReportMap, udidHash);
1384     if (extra == NULL) {
1385         LNN_LOGE(LNN_BUILDER, "LnnMapGet fail");
1386         (void)SoftBusMutexUnlock(&g_lnnDfxReportMutex);
1387         return SOFTBUS_NOT_FIND;
1388     }
1389     if (memcpy_s(bleExtra, sizeof(LnnBleReportExtra), extra, sizeof(LnnBleReportExtra)) != EOK) {
1390         LNN_LOGE(LNN_BUILDER, "memcpy_s extra fail");
1391         (void)SoftBusMutexUnlock(&g_lnnDfxReportMutex);
1392         return SOFTBUS_MEM_ERR;
1393     }
1394     (void)SoftBusMutexUnlock(&g_lnnDfxReportMutex);
1395     return SOFTBUS_OK;
1396 }
1397 
IsExistLnnDfxNodeByUdidHash(const char * udidHash,LnnBleReportExtra * bleExtra)1398 bool IsExistLnnDfxNodeByUdidHash(const char *udidHash, LnnBleReportExtra *bleExtra)
1399 {
1400     if (udidHash == NULL || bleExtra == NULL) {
1401         LNN_LOGE(LNN_BUILDER, "invalid param");
1402         return false;
1403     }
1404     if (!g_lnnDfxReportIsInit && !LnnBleReportExtraMapInit()) {
1405         LNN_LOGE(LNN_BUILDER, "LnnBleReportExtraMap is not init");
1406         return false;
1407     }
1408     if (GetNodeFromLnnBleReportExtraMap(udidHash, bleExtra) != SOFTBUS_OK) {
1409         return false;
1410     }
1411     char *anonyUdidHash = NULL;
1412     Anonymize(udidHash, &anonyUdidHash);
1413     LNN_LOGI(LNN_BUILDER, "device report node is exist, udidHash=%{public}s", anonyUdidHash);
1414     AnonymizeFree(anonyUdidHash);
1415     return true;
1416 }
1417 
DeleteNodeFromLnnBleReportExtraMap(const char * udidHash)1418 void DeleteNodeFromLnnBleReportExtraMap(const char *udidHash)
1419 {
1420     if (!g_lnnDfxReportIsInit || udidHash == NULL) {
1421         LNN_LOGE(LNN_BUILDER, "invalid param");
1422         return;
1423     }
1424     if (SoftBusMutexLock(&g_lnnDfxReportMutex) != SOFTBUS_OK) {
1425         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1426         return;
1427     }
1428     int32_t ret = LnnMapErase(&g_lnnDfxReportMap, udidHash);
1429     if (ret != SOFTBUS_OK) {
1430         LNN_LOGE(LNN_BUILDER, "delete item fail, ret=%{public}d", ret);
1431         (void)SoftBusMutexUnlock(&g_lnnDfxReportMutex);
1432         return;
1433     }
1434     (void)SoftBusMutexUnlock(&g_lnnDfxReportMutex);
1435 }
1436 
ClearLnnBleReportExtraMap(void)1437 void ClearLnnBleReportExtraMap(void)
1438 {
1439     if (!g_lnnDfxReportIsInit) {
1440         return;
1441     }
1442     if (SoftBusMutexLock(&g_lnnDfxReportMutex) != SOFTBUS_OK) {
1443         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1444         return;
1445     }
1446     LnnMapDelete(&g_lnnDfxReportMap);
1447     LNN_LOGI(LNN_BUILDER, "ClearLnnBleReportExtraMap succ");
1448     (void)SoftBusMutexUnlock(&g_lnnDfxReportMutex);
1449 }
1450 
LnnBlePcRestrictMapInit(void)1451 void LnnBlePcRestrictMapInit(void)
1452 {
1453     if (g_lnnDfxPcIsInit) {
1454         return;
1455     }
1456     if (SoftBusMutexInit(&g_lnnDfxPcMutex, NULL) != SOFTBUS_OK) {
1457         LNN_LOGE(LNN_BUILDER, "mutex init fail");
1458         return;
1459     }
1460     LnnMapInit(&g_lnnDfxPcMap);
1461     g_lnnDfxPcIsInit = true;
1462     LNN_LOGI(LNN_BUILDER, "map init succ");
1463     return;
1464 }
1465 
AddNodeToPcRestrictMap(const char * udidHash)1466 void AddNodeToPcRestrictMap(const char *udidHash)
1467 {
1468     if (!g_lnnDfxPcIsInit || udidHash == NULL) {
1469         LNN_LOGE(LNN_BUILDER, "invalid param");
1470         return;
1471     }
1472     if (SoftBusMutexLock(&g_lnnDfxPcMutex) != SOFTBUS_OK) {
1473         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1474         return;
1475     }
1476     uint32_t count = 1;
1477     if (LnnMapSet(&g_lnnDfxPcMap, udidHash, &count, sizeof(uint32_t)) != SOFTBUS_OK) {
1478         LNN_LOGE(LNN_BUILDER, "LnnMapSet fail");
1479         (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1480         return;
1481     }
1482     (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1483     char *anonyUdid = NULL;
1484     Anonymize(udidHash, &anonyUdid);
1485     LNN_LOGI(LNN_BUILDER, "add %{public}s to map succ", anonyUdid);
1486     AnonymizeFree(anonyUdid);
1487 }
1488 
ClearPcRestrictMap(void)1489 void ClearPcRestrictMap(void)
1490 {
1491     if (!g_lnnDfxPcIsInit) {
1492         return;
1493     }
1494     if (SoftBusMutexLock(&g_lnnDfxPcMutex) != SOFTBUS_OK) {
1495         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1496         return;
1497     }
1498     LnnMapDelete(&g_lnnDfxPcMap);
1499     LNN_LOGI(LNN_BUILDER, "Clear Map succ");
1500     (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1501 }
1502 
DeleteNodeFromPcRestrictMap(const char * udidHash)1503 void DeleteNodeFromPcRestrictMap(const char *udidHash)
1504 {
1505     if (!g_lnnDfxPcIsInit || udidHash == NULL) {
1506         LNN_LOGE(LNN_BUILDER, "invalid param");
1507         return;
1508     }
1509     if (SoftBusMutexLock(&g_lnnDfxPcMutex) != SOFTBUS_OK) {
1510         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1511         return;
1512     }
1513     int32_t ret = LnnMapErase(&g_lnnDfxPcMap, udidHash);
1514     if (ret != SOFTBUS_OK) {
1515         LNN_LOGE(LNN_BUILDER, "delete item fail, ret=%{public}d", ret);
1516         (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1517         return;
1518     }
1519     (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1520     char *anonyUdid = NULL;
1521     Anonymize(udidHash, &anonyUdid);
1522     LNN_LOGI(LNN_BUILDER, "delete %{public}s from map succ", anonyUdid);
1523     AnonymizeFree(anonyUdid);
1524 }
1525 
GetNodeFromPcRestrictMap(const char * udidHash,uint32_t * count)1526 int32_t GetNodeFromPcRestrictMap(const char *udidHash, uint32_t *count)
1527 {
1528     if (!g_lnnDfxPcIsInit || udidHash == NULL || count == NULL) {
1529         return SOFTBUS_INVALID_PARAM;
1530     }
1531     if (SoftBusMutexLock(&g_lnnDfxPcMutex) != SOFTBUS_OK) {
1532         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1533         return SOFTBUS_LOCK_ERR;
1534     }
1535     uint32_t *tempCount = (uint32_t *)LnnMapGet(&g_lnnDfxPcMap, udidHash);
1536     if (tempCount == NULL) {
1537         LNN_LOGE(LNN_BUILDER, "LnnMapGet fail");
1538         (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1539         return SOFTBUS_NOT_FIND;
1540     }
1541     *count = *tempCount;
1542     (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1543     return SOFTBUS_OK;
1544 }
1545 
UpdateNodeFromPcRestrictMap(const char * udidHash)1546 int32_t UpdateNodeFromPcRestrictMap(const char *udidHash)
1547 {
1548     if (!g_lnnDfxPcIsInit || udidHash == NULL) {
1549         return SOFTBUS_INVALID_PARAM;
1550     }
1551     if (SoftBusMutexLock(&g_lnnDfxPcMutex) != SOFTBUS_OK) {
1552         LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
1553         return SOFTBUS_LOCK_ERR;
1554     }
1555     uint32_t *tempCount = (uint32_t *)LnnMapGet(&g_lnnDfxPcMap, udidHash);
1556     if (tempCount == NULL) {
1557         LNN_LOGE(LNN_BUILDER, "LnnMapGet fail");
1558         (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1559         return SOFTBUS_NOT_FIND;
1560     }
1561     *tempCount = ++(*tempCount);
1562     (void)SoftBusMutexUnlock(&g_lnnDfxPcMutex);
1563     char *anonyUdid = NULL;
1564     Anonymize(udidHash, &anonyUdid);
1565     LNN_LOGI(LNN_BUILDER, "update %{public}s succ count=%{public}u", anonyUdid, *tempCount);
1566     AnonymizeFree(anonyUdid);
1567     return SOFTBUS_OK;
1568 }
1569 
AuthFailNotifyProofInfo(int32_t errCode,const char * errorReturn,uint32_t errorReturnLen)1570 int32_t AuthFailNotifyProofInfo(int32_t errCode, const char *errorReturn, uint32_t errorReturnLen)
1571 {
1572     if (errorReturn == NULL) {
1573         LNN_LOGE(LNN_BUILDER, "invalid param");
1574         return SOFTBUS_INVALID_PARAM;
1575     }
1576     if (errorReturnLen <= 1 || errorReturnLen >= PROOF_INFO_MAX_BUFFER_LEN) {
1577         LNN_LOGE(LNN_BUILDER, "invalid errorReturnLen");
1578         return SOFTBUS_INVALID_PARAM;
1579     }
1580     LnnNotifyHichainProofException(errorReturn, errorReturnLen, TYPE_PC_ID, errCode);
1581     return SOFTBUS_OK;
1582 }