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