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