1 /*
2 * Copyright (c) 2023-2025 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_connection_fsm.h"
17
18 #include <securec.h>
19
20 #include "anonymizer.h"
21 #include "auth_deviceprofile.h"
22 #include "auth_hichain.h"
23 #include "auth_interface.h"
24 #include "auth_manager.h"
25 #include "auth_pre_link.h"
26 #include "auth_deviceprofile.h"
27 #include "bus_center_event.h"
28 #include "bus_center_manager.h"
29 #include "g_enhance_lnn_func.h"
30 #include "g_enhance_lnn_func_pack.h"
31 #include "lnn_async_callback_utils.h"
32 #include "lnn_connection_addr_utils.h"
33 #include "lnn_connection_fsm_process.h"
34 #include "lnn_connId_callback_manager.h"
35 #include "lnn_decision_db.h"
36 #include "lnn_devicename_info.h"
37 #include "lnn_device_info.h"
38 #include "lnn_distributed_net_ledger.h"
39 #include "lnn_event.h"
40 #include "lnn_heartbeat_ctrl.h"
41 #include "lnn_heartbeat_medium_mgr.h"
42 #include "lnn_heartbeat_utils.h"
43 #include "lnn_local_net_ledger.h"
44 #include "lnn_log.h"
45 #include "lnn_net_builder.h"
46 #include "lnn_net_builder_init.h"
47 #include "lnn_sync_item_info.h"
48 #include "lnn_async_callback_utils.h"
49 #include "lnn_feature_capability.h"
50 #include "lnn_deviceinfo_to_profile.h"
51 #include "softbus_adapter_bt_common.h"
52 #include "softbus_adapter_mem.h"
53 #include "softbus_adapter_socket.h"
54 #include "softbus_adapter_timer.h"
55 #include "softbus_error_code.h"
56 #include "softbus_utils.h"
57 #include "softbus_init_common.h"
58 #include "trans_channel_manager.h"
59
60 #define DATA_SIZE 32
61 #define DISCOVERY_TYPE_MASK 0x7FFF
62 #define REASON_OVERFLOW_MAX 255
63 #define PEER_DEVICE_STATE_VERSION_CHANGE 8
64 #define BLE_CONNECT_ONLINE_REASON 16
65
66 typedef enum {
67 STATE_AUTH_INDEX = 0,
68 STATE_CLEAN_INVALID_CONN_INDEX,
69 STATE_ONLINE_INDEX,
70 STATE_LEAVING_INDEX,
71 STATE_CONN_NUM_MAX,
72 } ConnFsmStateIndex;
73
74 typedef enum {
75 ONLINE_TYPE_INVALID = 1,
76 ONLINE_TYPE_WIFI = 2,
77 ONLINE_TYPE_BLE = 3,
78 ONLINE_TYPE_BLE_THREE_STATE = 4,
79 ONLINE_TYPE_BR = 5,
80 } OnlineType;
81
82 #define JOIN_LNN_TIMEOUT_LEN (15 * 1000UL)
83 #define LEAVE_LNN_TIMEOUT_LEN (5 * 1000UL)
84
85 #define TO_CONN_FSM(ptr) CONTAINER_OF(ptr, LnnConnectionFsm, fsm)
86
87 #define CONN_CODE_SHIFT 16
88 #define PC_DEV_TYPE "00C"
89
90 typedef enum {
91 FSM_MSG_TYPE_JOIN_LNN,
92 FSM_MSG_TYPE_AUTH_DONE,
93 FSM_MSG_TYPE_LEAVE_INVALID_CONN,
94 FSM_MSG_TYPE_LEAVE_LNN,
95 FSM_MSG_TYPE_NOT_TRUSTED,
96 FSM_MSG_TYPE_DISCONNECT = 5,
97 FSM_MSG_TYPE_JOIN_LNN_TIMEOUT,
98 FSM_MSG_TYPE_SYNC_OFFLINE_DONE,
99 FSM_MSG_TYPE_LEAVE_LNN_TIMEOUT,
100 FSM_MSG_TYPE_INITIATE_ONLINE,
101 FSM_MSG_TYPE_FORCE_JOIN_LNN,
102 } StateMessageType;
103
104 typedef struct {
105 char localUdidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1];
106 char peerUdidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1];
107 char localDeviceType[DEVICE_TYPE_SIZE_LEN + 1];
108 char peerDeviceType[DEVICE_TYPE_SIZE_LEN + 1];
109 char netWorkId[NETWORK_ID_BUF_LEN];
110 char udidData[UDID_BUF_LEN];
111 char bleMacAddr[MAC_LEN];
112 } LnnDfxReportConnectInfo;
113
114 static LnnTriggerInfo g_lnnTriggerInfo = { 0 };
115 static SoftBusMutex g_lnnTriggerInfoMutex;
116 bool g_lnnTriggerInfoIsInit = false;
117
118 static bool AuthStateProcess(FsmStateMachine *fsm, int32_t msgType, void *para);
119 static bool CleanInvalidConnStateProcess(FsmStateMachine *fsm, int32_t msgType, void *para);
120 static void OnlineStateEnter(FsmStateMachine *fsm);
121 static bool OnlineStateProcess(FsmStateMachine *fsm, int32_t msgType, void *para);
122 static void LeavingStateEnter(FsmStateMachine *fsm);
123 static bool LeavingStateProcess(FsmStateMachine *fsm, int32_t msgType, void *para);
124 static bool IsBasicNodeInfoChanged(const NodeInfo *oldNodeInfo, const NodeInfo *newNodeInfo, bool isUpdate);
125
126 static FsmState g_states[STATE_CONN_NUM_MAX] = {
127 [STATE_AUTH_INDEX] = {
128 .enter = NULL,
129 .process = AuthStateProcess,
130 .exit = NULL,
131 },
132 [STATE_CLEAN_INVALID_CONN_INDEX] = {
133 .enter = NULL,
134 .process = CleanInvalidConnStateProcess,
135 .exit = NULL,
136 },
137 [STATE_ONLINE_INDEX] = {
138 .enter = OnlineStateEnter,
139 .process = OnlineStateProcess,
140 .exit = NULL,
141 },
142 [STATE_LEAVING_INDEX] = {
143 .enter = LeavingStateEnter,
144 .process = LeavingStateProcess,
145 .exit = NULL,
146 },
147 };
148
LnnTriggerInfoInit(void)149 static bool LnnTriggerInfoInit(void)
150 {
151 if (SoftBusMutexInit(&g_lnnTriggerInfoMutex, NULL) != SOFTBUS_OK) {
152 LNN_LOGE(LNN_BUILDER, "lnnTriggerInfo mutex init fail");
153 return false;
154 }
155 g_lnnTriggerInfoIsInit = true;
156 return true;
157 }
158
SetLnnTriggerInfoDeviceCntIncrease(void)159 static void SetLnnTriggerInfoDeviceCntIncrease(void)
160 {
161 if (!g_lnnTriggerInfoIsInit) {
162 LNN_LOGE(LNN_BUILDER, "lnnTriggerInfo is not init");
163 return;
164 }
165 if (SoftBusMutexLock(&g_lnnTriggerInfoMutex) != SOFTBUS_OK) {
166 LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
167 return;
168 }
169 g_lnnTriggerInfo.deviceCnt++;
170 (void)SoftBusMutexUnlock(&g_lnnTriggerInfoMutex);
171 }
172
SetLnnTriggerInfo(uint64_t triggerTime,int32_t deviceCnt,int32_t triggerReason)173 void SetLnnTriggerInfo(uint64_t triggerTime, int32_t deviceCnt, int32_t triggerReason)
174 {
175 if (!g_lnnTriggerInfoIsInit && !LnnTriggerInfoInit()) {
176 LNN_LOGE(LNN_BUILDER, "lnnTriggerInfo is not init");
177 return;
178 }
179 if (SoftBusMutexLock(&g_lnnTriggerInfoMutex) != SOFTBUS_OK) {
180 LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
181 return;
182 }
183 g_lnnTriggerInfo.triggerTime = triggerTime;
184 g_lnnTriggerInfo.deviceCnt = deviceCnt;
185 g_lnnTriggerInfo.triggerReason = triggerReason;
186 (void)SoftBusMutexUnlock(&g_lnnTriggerInfoMutex);
187 }
188
CheckStateMsgCommonArgs(const FsmStateMachine * fsm)189 static bool CheckStateMsgCommonArgs(const FsmStateMachine *fsm)
190 {
191 if (fsm == NULL) {
192 LNN_LOGE(LNN_BUILDER, "fsm is null");
193 return false;
194 }
195 if (TO_CONN_FSM(fsm) == NULL) {
196 LNN_LOGE(LNN_BUILDER, "connFsm is null");
197 return false;
198 }
199 return true;
200 }
201
GetLnnTriggerInfo(LnnTriggerInfo * triggerInfo)202 void GetLnnTriggerInfo(LnnTriggerInfo *triggerInfo)
203 {
204 if (triggerInfo == NULL) {
205 LNN_LOGE(LNN_BUILDER, "invalid param");
206 return;
207 }
208 if (!g_lnnTriggerInfoIsInit) {
209 LNN_LOGE(LNN_BUILDER, "lnnTriggerInfo is not init");
210 return;
211 }
212 if (SoftBusMutexLock(&g_lnnTriggerInfoMutex) != SOFTBUS_OK) {
213 LNN_LOGE(LNN_BUILDER, "SoftBusMutexLock fail");
214 return;
215 }
216 triggerInfo->triggerTime = g_lnnTriggerInfo.triggerTime;
217 triggerInfo->deviceCnt = g_lnnTriggerInfo.deviceCnt;
218 triggerInfo->triggerReason = g_lnnTriggerInfo.triggerReason;
219 (void)SoftBusMutexUnlock(&g_lnnTriggerInfoMutex);
220 }
221
DfxRecordTriggerTime(LnnTriggerReason reason,LnnEventLnnStage stage)222 void DfxRecordTriggerTime(LnnTriggerReason reason, LnnEventLnnStage stage)
223 {
224 uint64_t timeStamp = 0;
225 LnnEventExtra extra = {0};
226 (void)LnnEventExtraInit(&extra);
227 timeStamp = SoftBusGetSysTimeMs();
228 extra.triggerReason = reason;
229 extra.interval = BROADCAST_INTERVAL_DEFAULT;
230 LnnTriggerInfo triggerInfo = {0};
231 GetLnnTriggerInfo(&triggerInfo);
232 if (triggerInfo.triggerTime == 0 || (SoftBusGetSysTimeMs() - triggerInfo.triggerTime) > MAX_TIME_LATENCY) {
233 SetLnnTriggerInfo(timeStamp, 1, extra.triggerReason);
234 }
235 LNN_EVENT(EVENT_SCENE_LNN, stage, extra);
236 LNN_LOGI(LNN_HEART_BEAT, "triggerTime=%{public}" PRId64 ", triggerReason=%{public}d, deviceCnt=1",
237 timeStamp, extra.triggerReason);
238 }
239
CheckDeadFlag(const LnnConnectionFsm * connFsm,bool expectDeadFlag)240 static bool CheckDeadFlag(const LnnConnectionFsm *connFsm, bool expectDeadFlag)
241 {
242 return connFsm->isDead == expectDeadFlag;
243 }
244
NotifyLeaveResult(LnnConnectionFsm * connFsm,const char * networkId,int32_t retCode)245 static void NotifyLeaveResult(LnnConnectionFsm *connFsm, const char *networkId, int32_t retCode)
246 {
247 LnnConntionInfo *connInfo = &connFsm->connInfo;
248
249 if ((connInfo->flag & LNN_CONN_INFO_FLAG_LEAVE_REQUEST) != 0) {
250 LnnNotifyLeaveResult(networkId, retCode);
251 }
252 connInfo->flag &= ~LNN_CONN_INFO_FLAG_LEAVE_ACTIVE;
253 }
254
OnlineTrustGroupProc(const char * udid)255 static void OnlineTrustGroupProc(const char *udid)
256 {
257 NodeInfo nodeInfo;
258 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
259 if (LnnGetRemoteNodeInfoById(udid, CATEGORY_UDID, &nodeInfo) != SOFTBUS_OK) {
260 LNN_LOGE(LNN_BUILDER, "get remote info fail");
261 return;
262 }
263 if (((uint32_t)nodeInfo.groupType & GROUP_TYPE_P2P) == 0) {
264 LNN_LOGW(LNN_BUILDER, "not nonAccount group relation, don't save deviceUdid");
265 return;
266 }
267 LnnInsertSpecificTrustedDevInfo(udid);
268 }
269
ReportResult(const char * udid,ReportCategory report)270 static void ReportResult(const char *udid, ReportCategory report)
271 {
272 NodeBasicInfo basic;
273
274 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
275 if (LnnGetBasicInfoByUdid(udid, &basic) != SOFTBUS_OK) {
276 LNN_LOGE(LNN_BUILDER, "GetBasicInfoByUdid fail!");
277 return;
278 }
279 switch (report) {
280 case REPORT_CHANGE:
281 LnnNotifyBasicInfoChanged(&basic, TYPE_NETWORK_ID);
282 break;
283 case REPORT_ONLINE:
284 LnnNotifyOnlineState(true, &basic);
285 OnlineTrustGroupProc(udid);
286 ReportDeviceOnlineEvt(udid, &basic);
287 break;
288 case REPORT_NONE:
289 /* fall-through */
290 default:
291 break;
292 }
293 }
294
ConvertAddrTypeToHisysEvtLinkType(ConnectionAddrType type)295 static SoftBusLinkType ConvertAddrTypeToHisysEvtLinkType(ConnectionAddrType type)
296 {
297 if (type < CONNECTION_ADDR_WLAN || type > CONNECTION_ADDR_MAX) {
298 return SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
299 }
300 switch (type) {
301 case CONNECTION_ADDR_WLAN:
302 case CONNECTION_ADDR_ETH:
303 return SOFTBUS_HISYSEVT_LINK_TYPE_WLAN;
304 case CONNECTION_ADDR_BR:
305 return SOFTBUS_HISYSEVT_LINK_TYPE_BR;
306 case CONNECTION_ADDR_BLE:
307 return SOFTBUS_HISYSEVT_LINK_TYPE_BLE;
308 case CONNECTION_ADDR_SESSION:
309 case CONNECTION_ADDR_SESSION_WITH_KEY:
310 case CONNECTION_ADDR_MAX:
311 return SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
312 default:
313 return SOFTBUS_HISYSEVT_LINK_TYPE_BUTT;
314 }
315 }
316
ReportLnnResultEvt(LnnConnectionFsm * connFsm,int32_t retCode)317 static void ReportLnnResultEvt(LnnConnectionFsm *connFsm, int32_t retCode)
318 {
319 LNN_LOGD(LNN_BUILDER, "report lnn result evt enter");
320 SoftBusLinkType linkType = ConvertAddrTypeToHisysEvtLinkType(connFsm->connInfo.addr.type);
321 if (linkType == SOFTBUS_HISYSEVT_LINK_TYPE_BUTT) {
322 return;
323 }
324 if (retCode == SOFTBUS_OK) {
325 connFsm->statisticData.beginOnlineTime = LnnUpTimeMs();
326 if (connFsm->statisticData.beginOnlineTime < connFsm->statisticData.beginJoinLnnTime) {
327 LNN_LOGE(LNN_BUILDER, "report static lnn duration fail");
328 return;
329 }
330 uint64_t constTime =
331 (uint64_t)(connFsm->statisticData.beginOnlineTime - connFsm->statisticData.beginJoinLnnTime);
332 if (SoftBusRecordBusCenterResult(linkType, constTime) != SOFTBUS_OK) {
333 LNN_LOGE(LNN_BUILDER, "record buscenter result fail");
334 }
335 return;
336 }
337 SoftBusFaultEvtInfo info;
338 (void)memset_s(&info, sizeof(SoftBusFaultEvtInfo), 0, sizeof(SoftBusFaultEvtInfo));
339 info.moduleType = MODULE_TYPE_ONLINE;
340 info.linkType = linkType;
341 info.errorCode = retCode;
342 if (SoftBusReportBusCenterFaultEvt(&info) != SOFTBUS_OK) {
343 LNN_LOGE(LNN_BUILDER, "report buscenter fault evt fail");
344 }
345 }
346
IsDeviceTypePc(NodeInfo * info)347 static bool IsDeviceTypePc(NodeInfo *info)
348 {
349 if (info == NULL) {
350 LNN_LOGE(LNN_BUILDER, "nodeInfo is NULL");
351 return false;
352 }
353 return info->deviceInfo.deviceTypeId == TYPE_PC_ID;
354 }
355
PostPcOnlineUniquely(NodeInfo * info)356 static void PostPcOnlineUniquely(NodeInfo *info)
357 {
358 if (info == NULL) {
359 LNN_LOGE(LNN_BUILDER, "nodeInfo is NULL");
360 return;
361 }
362 LNN_LOGI(LNN_BUILDER, "pc online");
363 bool isPcWithSoftbus = false;
364 if (info->deviceInfo.deviceTypeId == TYPE_PC_ID &&
365 strcmp(info->networkId, info->deviceInfo.deviceUdid) != 0) {
366 isPcWithSoftbus = true;
367 }
368 if (!isPcWithSoftbus) {
369 LNN_LOGI(LNN_BUILDER, "pc without softbus online");
370 return;
371 }
372 NodeInfo nodeInfo;
373 (void)memset_s(&nodeInfo, sizeof(nodeInfo), 0, sizeof(nodeInfo));
374 char brMacHash[BT_MAC_HASH_STR_LEN] = {0};
375 if (LnnGenerateBtMacHash((const char *)info->connectInfo.macAddr, BT_MAC_LEN,
376 brMacHash, BT_MAC_HASH_STR_LEN) != SOFTBUS_OK) {
377 LNN_LOGE(LNN_BUILDER, "get br mac hash fail");
378 return;
379 }
380 if (LnnGetRemoteNodeInfoById(brMacHash, CATEGORY_UDID, &nodeInfo) == SOFTBUS_OK) {
381 LNN_LOGI(LNN_BUILDER, "set pc without softbus offline");
382 DeleteFromProfile(nodeInfo.deviceInfo.deviceUdid);
383 LnnRemoveNode(nodeInfo.deviceInfo.deviceUdid);
384 }
385 }
386
DeviceStateChangeProcess(char * udid,ConnectionAddrType type,bool isOnline)387 static void DeviceStateChangeProcess(char *udid, ConnectionAddrType type, bool isOnline)
388 {
389 if (udid == NULL) {
390 LNN_LOGE(LNN_BUILDER, "udid is NULL");
391 return;
392 }
393 if (type != CONNECTION_ADDR_BLE) {
394 LNN_LOGE(LNN_BUILDER, "send mlps only support ble");
395 return;
396 }
397 LpDeviceStateInfo *info = (LpDeviceStateInfo *)SoftBusCalloc(sizeof(LpDeviceStateInfo));
398 if (info == NULL) {
399 LNN_LOGE(LNN_BUILDER, "calloc info fail");
400 return;
401 }
402 if (strcpy_s(info->udid, UDID_BUF_LEN, udid) != EOK) {
403 LNN_LOGE(LNN_BUILDER, "strcpy_s outUdid fail");
404 SoftBusFree(info);
405 return;
406 }
407 info->isOnline = isOnline;
408 SoftBusLooper *looper = GetLooper(LOOP_TYPE_DEFAULT);
409 if (LnnAsyncCallbackDelayHelper(looper, SendDeviceStateToMlpsPacked,
410 (void *)info, 0) != SOFTBUS_OK) {
411 LNN_LOGE(LNN_BUILDER, "async call online process fail");
412 SoftBusFree(info);
413 }
414 }
415
NotifyUserChange(bool isChange,NodeInfo * oldInfo,NodeInfo * newInfo)416 static void NotifyUserChange(bool isChange, NodeInfo *oldInfo, NodeInfo *newInfo)
417 {
418 uint8_t defaultUserIdCheckSum[USERID_CHECKSUM_LEN] = {0};
419 if (memcmp(newInfo->userIdCheckSum, defaultUserIdCheckSum, USERID_CHECKSUM_LEN) == 0) {
420 return;
421 }
422 if (isChange || memcmp(oldInfo->userIdCheckSum, newInfo->userIdCheckSum, USERID_CHECKSUM_LEN) != 0) {
423 isChange = true;
424 } else {
425 isChange = false;
426 }
427 NotifyForegroundUseridChange(newInfo->networkId, newInfo->discoveryType, isChange);
428 }
429
SetAssetSessionKeyByAuthInfo(NodeInfo * info,AuthHandle authHandle)430 static void SetAssetSessionKeyByAuthInfo(NodeInfo *info, AuthHandle authHandle)
431 {
432 if (info == NULL) {
433 LNN_LOGE(LNN_BUILDER, "info is null");
434 return;
435 }
436 SessionKey sessionKey;
437 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
438 UpdateDpAclParams aclParams = {
439 .accountId = info->accountId,
440 .deviceId = info->deviceInfo.deviceUdid,
441 .peerUserId = info->userId
442 };
443 UpdateDpSameAccount(&aclParams, sessionKey, false, info->aclState);
444 }
445
SetLnnConnNodeInfo(LnnConntionInfo * connInfo,const char * networkId,LnnConnectionFsm * connFsm,int32_t retCode)446 static void SetLnnConnNodeInfo(
447 LnnConntionInfo *connInfo, const char *networkId, LnnConnectionFsm *connFsm, int32_t retCode)
448 {
449 ReportCategory report;
450 uint64_t localFeature;
451 (void)LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, &localFeature);
452 uint8_t relation[CONNECTION_ADDR_MAX] = { 0 };
453 NodeInfo oldInfo;
454 (void)memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
455 int32_t ret = LnnRetrieveDeviceInfoByNetworkIdPacked(networkId, &oldInfo);
456 if (!connFsm->isNeedConnect && connInfo->addr.type == CONNECTION_ADDR_BLE) {
457 connInfo->nodeInfo->isSupportSv = true;
458 }
459 report = LnnAddOnlineNode(connInfo->nodeInfo);
460 SetAssetSessionKeyByAuthInfo(connInfo->nodeInfo, connInfo->authHandle);
461 LnnOfflineTimingByHeartbeat(networkId, connInfo->addr.type);
462 if (LnnInsertLinkFinderInfoPacked(networkId) != SOFTBUS_OK) {
463 LNN_LOGE(LNN_BUILDER, "insert rpa info fail.");
464 }
465 if (LnnUpdateGroupType(connInfo->nodeInfo) != SOFTBUS_OK) {
466 LNN_LOGE(LNN_BUILDER, "update grouptype fail");
467 }
468 LNN_LOGI(LNN_BUILDER, "peer feature=%{public}" PRIu64 ", local=%{public}" PRIu64 "",
469 connInfo->nodeInfo->feature, localFeature);
470 if (IsFeatureSupport(connInfo->nodeInfo->feature, BIT_BLE_SUPPORT_LP_HEARTBEAT) &&
471 IsFeatureSupport(localFeature, BIT_BLE_SUPPORT_LP_HEARTBEAT)) {
472 DeviceStateChangeProcess(connInfo->nodeInfo->deviceInfo.deviceUdid, connInfo->addr.type, true);
473 }
474 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT),
475 SetLpKeepAliveStatePacked, NULL, 0) != SOFTBUS_OK) {
476 LNN_LOGE(LNN_BUILDER, "async call online process fail");
477 }
478 NotifyJoinResult(connFsm, networkId, retCode);
479 ReportResult(connInfo->nodeInfo->deviceInfo.deviceUdid, report);
480 if (report == REPORT_ONLINE) {
481 NotifyUserChange(ret != SOFTBUS_OK, &oldInfo, connInfo->nodeInfo);
482 }
483 connInfo->flag |= LNN_CONN_INFO_FLAG_ONLINE;
484 LnnNotifyNodeStateChanged(&connInfo->addr);
485 LnnGetLnnRelation(networkId, CATEGORY_NETWORK_ID, relation, CONNECTION_ADDR_MAX);
486 LnnNotifyLnnRelationChanged(
487 connInfo->nodeInfo->deviceInfo.deviceUdid, connInfo->addr.type, relation[connInfo->addr.type], true);
488 LnnNotifyOnlineNetType(networkId, connInfo->addr.type);
489 }
490
DfxRecordLnnOnlineType(const NodeInfo * info)491 static int32_t DfxRecordLnnOnlineType(const NodeInfo *info)
492 {
493 if (info == NULL) {
494 return ONLINE_TYPE_INVALID;
495 }
496 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_WIFI)) {
497 return ONLINE_TYPE_WIFI;
498 }
499 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR)) {
500 return ONLINE_TYPE_BR;
501 }
502 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE)) {
503 uint32_t local;
504 if (LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &local) != SOFTBUS_OK) {
505 LNN_LOGE(LNN_BUILDER, "get cap fail");
506 return ONLINE_TYPE_INVALID;
507 }
508 if (((local & (1 << BIT_BR)) == 0) || (info->netCapacity & (1 << BIT_BR)) == 0) {
509 return ONLINE_TYPE_BLE_THREE_STATE;
510 } else {
511 return ONLINE_TYPE_BLE;
512 }
513 }
514 return ONLINE_TYPE_INVALID;
515 }
516
GetLnnOnlineType(bool isNeedConnect,ConnectionAddrType type,int32_t * lnnType)517 static void GetLnnOnlineType(bool isNeedConnect, ConnectionAddrType type, int32_t *lnnType)
518 {
519 if (!isNeedConnect && type == CONNECTION_ADDR_BLE) {
520 *lnnType = LNN_TYPE_BLE_BROADCAST_ONLINE;
521 } else if (isNeedConnect && type == CONNECTION_ADDR_BLE) {
522 *lnnType = LNN_TYPE_BLE_CONNECT_ONLINE;
523 } else if (type == CONNECTION_ADDR_WLAN || type == CONNECTION_ADDR_ETH) {
524 *lnnType = LNN_TYPE_WIFI_CONNECT_ONLINE;
525 } else if (type == CONNECTION_ADDR_BR) {
526 *lnnType = LNN_TYPE_BR_CONNECT_ONLINE;
527 } else {
528 *lnnType = LNN_TYPE_OTHER_CONNECT_ONLINE;
529 }
530 }
531
IsEmptyShortHashStr(char * udidHash)532 static bool IsEmptyShortHashStr(char *udidHash)
533 {
534 if (strlen(udidHash) == 0) {
535 LNN_LOGI(LNN_BUILDER, "udidhash len is 0");
536 return true;
537 }
538 uint8_t emptyHash[HB_SHORT_UDID_HASH_LEN] = { 0 };
539 char emptyHashStr[HB_SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
540 if (ConvertBytesToHexString(emptyHashStr, HB_SHORT_UDID_HASH_HEX_LEN + 1, emptyHash, HB_SHORT_UDID_HASH_LEN)
541 != SOFTBUS_OK) {
542 LNN_LOGE(LNN_BUILDER, "convert bytes to string fail");
543 return false;
544 }
545 if (strncmp(emptyHashStr, udidHash, strlen(emptyHashStr)) == 0) {
546 LNN_LOGI(LNN_BUILDER, "udidhash is empty");
547 return true;
548 }
549 return false;
550 }
551
GetUdidHashForDfx(char * localUdidHash,char * peerUdidHash,LnnConntionInfo * connInfo)552 static int32_t GetUdidHashForDfx(char *localUdidHash, char *peerUdidHash, LnnConntionInfo *connInfo)
553 {
554 int32_t rc = SOFTBUS_OK;
555 const NodeInfo *localInfo = LnnGetLocalNodeInfo();
556 if (localInfo == NULL) {
557 LNN_LOGE(LNN_BUILDER, "localInfo is NULL");
558 return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
559 }
560 uint8_t hash[UDID_HASH_LEN] = { 0 };
561 rc = SoftBusGenerateStrHash((uint8_t *)localInfo->deviceInfo.deviceUdid, strlen(localInfo->deviceInfo.deviceUdid),
562 hash);
563 if (rc != SOFTBUS_OK) {
564 LNN_LOGE(LNN_BUILDER, "generate udidhash fail");
565 return rc;
566 }
567 rc = ConvertBytesToHexString(localUdidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1, hash, HB_SHORT_UDID_HASH_LEN);
568 if (rc != SOFTBUS_OK) {
569 LNN_LOGE(LNN_BUILDER, "convert bytes to string fail");
570 return rc;
571 }
572 if (connInfo->addr.type == CONNECTION_ADDR_WLAN) {
573 if (strncpy_s(peerUdidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1, (char *)connInfo->addr.info.ip.udidHash,
574 HB_SHORT_UDID_HASH_HEX_LEN) != EOK) {
575 LNN_LOGE(LNN_BUILDER, "strcpy_s wifi udidhash fail");
576 return SOFTBUS_STRCPY_ERR;
577 }
578 } else if (connInfo->addr.type == CONNECTION_ADDR_BLE) {
579 rc = ConvertBytesToHexString(peerUdidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1,
580 (const unsigned char *)connInfo->addr.info.ble.udidHash, HB_SHORT_UDID_HASH_LEN);
581 if (rc != SOFTBUS_OK) {
582 LNN_LOGE(LNN_BUILDER, "get ble udidhash fail");
583 return rc;
584 }
585 }
586 return SOFTBUS_OK;
587 }
588
GetPeerUdidHash(NodeInfo * nodeInfo,char * peerUdidHash)589 static int32_t GetPeerUdidHash(NodeInfo *nodeInfo, char *peerUdidHash)
590 {
591 if (nodeInfo == NULL || peerUdidHash == NULL) {
592 LNN_LOGE(LNN_BUILDER, "param error");
593 return SOFTBUS_INVALID_PARAM;
594 }
595 int32_t rc = SOFTBUS_OK;
596 uint8_t hash[UDID_HASH_LEN] = { 0 };
597 rc = SoftBusGenerateStrHash((uint8_t *)nodeInfo->deviceInfo.deviceUdid,
598 strlen(nodeInfo->deviceInfo.deviceUdid), hash);
599 if (rc != SOFTBUS_OK) {
600 LNN_LOGE(LNN_BUILDER, "generate udidhash fail");
601 return rc;
602 }
603 rc = ConvertBytesToHexString(peerUdidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1, hash, HB_SHORT_UDID_HASH_LEN);
604 if (rc != SOFTBUS_OK) {
605 LNN_LOGE(LNN_BUILDER, "convert bytes to string fail");
606 return rc;
607 }
608 return SOFTBUS_OK;
609 }
610
GetDevTypeForDfx(char * localDeviceType,char * peerDeviceType,LnnConntionInfo * connInfo)611 static int32_t GetDevTypeForDfx(char *localDeviceType, char *peerDeviceType, LnnConntionInfo *connInfo)
612 {
613 NodeInfo localInfo;
614 (void)memset_s(&localInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
615 if (LnnGetLocalNodeInfoSafe(&localInfo) != SOFTBUS_OK) {
616 LNN_LOGE(LNN_BUILDER, "get local device info fail");
617 return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
618 }
619 if (snprintf_s(localDeviceType, DEVICE_TYPE_SIZE_LEN + 1, DEVICE_TYPE_SIZE_LEN, "%03X",
620 localInfo.deviceInfo.deviceTypeId) < 0) {
621 LNN_LOGE(LNN_BUILDER, "snprintf_s localDeviceType fail");
622 return SOFTBUS_SPRINTF_ERR;
623 }
624 if (connInfo->nodeInfo == NULL) {
625 if (snprintf_s(peerDeviceType, DEVICE_TYPE_SIZE_LEN + 1, DEVICE_TYPE_SIZE_LEN, "%03X",
626 (uint16_t)connInfo->infoReport.type) < 0) {
627 LNN_LOGE(LNN_BUILDER, "snprintf_s peerDeviceType by infoReport fail");
628 return SOFTBUS_SPRINTF_ERR;
629 }
630 } else {
631 if (snprintf_s(peerDeviceType, DEVICE_TYPE_SIZE_LEN + 1, DEVICE_TYPE_SIZE_LEN, "%03X",
632 connInfo->nodeInfo->deviceInfo.deviceTypeId) < 0) {
633 LNN_LOGE(LNN_BUILDER, "snprintf_s peerDeviceType fail");
634 return SOFTBUS_SPRINTF_ERR;
635 }
636 }
637 LNN_LOGI(LNN_BUILDER, "localDeviceType=%{public}s, peerDeviceType=%{public}s", localDeviceType, peerDeviceType);
638 return SOFTBUS_OK;
639 }
640
GetPeerUdidInfo(NodeInfo * nodeInfo,char * udidData,char * peerUdidHash)641 static int32_t GetPeerUdidInfo(NodeInfo *nodeInfo, char *udidData, char *peerUdidHash)
642 {
643 int32_t rc = SOFTBUS_OK;
644 if (strcpy_s(udidData, UDID_BUF_LEN, nodeInfo->deviceInfo.deviceUdid) != EOK) {
645 LNN_LOGE(LNN_BUILDER, "strcpy_s udidData fail");
646 return SOFTBUS_STRCPY_ERR;
647 }
648 if (IsEmptyShortHashStr(peerUdidHash) || strlen(peerUdidHash) != HB_SHORT_UDID_HASH_HEX_LEN) {
649 rc = GetPeerUdidHash(nodeInfo, peerUdidHash);
650 if (rc != SOFTBUS_OK) {
651 LNN_LOGE(LNN_BUILDER, "get udidhash fail");
652 return rc;
653 }
654 }
655 return SOFTBUS_OK;
656 }
657
SetOnlineType(int32_t reason,NodeInfo * nodeInfo,LnnEventExtra extra)658 static void SetOnlineType(int32_t reason, NodeInfo *nodeInfo, LnnEventExtra extra)
659 {
660 if (reason == SOFTBUS_OK) {
661 extra.onlineType = (uint32_t)DfxRecordLnnOnlineType(nodeInfo);
662 } else {
663 extra.onlineType = ONLINE_TYPE_INVALID;
664 }
665 }
666
FillDeviceBleReportExtra(const LnnEventExtra * extra,LnnBleReportExtra * bleExtra)667 static int32_t FillDeviceBleReportExtra(const LnnEventExtra *extra, LnnBleReportExtra *bleExtra)
668 {
669 if (extra == NULL || bleExtra == NULL) {
670 LNN_LOGE(LNN_BUILDER, "invalid param");
671 return SOFTBUS_INVALID_PARAM;
672 }
673 bleExtra->extra.onlineType = extra->onlineType;
674 if (strcpy_s(bleExtra->extra.peerNetworkId, NETWORK_ID_BUF_LEN, extra->peerNetworkId) != EOK) {
675 LNN_LOGE(LNN_BUILDER, "strcpy_s peerNetworkId fail");
676 return SOFTBUS_STRCPY_ERR;
677 }
678 if (strcpy_s(bleExtra->extra.peerUdid, UDID_BUF_LEN, extra->peerUdid) != EOK) {
679 LNN_LOGE(LNN_BUILDER, "strcpy_s peerUdid fail");
680 return SOFTBUS_STRCPY_ERR;
681 }
682 if (strcpy_s(bleExtra->extra.peerUdidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1, extra->peerUdidHash) != EOK) {
683 LNN_LOGE(LNN_BUILDER, "strcpy_s peerUdidHash fail");
684 return SOFTBUS_STRCPY_ERR;
685 }
686 if (strcpy_s(bleExtra->extra.peerBleMac, BT_MAC_LEN, extra->peerBleMac) != EOK) {
687 LNN_LOGE(LNN_BUILDER, "strcpy_s peerBleMac fail");
688 return SOFTBUS_STRCPY_ERR;
689 }
690 return SOFTBUS_OK;
691 }
692
DfxAddBleReportExtra(const LnnConntionInfo * connInfo,const LnnEventExtra * extra,LnnBleReportExtra * bleExtra)693 static void DfxAddBleReportExtra(
694 const LnnConntionInfo *connInfo, const LnnEventExtra *extra, LnnBleReportExtra *bleExtra)
695 {
696 if (connInfo == NULL || extra == NULL || bleExtra == NULL) {
697 LNN_LOGE(LNN_BUILDER, "invalid param");
698 return;
699 }
700 bleExtra->extra.onlineNum = extra->onlineNum;
701 bleExtra->extra.errcode = extra->errcode;
702 bleExtra->extra.lnnType = extra->lnnType;
703 bleExtra->extra.result = extra->result;
704 bleExtra->extra.osType = extra->osType;
705 bleExtra->extra.connOnlineReason = extra->connOnlineReason;
706 if (strcpy_s(bleExtra->extra.localUdidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1, extra->localUdidHash) != EOK) {
707 LNN_LOGE(LNN_BUILDER, "strcpy_s localUdidHash fail");
708 return;
709 }
710 if (strcpy_s(bleExtra->extra.peerUdidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1, extra->peerUdidHash) != EOK) {
711 LNN_LOGE(LNN_BUILDER, "strcpy_s peerUdidHash fail");
712 return;
713 }
714 if (strcpy_s(bleExtra->extra.localDeviceType, DEVICE_TYPE_SIZE_LEN + 1, extra->localDeviceType) != EOK) {
715 LNN_LOGE(LNN_BUILDER, "strcpy_s localDeviceType fail");
716 return;
717 }
718 if (strcpy_s(bleExtra->extra.peerDeviceType, DEVICE_TYPE_SIZE_LEN + 1, extra->peerDeviceType) != EOK) {
719 LNN_LOGE(LNN_BUILDER, "strcpy_s peerDeviceType fail");
720 return;
721 }
722 if (extra->errcode == SOFTBUS_AUTH_HICHAIN_NO_CANDIDATE_GROUP &&
723 (strncmp(extra->peerDeviceType, PC_DEV_TYPE, strlen(PC_DEV_TYPE)) == 0)) {
724 LnnBlePcRestrictMapInit();
725 uint32_t count = 0;
726 if (GetNodeFromPcRestrictMap(extra->peerUdidHash, &count) == SOFTBUS_OK) {
727 UpdateNodeFromPcRestrictMap(extra->peerUdidHash);
728 } else {
729 AddNodeToPcRestrictMap(extra->peerUdidHash);
730 }
731 }
732 if (connInfo->nodeInfo == NULL) {
733 bleExtra->status = BLE_REPORT_EVENT_FAIL;
734 AddNodeToLnnBleReportExtraMap(bleExtra->extra.peerUdidHash, bleExtra);
735 return;
736 }
737 if (FillDeviceBleReportExtra(extra, bleExtra) != SOFTBUS_OK) {
738 LNN_LOGE(LNN_BUILDER, "FillDeviceBleReportExtra fail");
739 return;
740 }
741 bleExtra->status = BLE_REPORT_EVENT_FAIL;
742 AddNodeToLnnBleReportExtraMap(bleExtra->extra.peerUdidHash, bleExtra);
743 }
744
DfxReportOnlineEvent(LnnConntionInfo * connInfo,int32_t reason,LnnEventExtra extra)745 static void DfxReportOnlineEvent(LnnConntionInfo *connInfo, int32_t reason, LnnEventExtra extra)
746 {
747 if (connInfo == NULL) {
748 LNN_LOGE(LNN_BUILDER, "connInfo is NULL");
749 return;
750 }
751 uint64_t timeStamp = 0;
752 LnnTriggerInfo triggerInfo = { 0 };
753 GetLnnTriggerInfo(&triggerInfo);
754 int32_t osType = connInfo->infoReport.osType;
755 LNN_LOGI(LNN_BUILDER, "osType=%{public}d, extra.osType=%{public}d", osType, extra.osType);
756 if (connInfo->addr.type == CONNECTION_ADDR_BLE) {
757 LnnBleReportExtra bleExtra;
758 (void)memset_s(&bleExtra, sizeof(LnnBleReportExtra), 0, sizeof(LnnBleReportExtra));
759 if (IsExistLnnDfxNodeByUdidHash(extra.peerUdidHash, &bleExtra)) {
760 if (reason != SOFTBUS_OK) {
761 extra.osType = osType;
762 DfxAddBleReportExtra(connInfo, &extra, &bleExtra);
763 return;
764 }
765 if ((SoftBusGetSysTimeMs() - triggerInfo.triggerTime) < MAX_TIME_LATENCY) {
766 timeStamp = SoftBusGetSysTimeMs();
767 extra.timeLatency = timeStamp - triggerInfo.triggerTime;
768 extra.onlineDevCnt = triggerInfo.deviceCnt;
769 extra.triggerReason = triggerInfo.triggerReason;
770 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_JOIN_LNN_END, extra);
771 SetLnnTriggerInfoDeviceCntIncrease();
772 } else {
773 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_JOIN_LNN_END, extra);
774 }
775 bleExtra.status = BLE_REPORT_EVENT_SUCCESS;
776 AddNodeToLnnBleReportExtraMap(extra.peerUdidHash, &bleExtra);
777 }
778 return;
779 }
780 if (reason == SOFTBUS_OK && (SoftBusGetSysTimeMs() - triggerInfo.triggerTime) < MAX_TIME_LATENCY) {
781 timeStamp = SoftBusGetSysTimeMs();
782 extra.timeLatency = timeStamp - triggerInfo.triggerTime;
783 extra.onlineDevCnt = triggerInfo.deviceCnt;
784 extra.triggerReason = triggerInfo.triggerReason;
785 SetLnnTriggerInfoDeviceCntIncrease();
786 }
787 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_JOIN_LNN_END, extra);
788 }
789
GetPeerConnInfo(const LnnConntionInfo * connInfo,char * netWorkId,char * bleMacAddr)790 static int32_t GetPeerConnInfo(const LnnConntionInfo *connInfo, char *netWorkId, char *bleMacAddr)
791 {
792 if (strcpy_s(netWorkId, NETWORK_ID_BUF_LEN, connInfo->nodeInfo->networkId) != EOK) {
793 LNN_LOGE(LNN_BUILDER, "strcpy_s netWorkId fail");
794 return SOFTBUS_STRCPY_ERR;
795 }
796 if (strcpy_s(bleMacAddr, MAC_LEN, connInfo->nodeInfo->connectInfo.bleMacAddr) != EOK) {
797 LNN_LOGE(LNN_BUILDER, "strcpy_s bleMacAddr fail");
798 return SOFTBUS_STRCPY_ERR;
799 }
800 return SOFTBUS_OK;
801 }
802
GetConnectOnlineReason(LnnConntionInfo * connInfo,uint32_t * connOnlineReason,int32_t reason)803 static void GetConnectOnlineReason(LnnConntionInfo *connInfo, uint32_t *connOnlineReason, int32_t reason)
804 {
805 uint8_t connectReason = 0;
806 uint8_t localReason = 0;
807 uint8_t peerReason = 0;
808
809 NodeInfo localInfo;
810 (void)memset_s(&localInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
811 if (LnnGetLocalNodeInfoSafe(&localInfo) != SOFTBUS_OK) {
812 LNN_LOGE(LNN_BUILDER, "get local device info fail");
813 return;
814 }
815 if ((uint32_t)connInfo->infoReport.bleConnectReason > REASON_OVERFLOW_MAX ||
816 localInfo.stateVersionReason > REASON_OVERFLOW_MAX ||
817 (connInfo->nodeInfo != NULL && connInfo->nodeInfo->stateVersionReason > REASON_OVERFLOW_MAX)) {
818 LNN_LOGE(LNN_BUILDER, "reason convert will overflow");
819 return;
820 }
821 connectReason = (uint8_t)connInfo->infoReport.bleConnectReason;
822 localReason = (uint8_t)localInfo.stateVersionReason;
823 if (connInfo->nodeInfo == NULL) {
824 peerReason = 0;
825 } else {
826 peerReason = (uint8_t)connInfo->nodeInfo->stateVersionReason;
827 }
828
829 *connOnlineReason =
830 ((connectReason << BLE_CONNECT_ONLINE_REASON) | (peerReason << PEER_DEVICE_STATE_VERSION_CHANGE) | localReason);
831 LNN_LOGI(LNN_BUILDER,
832 "connOnlineReason=%{public}u, connectReason=%{public}hhu, peerReason=%{public}hhu, localReason=%{public}hhu",
833 *connOnlineReason, connectReason, peerReason, localReason);
834 }
835
NotifyProofExceptionEvent(DeviceType type,int32_t reason,const char * peerDeviceType)836 static void NotifyProofExceptionEvent(DeviceType type, int32_t reason, const char *peerDeviceType)
837 {
838 if ((reason == SOFTBUS_AUTH_HICHAIN_NO_CANDIDATE_GROUP || reason == SOFTBUS_AUTH_HICHAIN_PROOF_MISMATCH ||
839 reason == PC_PROOF_NON_CONSISTENT_ERRCODE) &&
840 (strncmp(peerDeviceType, PC_DEV_TYPE, strlen(PC_DEV_TYPE)) == 0)) {
841 LnnNotifyHichainProofException(NULL, 0, (uint16_t)type, reason);
842 LNN_LOGE(LNN_BUILDER, "notify hichain proof exception event, reason=%{public}d, type=%{public}hu", reason,
843 (uint16_t)type);
844 }
845 }
846
DfxRecordLnnAddOnlineNodeEnd(LnnConntionInfo * connInfo,int32_t onlineNum,int32_t lnnType,int32_t reason)847 static void DfxRecordLnnAddOnlineNodeEnd(LnnConntionInfo *connInfo, int32_t onlineNum, int32_t lnnType, int32_t reason)
848 {
849 LnnEventExtra extra = { 0 };
850 LnnEventExtraInit(&extra);
851 extra.onlineNum = onlineNum;
852 extra.errcode = reason;
853 extra.lnnType = lnnType;
854 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
855 LnnDfxReportConnectInfo dfxConnectInfo = {};
856 uint32_t connOnlineReason = 0;
857 if (GetUdidHashForDfx(dfxConnectInfo.localUdidHash, dfxConnectInfo.peerUdidHash, connInfo) != SOFTBUS_OK) {
858 LNN_LOGE(LNN_BUILDER, "get udidhash fail");
859 return;
860 }
861 if (GetDevTypeForDfx(dfxConnectInfo.localDeviceType, dfxConnectInfo.peerDeviceType, connInfo) != SOFTBUS_OK) {
862 LNN_LOGE(LNN_BUILDER, "get device type fail");
863 return;
864 }
865 if (connInfo->addr.type == CONNECTION_ADDR_BLE) {
866 (void)GetConnectOnlineReason(connInfo, &connOnlineReason, reason);
867 }
868 extra.localUdidHash = dfxConnectInfo.localUdidHash;
869 extra.peerUdidHash = dfxConnectInfo.peerUdidHash;
870 extra.localDeviceType = dfxConnectInfo.localDeviceType;
871 extra.peerDeviceType = dfxConnectInfo.peerDeviceType;
872 extra.connOnlineReason = connOnlineReason;
873 NotifyProofExceptionEvent(connInfo->infoReport.type, reason, extra.peerDeviceType);
874 if (connInfo->nodeInfo == NULL) {
875 DfxReportOnlineEvent(connInfo, reason, extra);
876 return;
877 }
878 SetOnlineType(reason, connInfo->nodeInfo, extra);
879 if (GetPeerUdidInfo(connInfo->nodeInfo, dfxConnectInfo.udidData, dfxConnectInfo.peerUdidHash) != SOFTBUS_OK) {
880 LNN_LOGE(LNN_BUILDER, "get peer udid fail");
881 return;
882 }
883 if (GetPeerConnInfo(connInfo, dfxConnectInfo.netWorkId, dfxConnectInfo.bleMacAddr) != SOFTBUS_OK) {
884 LNN_LOGE(LNN_BUILDER, "get peer connInfo fail");
885 return;
886 }
887 if (connInfo->addr.type == CONNECTION_ADDR_BLE) {
888 extra.osType = connInfo->nodeInfo->deviceInfo.osType;
889 }
890 extra.peerNetworkId = dfxConnectInfo.netWorkId;
891 extra.peerUdid = dfxConnectInfo.udidData;
892 extra.peerUdidHash = dfxConnectInfo.peerUdidHash;
893 extra.peerBleMac = dfxConnectInfo.bleMacAddr;
894 DfxReportOnlineEvent(connInfo, reason, extra);
895 }
896
DeletePcRestrictNode(int32_t retCode,NodeInfo * nodeInfo)897 static void DeletePcRestrictNode(int32_t retCode, NodeInfo *nodeInfo)
898 {
899 char peerUdidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
900 uint32_t count = 0;
901 if (retCode == SOFTBUS_OK && GetPeerUdidHash(nodeInfo, peerUdidHash) == SOFTBUS_OK) {
902 if (GetNodeFromPcRestrictMap(peerUdidHash, &count) == SOFTBUS_OK) {
903 DeleteNodeFromPcRestrictMap(peerUdidHash);
904 }
905 }
906 }
907
NotifyJoinExtResultProcess(LnnConnectionFsm * connFsm,int32_t retCode)908 static void NotifyJoinExtResultProcess(LnnConnectionFsm *connFsm, int32_t retCode)
909 {
910 if (!connFsm->isSession) {
911 return;
912 }
913 if (connFsm->connInfo.nodeInfo != NULL) {
914 LnnNotifyStateForSession(connFsm->connInfo.nodeInfo->deviceInfo.deviceUdid, retCode);
915 return;
916 }
917 NotifyStateForSession(&connFsm->connInfo.addr);
918 }
919
IsRepeatDeviceId(NodeInfo * info)920 static bool IsRepeatDeviceId(NodeInfo *info)
921 {
922 if (info == NULL || (strlen(info->deviceInfo.deviceUdid) != UDID_BUF_LEN - 1) ||
923 (strlen(info->networkId) != NETWORK_ID_BUF_LEN - 1)) {
924 LNN_LOGE(LNN_BUILDER, "nodeInfo err");
925 return false;
926 }
927 NodeInfo oldInfo;
928 (void)memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
929 if (LnnGetRemoteNodeInfoById(info->networkId, CATEGORY_NETWORK_ID, &oldInfo) != SOFTBUS_OK) {
930 LNN_LOGE(LNN_BUILDER, "device not found");
931 return false;
932 }
933 if (strcmp(info->deviceInfo.deviceUdid, oldInfo.deviceInfo.deviceUdid) == 0) {
934 LNN_LOGE(LNN_BUILDER, "same device");
935 return false;
936 }
937 if (!LnnIsNodeOnline(&oldInfo)) {
938 LnnRemoveNode(oldInfo.deviceInfo.deviceUdid);
939 LNN_LOGE(LNN_BUILDER, "delete old info");
940 return false;
941 }
942 char *anonyUdid = NULL;
943 Anonymize(oldInfo.deviceInfo.deviceUdid, &anonyUdid);
944 LNN_LOGI(LNN_BUILDER, "repeat networkId. old udid=%{public}s", AnonymizeWrapper(anonyUdid));
945 AnonymizeFree(anonyUdid);
946 return true;
947 }
948
NeedUpdateRawEnhanceP2p(LnnConnectionFsm * connFsm)949 static bool NeedUpdateRawEnhanceP2p(LnnConnectionFsm *connFsm)
950 {
951 if (connFsm->connInfo.addr.type != CONNECTION_ADDR_SESSION_WITH_KEY) {
952 LNN_LOGI(LNN_BUILDER, "addr type not session wiht key, skip");
953 return false;
954 }
955 bool needUpdateAuthManager = false;
956 needUpdateAuthManager = RawLinkNeedUpdateAuthManager(connFsm->connInfo.nodeInfo->uuid, false);
957 if (!needUpdateAuthManager) {
958 needUpdateAuthManager = RawLinkNeedUpdateAuthManager(connFsm->connInfo.nodeInfo->uuid, true);
959 }
960 return needUpdateAuthManager;
961 }
962
TryUpdateRawEnhanceP2p(LnnConnectionFsm * connFsm)963 static void TryUpdateRawEnhanceP2p(LnnConnectionFsm *connFsm)
964 {
965 if (NeedUpdateRawEnhanceP2p(connFsm)) {
966 LNN_LOGI(LNN_BUILDER, "notify add raw auth connection");
967 LnnNotifyRawEnhanceP2pEvent event = {.basic.event = LNN_EVENT_NOTIFY_RAW_ENHANCE_P2P};
968 event.basic.event = LNN_EVENT_NOTIFY_RAW_ENHANCE_P2P;
969 event.type = connFsm->connInfo.addr.type;
970 event.uuid = connFsm->connInfo.nodeInfo->uuid;
971 event.networkId = connFsm->connInfo.nodeInfo->networkId;
972 LnnNotifyAddRawEnhanceP2pEvent(&event);
973 }
974 }
975
CompleteJoinLNN(LnnConnectionFsm * connFsm,const char * networkId,int32_t retCode)976 static void CompleteJoinLNN(LnnConnectionFsm *connFsm, const char *networkId, int32_t retCode)
977 {
978 LnnConntionInfo *connInfo = &connFsm->connInfo;
979
980 if (connInfo == NULL) {
981 LNN_LOGE(LNN_BUILDER, "CompleteJoinLNN connInfo is NULL");
982 return;
983 }
984 SetWatchdogFlag(true);
985 LnnFsmRemoveMessage(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT);
986 if (IsDeviceTypePc(connInfo->nodeInfo)) {
987 PostPcOnlineUniquely(connInfo->nodeInfo);
988 }
989 ReportLnnResultEvt(connFsm, retCode);
990 if (retCode == SOFTBUS_OK && connInfo->nodeInfo != NULL) {
991 SetLnnConnNodeInfo(connInfo, networkId, connFsm, retCode);
992 TryUpdateRawEnhanceP2p(connFsm);
993 } else if (retCode != SOFTBUS_OK) {
994 NotifyJoinResult(connFsm, networkId, retCode);
995 connFsm->isDead = true;
996 LnnNotifyAuthHandleLeaveLNN(connInfo->authHandle);
997 }
998 NotifyJoinExtResultProcess(connFsm, retCode);
999 int32_t infoNum = 0;
1000 int32_t lnnType = 0;
1001 NodeBasicInfo *info = NULL;
1002 bool isSuccessFlag = true;
1003 GetLnnOnlineType(connFsm->isNeedConnect, connInfo->addr.type, &lnnType);
1004 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
1005 LNN_LOGE(LNN_BUILDER, "Lnn get online node fail");
1006 isSuccessFlag = false;
1007 }
1008 if ((connInfo->flag & LNN_CONN_INFO_FLAG_JOIN_REQUEST) == 0 && lnnType == LNN_TYPE_BR_CONNECT_ONLINE) {
1009 isSuccessFlag = false;
1010 SoftBusFree(info);
1011 }
1012 if (isSuccessFlag) {
1013 DfxRecordLnnAddOnlineNodeEnd(connInfo, infoNum, lnnType, retCode);
1014 SoftBusFree(info);
1015 }
1016 DeletePcRestrictNode(retCode, connInfo->nodeInfo);
1017 if (connInfo->nodeInfo != NULL) {
1018 SoftBusFree(connInfo->nodeInfo);
1019 connInfo->nodeInfo = NULL;
1020 }
1021 connInfo->flag &= ~LNN_CONN_INFO_FLAG_JOIN_PASSIVE;
1022 if (retCode != SOFTBUS_OK) {
1023 LNN_LOGE(LNN_BUILDER, "join failed, ready clean, [id=%{public}u], retCode=%{public}d", connFsm->id, retCode);
1024 LnnRequestCleanConnFsm(connFsm->id);
1025 return;
1026 }
1027 LNN_LOGI(LNN_BUILDER, "complete join LNN done. [id=%{public}u]", connFsm->id);
1028 }
1029
UpdateLeaveToLedger(const LnnConnectionFsm * connFsm,const char * networkId,NodeBasicInfo * basic)1030 static bool UpdateLeaveToLedger(const LnnConnectionFsm *connFsm, const char *networkId, NodeBasicInfo *basic)
1031 {
1032 const LnnConntionInfo *connInfo = &connFsm->connInfo;
1033 NodeInfo info;
1034 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1035 const char *udid = NULL;
1036 bool needReportOffline = false;
1037 bool isMetaAuth = false;
1038 bool isCleanInfo = connInfo->cleanInfo != NULL ? true : false;
1039 uint8_t relation[CONNECTION_ADDR_MAX] = {0};
1040 ReportCategory report;
1041 const char *findNetworkId = isCleanInfo ? connInfo->cleanInfo->networkId : networkId;
1042 if (LnnGetRemoteNodeInfoById(findNetworkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
1043 LNN_LOGW(LNN_BUILDER, "get node info by networkId fail, isCleanInfo=%{public}d", isCleanInfo);
1044 return needReportOffline;
1045 }
1046 isMetaAuth = (info.AuthTypeValue & (1 << ONLINE_METANODE)) != 0;
1047 udid = LnnGetDeviceUdid(&info);
1048 report = LnnSetNodeOffline(udid, connInfo->addr.type, (int32_t)connInfo->authHandle.authId);
1049 LnnGetLnnRelation(udid, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
1050 LnnNotifyLnnRelationChanged(udid, connInfo->addr.type, relation[connInfo->addr.type], false);
1051 if (LnnGetBasicInfoByUdid(udid, basic) != SOFTBUS_OK) {
1052 LNN_LOGE(LNN_BUILDER, "get basic info fail. [id=%{public}u]", connFsm->id);
1053 needReportOffline = false;
1054 }
1055 if (isCleanInfo) {
1056 if (strcpy_s(basic->networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
1057 LNN_LOGE(LNN_BUILDER, "strcpy networkId fail");
1058 return needReportOffline;
1059 }
1060 }
1061 if (report == REPORT_OFFLINE) {
1062 needReportOffline = true;
1063 DeleteFromProfile(udid);
1064 // just remove node when peer device is not trusted
1065 if ((connInfo->flag & LNN_CONN_INFO_FLAG_LEAVE_PASSIVE) != 0 && !isMetaAuth) {
1066 LNN_LOGE(LNN_BUILDER, "remove node. [id=%{public}u]", connFsm->id);
1067 LnnRemoveNode(udid);
1068 }
1069 }
1070 return needReportOffline;
1071 }
1072
ReportLeaveLNNResultEvt(LnnConnectionFsm * connFsm,int32_t retCode)1073 static void ReportLeaveLNNResultEvt(LnnConnectionFsm *connFsm, int32_t retCode)
1074 {
1075 LNN_LOGI(LNN_BUILDER, "report leave lnn result evt enter");
1076 if (retCode == SOFTBUS_OK) {
1077 connFsm->statisticData.offLineTime = LnnUpTimeMs();
1078 if (connFsm->statisticData.offLineTime < connFsm->statisticData.beginOnlineTime) {
1079 LNN_LOGE(LNN_BUILDER, "report static device online duration fail");
1080 return;
1081 }
1082 uint64_t constTime = (uint64_t)(connFsm->statisticData.offLineTime - connFsm->statisticData.beginOnlineTime);
1083 if (SoftBusRecordDevOnlineDurResult(constTime) != SOFTBUS_OK) {
1084 LNN_LOGE(LNN_BUILDER, "report static device online duration fail");
1085 }
1086 return;
1087 }
1088 SoftBusLinkType linkType = ConvertAddrTypeToHisysEvtLinkType(connFsm->connInfo.addr.type);
1089 if (linkType == SOFTBUS_HISYSEVT_LINK_TYPE_BUTT) {
1090 return;
1091 }
1092 SoftBusFaultEvtInfo info;
1093 (void)memset_s(&info, sizeof(SoftBusFaultEvtInfo), 0, sizeof(SoftBusFaultEvtInfo));
1094 info.moduleType = MODULE_TYPE_ONLINE;
1095 info.linkType = linkType;
1096 info.errorCode = retCode;
1097 if (SoftBusReportBusCenterFaultEvt(&info) != SOFTBUS_OK) {
1098 LNN_LOGE(LNN_BUILDER, "report buscenter fault evt fail");
1099 }
1100 }
1101
CompleteLeaveLNN(LnnConnectionFsm * connFsm,const char * networkId,int32_t retCode)1102 static void CompleteLeaveLNN(LnnConnectionFsm *connFsm, const char *networkId, int32_t retCode)
1103 {
1104 LnnConntionInfo *connInfo = &connFsm->connInfo;
1105 NodeBasicInfo basic;
1106 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
1107 bool needReportOffline = false;
1108 ReportLeaveLNNResultEvt(connFsm, retCode);
1109 if (CheckDeadFlag(connFsm, true)) {
1110 LNN_LOGE(LNN_BUILDER, "deadFlag is true");
1111 return;
1112 }
1113 LnnFsmRemoveMessage(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_LNN_TIMEOUT);
1114 if (retCode == SOFTBUS_OK) {
1115 needReportOffline = UpdateLeaveToLedger(connFsm, networkId, &basic);
1116 LnnNotifyNodeStateChanged(&connInfo->addr);
1117 LnnNotifySingleOffLineEvent(&connInfo->addr, &basic);
1118 }
1119 NotifyLeaveResult(connFsm, networkId, retCode);
1120 if (needReportOffline) {
1121 LnnStopOfflineTimingByHeartbeat(networkId, connInfo->addr.type);
1122 LnnStopOfflineTimingBySleHb(networkId, connInfo->addr.type);
1123 LnnNotifyOnlineState(false, &basic);
1124 } else if (retCode == SOFTBUS_OK) {
1125 LnnNotifySingleOffLineEvent(&connInfo->addr, &basic);
1126 }
1127 NodeInfo info;
1128 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1129 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) == SOFTBUS_OK) {
1130 DeviceStateChangeProcess(info.deviceInfo.deviceUdid, connInfo->addr.type, false);
1131 }
1132 connInfo->flag &= ~LNN_CONN_INFO_FLAG_LEAVE_PASSIVE;
1133 connFsm->isDead = true;
1134 LnnNotifyAuthHandleLeaveLNN(connInfo->authHandle);
1135 LnnRequestCleanConnFsm(connFsm->id);
1136 LnnCleanTriggerSparkInfo(info.deviceInfo.deviceUdid, connInfo->addr.type);
1137 LNN_LOGI(LNN_BUILDER, "complete leave lnn, ready clean. [id=%{public}u]", connFsm->id);
1138 }
1139
OnJoinFail(LnnConnectionFsm * connFsm,int32_t retCode)1140 static int32_t OnJoinFail(LnnConnectionFsm *connFsm, int32_t retCode)
1141 {
1142 if (CheckDeadFlag(connFsm, true)) {
1143 return SOFTBUS_NETWORK_CONN_FSM_DEAD;
1144 }
1145 CompleteJoinLNN(connFsm, NULL, retCode);
1146 return SOFTBUS_OK;
1147 }
1148
TryCancelJoinProcedure(LnnConnectionFsm * connFsm)1149 static void TryCancelJoinProcedure(LnnConnectionFsm *connFsm)
1150 {
1151 if ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_LEAVE_AUTO) != 0) {
1152 CompleteJoinLNN(connFsm, NULL, SOFTBUS_NETWORK_JOIN_CANCELED);
1153 } else {
1154 NotifyJoinResult(connFsm, connFsm->connInfo.peerNetworkId, SOFTBUS_NETWORK_LEAVE_OFFLINE);
1155 }
1156 NotifyJoinExtResultProcess(connFsm, SOFTBUS_NETWORK_JOIN_CANCELED);
1157 }
1158
FilterRetrieveDeviceInfo(NodeInfo * info)1159 static void FilterRetrieveDeviceInfo(NodeInfo *info)
1160 {
1161 info->authChannelId[CONNECTION_ADDR_BLE][AUTH_AS_CLIENT_SIDE] = 0;
1162 info->authChannelId[CONNECTION_ADDR_BLE][AUTH_AS_SERVER_SIDE] = 0;
1163 info->AuthTypeValue = 0;
1164 LnnSetWiFiIp(info, LOCAL_IPV6_STR, USB_IF);
1165 LnnSetWiFiIp(info, LOCAL_IP, WLAN_IF);
1166 }
1167
LnnRecoveryBroadcastKey()1168 static int32_t LnnRecoveryBroadcastKey()
1169 {
1170 int32_t ret = LnnLoadLocalBroadcastCipherKeyPacked();
1171 if (ret != SOFTBUS_OK) {
1172 LNN_LOGE(LNN_BUILDER, "load BroadcastCipherInfo fail");
1173 return ret;
1174 }
1175 BroadcastCipherKey broadcastKey;
1176 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1177 do {
1178 ret = LnnGetLocalBroadcastCipherKeyPacked(&broadcastKey);
1179 if (ret != SOFTBUS_OK) {
1180 LNN_LOGE(LNN_BUILDER, "get local info failed");
1181 break;
1182 }
1183 ret = LnnSetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_KEY, broadcastKey.cipherInfo.key, SESSION_KEY_LENGTH);
1184 if (ret != SOFTBUS_OK) {
1185 LNN_LOGE(LNN_BUILDER, "set key failed");
1186 break;
1187 }
1188 ret = LnnSetLocalByteInfo(BYTE_KEY_BROADCAST_CIPHER_IV, broadcastKey.cipherInfo.iv, BROADCAST_IV_LEN);
1189 if (ret != SOFTBUS_OK) {
1190 LNN_LOGE(LNN_BUILDER, "set iv failed");
1191 break;
1192 }
1193 LNN_LOGI(LNN_BUILDER, "recovery broadcastKey success!");
1194 ret = SOFTBUS_OK;
1195 } while (0);
1196 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1197 LNN_LOGI(LNN_BUILDER, "recovery broadcastKey success!");
1198 return ret;
1199 }
1200
DfxRecordConnAuthStart(const AuthConnInfo * connInfo,LnnConnectionFsm * connFsm,uint32_t requestId)1201 static void DfxRecordConnAuthStart(const AuthConnInfo *connInfo, LnnConnectionFsm *connFsm, uint32_t requestId)
1202 {
1203 LnnEventExtra extra = { 0 };
1204 LnnEventExtraInit(&extra);
1205 extra.authRequestId = (int32_t)requestId;
1206
1207 if (connInfo != NULL) {
1208 extra.authLinkType = connInfo->type;
1209 }
1210 if (connFsm != NULL && IsValidString(connFsm->pkgName, PKG_NAME_SIZE_MAX - 1)) {
1211 extra.callerPkg = connFsm->pkgName;
1212 }
1213 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH, extra);
1214 }
1215
BleDirectOnline(LnnConntionInfo * connInfo,AuthConnInfo * authConn,NodeInfo * deviceInfo,bool dupOk)1216 static int32_t BleDirectOnline(LnnConntionInfo *connInfo, AuthConnInfo *authConn, NodeInfo *deviceInfo, bool dupOk)
1217 {
1218 int32_t ret;
1219 AuthHandle authHandle = { .authId = AUTH_INVALID_ID, .type = AUTH_LINK_TYPE_BLE };
1220 char udidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = {0};
1221 ret = ConvertBytesToHexString(udidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1,
1222 (const unsigned char *)connInfo->addr.info.ble.udidHash, HB_SHORT_UDID_HASH_LEN);
1223 char *anonyUdidHash = NULL;
1224 Anonymize(udidHash, &anonyUdidHash);
1225 LNN_LOGI(LNN_BUILDER, "join udidHash=%{public}s", AnonymizeWrapper(anonyUdidHash));
1226 AnonymizeFree(anonyUdidHash);
1227 if (ret == SOFTBUS_OK) {
1228 if ((dupOk || (LnnRetrieveDeviceInfoPacked(udidHash, deviceInfo) == SOFTBUS_OK &&
1229 LnnRecoveryBroadcastKey() == SOFTBUS_OK)) &&
1230 AuthRestoreAuthManager(udidHash, authConn, connInfo->requestId, deviceInfo,
1231 &authHandle.authId) == SOFTBUS_OK) {
1232 FilterRetrieveDeviceInfo(deviceInfo);
1233 LnnGetVerifyCallback()->onVerifyPassed(connInfo->requestId, authHandle, deviceInfo);
1234 return SOFTBUS_OK;
1235 }
1236 }
1237 return SOFTBUS_NETWORK_BLE_DIRECT_FAILED;
1238 }
1239
LnnConvertSessionAddrToAuthConnInfo(const ConnectionAddr * addr,AuthConnInfo * authConn)1240 static int32_t LnnConvertSessionAddrToAuthConnInfo(const ConnectionAddr *addr, AuthConnInfo *authConn)
1241 {
1242 if (addr == NULL || authConn == NULL) {
1243 LNN_LOGE(LNN_BUILDER, "invalid param.");
1244 return SOFTBUS_INVALID_PARAM;
1245 }
1246 authConn->type = AUTH_LINK_TYPE_SESSION;
1247 ConnIdCbInfo connIdCbInfo;
1248 (void)memset_s(&connIdCbInfo, sizeof(ConnIdCbInfo), 0, sizeof(ConnIdCbInfo));
1249 int32_t ret = GetConnIdCbInfoByAddr(addr, &connIdCbInfo);
1250 if (ret != SOFTBUS_OK) {
1251 LNN_LOGE(LNN_BUILDER, "get connIdCbInfo fail.");
1252 return ret;
1253 }
1254 if (strncpy_s(authConn->info.sessionInfo.udid, UDID_BUF_LEN, connIdCbInfo.udid, UDID_BUF_LEN) != EOK) {
1255 LNN_LOGE(LNN_BUILDER, "copy udid to authConn fail");
1256 return SOFTBUS_STRCPY_ERR;
1257 }
1258 authConn->info.sessionInfo.connId = connIdCbInfo.connId;
1259 return SOFTBUS_OK;
1260 }
1261
CheckConnFsmValid(LnnConnectionFsm * connFsm,LnnConntionInfo * connInfo)1262 static int32_t CheckConnFsmValid(LnnConnectionFsm *connFsm, LnnConntionInfo *connInfo)
1263 {
1264 if (CheckDeadFlag(connFsm, true)) {
1265 NotifyJoinResult(connFsm, NULL, SOFTBUS_NETWORK_CONN_FSM_DEAD);
1266 NotifyJoinExtResultProcess(connFsm, SOFTBUS_NETWORK_CONN_FSM_DEAD);
1267 return SOFTBUS_NETWORK_CONN_FSM_DEAD;
1268 }
1269 return SOFTBUS_OK;
1270 }
1271
CheckDupOk(LnnConnectionFsm * connFsm,NodeInfo * deviceInfo,bool * dupOk)1272 static void CheckDupOk(LnnConnectionFsm *connFsm, NodeInfo *deviceInfo, bool *dupOk)
1273 {
1274 if (connFsm->connInfo.dupInfo != NULL) {
1275 *deviceInfo = *connFsm->connInfo.dupInfo;
1276 *dupOk = true;
1277 SoftBusFree(connFsm->connInfo.dupInfo);
1278 connFsm->connInfo.dupInfo = NULL;
1279 LNN_LOGI(LNN_BUILDER, "join dup node info ok");
1280 }
1281 }
1282
FillDeviceKeyId(AuthVerifyParam * authVerifyParam,DeviceKeyId * deviceKeyId)1283 static void FillDeviceKeyId(AuthVerifyParam *authVerifyParam, DeviceKeyId *deviceKeyId)
1284 {
1285 if (deviceKeyId->hasDeviceKeyId) {
1286 authVerifyParam->deviceKeyId.localDeviceKeyId = deviceKeyId->localDeviceKeyId;
1287 authVerifyParam->deviceKeyId.remoteDeviceKeyId = deviceKeyId->remoteDeviceKeyId;
1288 authVerifyParam->deviceKeyId.hasDeviceKeyId = true;
1289 }
1290 }
1291
CheckDeviceKeyByPreLinkNode(LnnConntionInfo * connInfo,AuthVerifyParam * authVerifyParam)1292 static void CheckDeviceKeyByPreLinkNode(LnnConntionInfo *connInfo, AuthVerifyParam *authVerifyParam)
1293 {
1294 int32_t connId;
1295 int32_t rc = SOFTBUS_MEM_ERR;
1296 if (TransGetConnByChanId(connInfo->addr.info.session.channelId, connInfo->addr.info.session.type,
1297 &connId) != SOFTBUS_OK) {
1298 LNN_LOGE(LNN_STATE, "TransGetConnByChanId fail");
1299 return;
1300 }
1301 rc = AddToAuthPreLinkList(connInfo->requestId, connId, &connInfo->addr);
1302 if (rc != SOFTBUS_OK) {
1303 LNN_LOGE(LNN_STATE, "add to auth reuse key list fail");
1304 }
1305 FillDeviceKeyId(authVerifyParam, &connInfo->addr.deviceKeyId);
1306 }
1307
SetAuthVerifyParam(AuthVerifyParam * authVerifyParam,uint32_t requestId)1308 static void SetAuthVerifyParam(AuthVerifyParam *authVerifyParam, uint32_t requestId)
1309 {
1310 authVerifyParam->isFastAuth = true;
1311 authVerifyParam->module = AUTH_MODULE_LNN;
1312 authVerifyParam->requestId = requestId;
1313 authVerifyParam->deviceKeyId.hasDeviceKeyId = false;
1314 authVerifyParam->deviceKeyId.localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
1315 authVerifyParam->deviceKeyId.remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
1316 }
1317
OnJoinLNN(LnnConnectionFsm * connFsm)1318 static int32_t OnJoinLNN(LnnConnectionFsm *connFsm)
1319 {
1320 int32_t rc;
1321 AuthConnInfo authConn;
1322 LnnConntionInfo *connInfo = &connFsm->connInfo;
1323 if (CheckConnFsmValid(connFsm, connInfo) != SOFTBUS_OK) {
1324 return SOFTBUS_NETWORK_CONN_FSM_DEAD;
1325 }
1326 LNN_CHECK_AND_RETURN_RET_LOGW(connInfo->authHandle.authId <= 0, SOFTBUS_OK, LNN_BUILDER,
1327 "[id=%{public}u]join LNN is ongoing, waiting...", connFsm->id);
1328 LNN_LOGI(LNN_BUILDER, "begin join request, [id=%{public}u], peer%{public}s, isNeedConnect=%{public}d", connFsm->id,
1329 LnnPrintConnectionAddr(&connInfo->addr), connFsm->isNeedConnect);
1330 connInfo->requestId = AuthGenRequestId();
1331 AuthVerifyParam authVerifyParam;
1332 (void)memset_s(&authVerifyParam, sizeof(authVerifyParam), 0, sizeof(authVerifyParam));
1333 SetAuthVerifyParam(&authVerifyParam, connInfo->requestId);
1334 authVerifyParam.deviceTypeId = connFsm->connInfo.addr.deviceTypeId;
1335 if (connInfo->addr.type == CONNECTION_ADDR_SESSION) {
1336 rc = LnnConvertSessionAddrToAuthConnInfo(&connInfo->addr, &authConn);
1337 if (rc != SOFTBUS_OK) {
1338 LNN_LOGE(LNN_BUILDER, "convert session addr to auth conn info fail. [id=%{public}u]", connFsm->id);
1339 CompleteJoinLNN(connFsm, NULL, rc);
1340 return rc;
1341 }
1342 } else if (connInfo->addr.type == CONNECTION_ADDR_SESSION_WITH_KEY) {
1343 (void)LnnConvertAddrToAuthConnInfo(&connInfo->addr, &authConn);
1344 CheckDeviceKeyByPreLinkNode(connInfo, &authVerifyParam);
1345 } else {
1346 (void)LnnConvertAddrToAuthConnInfo(&connInfo->addr, &authConn);
1347 FillDeviceKeyId(&authVerifyParam, &connInfo->addr.deviceKeyId);
1348 }
1349 NodeInfo deviceInfo;
1350 (void)memset_s(&deviceInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1351 bool dupOk = false;
1352 CheckDupOk(connFsm, &deviceInfo, &dupOk);
1353 if (!connFsm->isNeedConnect && connInfo->addr.type == CONNECTION_ADDR_BLE) {
1354 // go to online
1355 if (BleDirectOnline(connInfo, &authConn, &deviceInfo, dupOk) == SOFTBUS_OK) {
1356 return SOFTBUS_OK;
1357 }
1358 }
1359 DfxRecordConnAuthStart(&authConn, connFsm, connInfo->requestId);
1360 rc = AuthStartVerify(&authConn, &authVerifyParam, LnnGetVerifyCallback());
1361 if (rc != SOFTBUS_OK) {
1362 LNN_LOGE(LNN_BUILDER, "auth verify device failed. [id=%{public}u]", connFsm->id);
1363 CompleteJoinLNN(connFsm, NULL, SOFTBUS_AUTH_START_VERIFY_FAIL);
1364 } else {
1365 LnnFsmPostMessageDelay(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT, NULL, JOIN_LNN_TIMEOUT_LEN);
1366 }
1367 LNN_LOGI(LNN_BUILDER, "verify request. [id=%{public}u], requestId=%{public}u", connFsm->id, connInfo->requestId);
1368 return rc;
1369 }
1370
LnnFillConnInfo(LnnConntionInfo * connInfo)1371 static int32_t LnnFillConnInfo(LnnConntionInfo *connInfo)
1372 {
1373 if (connInfo->nodeInfo == NULL) {
1374 LNN_LOGE(LNN_BUILDER, "nodeInfo is null");
1375 return SOFTBUS_INVALID_PARAM;
1376 }
1377 bool isAuthServer = false;
1378 SoftBusVersion version;
1379 NodeInfo *nodeInfo = connInfo->nodeInfo;
1380 nodeInfo->discoveryType = 1 << (uint32_t)LnnConvAddrTypeToDiscType(connInfo->addr.type);
1381 nodeInfo->authSeqNum = connInfo->authHandle.authId;
1382 (void)AuthGetServerSide(connInfo->authHandle.authId, &isAuthServer);
1383 nodeInfo->authChannelId[connInfo->addr.type][isAuthServer ? AUTH_AS_SERVER_SIDE : AUTH_AS_CLIENT_SIDE] =
1384 (int32_t)connInfo->authHandle.authId;
1385 nodeInfo->relation[connInfo->addr.type]++;
1386 int32_t ret = AuthGetVersion(connInfo->authHandle.authId, &version);
1387 if (ret != SOFTBUS_OK) {
1388 LNN_LOGE(LNN_BUILDER, "fill version fail");
1389 return ret;
1390 }
1391 connInfo->version = version;
1392 ret = AuthGetDeviceUuid(connInfo->authHandle.authId, nodeInfo->uuid, sizeof(nodeInfo->uuid));
1393 if (ret != SOFTBUS_OK || nodeInfo->uuid[0] == '\0') {
1394 LNN_LOGE(LNN_BUILDER, "fill uuid fail");
1395 return ret;
1396 }
1397 if (connInfo->addr.type == CONNECTION_ADDR_ETH || connInfo->addr.type == CONNECTION_ADDR_WLAN ||
1398 connInfo->addr.type == CONNECTION_ADDR_NCM) {
1399 int32_t ifnameIdx = (connInfo->addr.type == CONNECTION_ADDR_NCM) ? USB_IF : WLAN_IF;
1400 if (strcpy_s(nodeInfo->connectInfo.ifInfo[ifnameIdx].deviceIp, MAX_ADDR_LEN,
1401 connInfo->addr.info.ip.ip) != EOK) {
1402 LNN_LOGE(LNN_BUILDER, "fill deviceIp fail");
1403 return SOFTBUS_STRCPY_ERR;
1404 }
1405 }
1406 if (strcpy_s(connInfo->peerNetworkId, sizeof(connInfo->peerNetworkId), nodeInfo->networkId) != EOK) {
1407 LNN_LOGE(LNN_BUILDER, "fill networkId fail");
1408 return SOFTBUS_STRCPY_ERR;
1409 }
1410 return SOFTBUS_OK;
1411 }
1412
IsSupportFeatureByCapability(uint32_t feature,AuthCapability capaBit)1413 static bool IsSupportFeatureByCapability(uint32_t feature, AuthCapability capaBit)
1414 {
1415 return ((feature & (1 << (uint32_t)capaBit)) != 0);
1416 }
1417
CheckRemoteBasicInfoChanged(const NodeInfo * newNodeInfo)1418 bool CheckRemoteBasicInfoChanged(const NodeInfo *newNodeInfo)
1419 {
1420 if (newNodeInfo == NULL) {
1421 return false;
1422 }
1423 NodeInfo oldNodeInfo;
1424 if (memset_s(&oldNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo)) != EOK) {
1425 LNN_LOGE(LNN_BUILDER, "memset fail");
1426 return false;
1427 }
1428 if (LnnGetRemoteNodeInfoById(newNodeInfo->deviceInfo.deviceUdid, CATEGORY_UDID, &oldNodeInfo) != SOFTBUS_OK) {
1429 LNN_LOGE(LNN_BUILDER, "get remote node info fail");
1430 return false;
1431 }
1432 return IsBasicNodeInfoChanged(&oldNodeInfo, newNodeInfo, false);
1433 }
1434
FillBleAddr(ConnectionAddr * addr,const ConnectionAddr * connAddr,NodeInfo * nodeInfo)1435 static int32_t FillBleAddr(ConnectionAddr *addr, const ConnectionAddr *connAddr, NodeInfo *nodeInfo)
1436 {
1437 uint8_t hash[SHA_256_HASH_LEN] = { 0 };
1438 addr->type = CONNECTION_ADDR_BLE;
1439 if (memcpy_s(addr->info.ble.bleMac, BT_MAC_LEN, nodeInfo->connectInfo.macAddr,
1440 BT_MAC_LEN) != EOK) {
1441 LNN_LOGE(LNN_BUILDER, "bt mac memcpy to ble fail");
1442 return SOFTBUS_MEM_ERR;
1443 }
1444 if (SoftBusGenerateStrHash((uint8_t *)nodeInfo->deviceInfo.deviceUdid,
1445 strlen(nodeInfo->deviceInfo.deviceUdid), hash) != SOFTBUS_OK) {
1446 LNN_LOGE(LNN_BUILDER, "generate udid short hash fail.");
1447 return SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR;
1448 }
1449 if (memcpy_s(addr->info.ble.udidHash, UDID_HASH_LEN, hash, SHORT_UDID_HASH_LEN) != EOK) {
1450 LNN_LOGE(LNN_BUILDER, "memcpy udid hash fail");
1451 return SOFTBUS_MEM_ERR;
1452 }
1453 return SOFTBUS_OK;
1454 }
1455
UpdateDeviceDeviceName(NodeInfo * nodeInfo,NodeInfo * remoteInfo)1456 static void UpdateDeviceDeviceName(NodeInfo *nodeInfo, NodeInfo *remoteInfo)
1457 {
1458 if (strcmp(nodeInfo->deviceInfo.deviceName, remoteInfo->deviceInfo.deviceName) != 0) {
1459 if (!LnnSetDLDeviceInfoName(nodeInfo->deviceInfo.deviceUdid, nodeInfo->deviceInfo.deviceName)) {
1460 LNN_LOGE(LNN_BUILDER, "set device name to distributedLedger fail");
1461 return;
1462 }
1463 char *anonyOldName = NULL;
1464 char *anonyNewName = NULL;
1465 AnonymizeDeviceName(remoteInfo->deviceInfo.deviceName, &anonyOldName);
1466 AnonymizeDeviceName(nodeInfo->deviceInfo.deviceName, &anonyNewName);
1467 LNN_LOGI(LNN_BUILDER, "update deviceName=%{public}s -> %{public}s", AnonymizeWrapper(anonyOldName),
1468 AnonymizeWrapper(anonyNewName));
1469 AnonymizeFree(anonyOldName);
1470 AnonymizeFree(anonyNewName);
1471 }
1472 }
1473
ProcessBleOnline(NodeInfo * nodeInfo,const ConnectionAddr * connAddr,AuthCapability authCapability)1474 int32_t ProcessBleOnline(NodeInfo *nodeInfo, const ConnectionAddr *connAddr, AuthCapability authCapability)
1475 {
1476 if (nodeInfo == NULL || connAddr == NULL) {
1477 LNN_LOGE(LNN_BUILDER, "nodeInfo or connAddr is null");
1478 return SOFTBUS_INVALID_PARAM;
1479 }
1480 uint32_t localAuthCapability = 0;
1481 if (LnnGetLocalNumU32Info(NUM_KEY_AUTH_CAP, &localAuthCapability) != SOFTBUS_OK) {
1482 LNN_LOGE(LNN_BUILDER, "get local auth capability fail");
1483 return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
1484 }
1485 NodeInfo remoteInfo;
1486 if (!IsSupportFeatureByCapability(nodeInfo->authCapacity, authCapability) ||
1487 !IsSupportFeatureByCapability(localAuthCapability, authCapability)) {
1488 LNN_LOGI(LNN_BUILDER, "local or remote not support, no need to go online");
1489 return SOFTBUS_FUNC_NOT_SUPPORT;
1490 }
1491 if (LnnGetRemoteNodeInfoById(nodeInfo->deviceInfo.deviceUdid, CATEGORY_UDID,
1492 &remoteInfo) == SOFTBUS_OK && LnnHasDiscoveryType(&remoteInfo, DISCOVERY_TYPE_BLE) &&
1493 !CheckRemoteBasicInfoChanged(nodeInfo)) {
1494 if (authCapability == BIT_SUPPORT_SESSION_DUP_BLE) {
1495 LnnNotifyStateForSession(nodeInfo->deviceInfo.deviceUdid, SOFTBUS_OK);
1496 }
1497 UpdateDeviceDeviceName(nodeInfo, &remoteInfo);
1498 LNN_LOGI(LNN_BUILDER, "ble has online, no need to go online");
1499 return SOFTBUS_OK;
1500 }
1501 ConnectionAddr addr;
1502 (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
1503 int32_t rc = FillBleAddr(&addr, connAddr, nodeInfo);
1504 if (rc != SOFTBUS_OK) {
1505 LNN_LOGE(LNN_BUILDER, "fill ble addr fail");
1506 return rc;
1507 }
1508 bool isSession = (authCapability == BIT_SUPPORT_SESSION_DUP_BLE);
1509 rc = JoinLnnWithNodeInfo(&addr, nodeInfo, isSession);
1510 if (rc == SOFTBUS_OK) {
1511 LNN_LOGI(LNN_BUILDER, "join with node info success");
1512 } else {
1513 LNN_LOGE(LNN_BUILDER, "join with node info fail");
1514 }
1515 return rc;
1516 }
1517
ProcessBleOnlineForSession(LnnConnectionFsm * connFsm)1518 static void ProcessBleOnlineForSession(LnnConnectionFsm *connFsm)
1519 {
1520 LnnConntionInfo *connInfo = &connFsm->connInfo;
1521 int32_t retCode = ProcessBleOnline(connInfo->nodeInfo, &(connInfo->addr), BIT_SUPPORT_SESSION_DUP_BLE);
1522 if (retCode != SOFTBUS_OK) {
1523 LnnNotifyStateForSession(connFsm->connInfo.nodeInfo->deviceInfo.deviceUdid, retCode);
1524 }
1525 LNN_LOGI(LNN_BUILDER, "session online not need notify.");
1526 AuthRemoveAuthManagerByAuthHandle(connInfo->authHandle);
1527 LnnFsmRemoveMessage(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN_TIMEOUT);
1528 (void)LnnRequestCleanConnFsm(connFsm->id);
1529 }
1530
ProcessBleOnlineForAuthPreLink(LnnConnectionFsm * connFsm)1531 static void ProcessBleOnlineForAuthPreLink(LnnConnectionFsm *connFsm)
1532 {
1533 ConnectionAddr connAddr;
1534 connAddr.type = CONNECTION_ADDR_BR;
1535 if (connFsm->connInfo.nodeInfo == NULL) {
1536 LNN_LOGE(LNN_BUILDER, " node info is null");
1537 return;
1538 }
1539 if (memcpy_s(connAddr.info.br.brMac, BT_MAC_LEN, connFsm->connInfo.nodeInfo->connectInfo.macAddr,
1540 BT_MAC_LEN) != EOK) {
1541 LNN_LOGE(LNN_BUILDER, "copy br mac failed");
1542 return;
1543 }
1544 LNN_LOGI(LNN_BUILDER, "start ble online");
1545 ProcessBleOnline(connFsm->connInfo.nodeInfo, &connAddr, BIT_SUPPORT_SESSION_DUP_BLE);
1546 }
1547
OnAuthDone(LnnConnectionFsm * connFsm,int32_t * retCode)1548 static int32_t OnAuthDone(LnnConnectionFsm *connFsm, int32_t *retCode)
1549 {
1550 LnnConntionInfo *connInfo = &connFsm->connInfo;
1551
1552 if (retCode == NULL) {
1553 LNN_LOGE(LNN_BUILDER, "auth result is null. [id=%{public}u]", connFsm->id);
1554 return SOFTBUS_INVALID_PARAM;
1555 }
1556 if (CheckDeadFlag(connFsm, true)) {
1557 SoftBusFree(retCode);
1558 return SOFTBUS_NETWORK_CONN_FSM_DEAD;
1559 }
1560
1561 LNN_LOGI(LNN_BUILDER,
1562 "[id=%{public}u] auth done, authId=%{public}" PRId64 ", result=%{public}d, connType=%{public}d",
1563 connFsm->id, connInfo->authHandle.authId, *retCode, connFsm->connInfo.addr.type);
1564 if (*retCode == SOFTBUS_OK) {
1565 LNN_LOGI(LNN_BUILDER,
1566 "[id=%{public}u] auth passed, authId=%{public}" PRId64, connFsm->id, connInfo->authHandle.authId);
1567 (void)LnnFillConnInfo(connInfo);
1568 AuthPreLinkNode tmpNode;
1569 if (connInfo->nodeInfo != NULL) {
1570 if (connInfo->addr.type == CONNECTION_ADDR_BR) {
1571 (void)ProcessBleOnline(connInfo->nodeInfo, &(connInfo->addr), BIT_SUPPORT_BR_DUP_BLE);
1572 } else if (connInfo->addr.type == CONNECTION_ADDR_SESSION_WITH_KEY &&
1573 FindAuthPreLinkNodeByUuid(connInfo->nodeInfo->uuid, &tmpNode) == SOFTBUS_OK) {
1574 DelAuthPreLinkByUuid(connInfo->nodeInfo->uuid);
1575 LNN_LOGI(LNN_BUILDER, "delete auth pre link node by uuid");
1576 ProcessBleOnlineForAuthPreLink(connFsm);
1577 } else if (connInfo->addr.type == CONNECTION_ADDR_SESSION) {
1578 ProcessBleOnlineForSession(connFsm);
1579 SoftBusFree(retCode);
1580 return SOFTBUS_OK;
1581 }
1582 }
1583 LnnFsmTransactState(&connFsm->fsm, g_states + STATE_CLEAN_INVALID_CONN_INDEX);
1584 LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_INVALID_CONN, NULL);
1585 } else {
1586 LNN_LOGE(LNN_BUILDER,
1587 "[id=%{public}u] auth failed, authId=%{public}" PRId64 ", requestId=%{public}u, reason=%{public}d, "
1588 "connType=%{public}d",
1589 connFsm->id, connInfo->authHandle.authId, connInfo->requestId, *retCode, connFsm->connInfo.addr.type);
1590 CompleteJoinLNN(connFsm, NULL, *retCode);
1591 }
1592 SoftBusFree(retCode);
1593 return SOFTBUS_OK;
1594 }
1595
AuthStateProcess(FsmStateMachine * fsm,int32_t msgType,void * para)1596 static bool AuthStateProcess(FsmStateMachine *fsm, int32_t msgType, void *para)
1597 {
1598 LnnConnectionFsm *connFsm = NULL;
1599
1600 if (!CheckStateMsgCommonArgs(fsm)) {
1601 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
1602 FreeUnhandledMessage(msgType, para);
1603 return false;
1604 }
1605 connFsm = TO_CONN_FSM(fsm);
1606
1607 LNN_LOGI(LNN_BUILDER, "auth process. [id=%{public}u], msgType=%{public}d", connFsm->id, msgType);
1608 switch (msgType) {
1609 case FSM_MSG_TYPE_JOIN_LNN:
1610 OnJoinLNN(connFsm);
1611 break;
1612 case FSM_MSG_TYPE_AUTH_DONE:
1613 OnAuthDone(connFsm, (int32_t *)para);
1614 break;
1615 case FSM_MSG_TYPE_DISCONNECT:
1616 OnJoinFail(connFsm, SOFTBUS_NETWORK_AUTH_DISCONNECT);
1617 break;
1618 case FSM_MSG_TYPE_JOIN_LNN_TIMEOUT:
1619 OnJoinFail(connFsm, SOFTBUS_NETWORK_JOIN_TIMEOUT);
1620 break;
1621 case FSM_MSG_TYPE_LEAVE_LNN:
1622 TryCancelJoinProcedure(connFsm);
1623 break;
1624 default:
1625 FreeUnhandledMessage(msgType, para);
1626 return false;
1627 }
1628 return true;
1629 }
1630
IsBasicNodeInfoChanged(const NodeInfo * oldNodeInfo,const NodeInfo * newNodeInfo,bool isUpdate)1631 static bool IsBasicNodeInfoChanged(const NodeInfo *oldNodeInfo, const NodeInfo *newNodeInfo, bool isUpdate)
1632 {
1633 if (strcmp(newNodeInfo->networkId, oldNodeInfo->networkId) != 0) {
1634 char *newNetworkId = NULL;
1635 char *oldNetworkId = NULL;
1636 Anonymize(newNodeInfo->networkId, &newNetworkId);
1637 Anonymize(oldNodeInfo->networkId, &oldNetworkId);
1638 LNN_LOGI(LNN_BUILDER, "networkId changed %{public}s -> %{public}s",
1639 AnonymizeWrapper(oldNetworkId), AnonymizeWrapper(newNetworkId));
1640 AnonymizeFree(newNetworkId);
1641 AnonymizeFree(oldNetworkId);
1642 if (isUpdate) {
1643 (void)LnnUpdateNetworkId(newNodeInfo);
1644 }
1645 return true;
1646 }
1647 if (strcmp(newNodeInfo->uuid, oldNodeInfo->uuid) != 0) {
1648 char *newUuid = NULL;
1649 char *oldUuid = NULL;
1650 Anonymize(newNodeInfo->uuid, &newUuid);
1651 Anonymize(oldNodeInfo->uuid, &oldUuid);
1652 LNN_LOGI(LNN_BUILDER, "uuid changed %{public}s -> %{public}s",
1653 AnonymizeWrapper(oldUuid), AnonymizeWrapper(newUuid));
1654 AnonymizeFree(newUuid);
1655 AnonymizeFree(oldUuid);
1656 return true;
1657 }
1658 if (strcmp(newNodeInfo->softBusVersion, oldNodeInfo->softBusVersion) != 0) {
1659 char *newSoftBusVersion = NULL;
1660 char *oldSoftBusVersion = NULL;
1661 Anonymize(newNodeInfo->softBusVersion, &newSoftBusVersion);
1662 Anonymize(oldNodeInfo->softBusVersion, &oldSoftBusVersion);
1663 LNN_LOGI(LNN_BUILDER, "uuid changed %{public}s -> %{public}s",
1664 AnonymizeWrapper(oldSoftBusVersion), AnonymizeWrapper(newSoftBusVersion));
1665 AnonymizeFree(newSoftBusVersion);
1666 AnonymizeFree(oldSoftBusVersion);
1667 }
1668 return false;
1669 }
1670
IsWifiConnectInfoChanged(const NodeInfo * oldNodeInfo,const NodeInfo * newNodeInfo,ConnectionAddrType type)1671 static bool IsWifiConnectInfoChanged(const NodeInfo *oldNodeInfo, const NodeInfo *newNodeInfo, ConnectionAddrType type)
1672 {
1673 if (!LnnHasDiscoveryType(oldNodeInfo, DISCOVERY_TYPE_WIFI) &&
1674 !LnnHasDiscoveryType(oldNodeInfo, DISCOVERY_TYPE_USB)) {
1675 LNN_LOGI(LNN_BUILDER, "oldNodeInfo not have wifi or usb, discoveryType=%{public}u", oldNodeInfo->discoveryType);
1676 return false;
1677 }
1678 int32_t ifIdx = (type == CONNECTION_ADDR_NCM) ? USB_IF : WLAN_IF;
1679 if (strcmp(newNodeInfo->connectInfo.ifInfo[ifIdx].deviceIp,
1680 oldNodeInfo->connectInfo.ifInfo[ifIdx].deviceIp) != 0) {
1681 char *newIp = NULL;
1682 char *oldIp = NULL;
1683 Anonymize(newNodeInfo->connectInfo.ifInfo[ifIdx].deviceIp, &newIp);
1684 Anonymize(oldNodeInfo->connectInfo.ifInfo[ifIdx].deviceIp, &oldIp);
1685 LNN_LOGI(LNN_BUILDER, "peer ip changed %{public}s -> %{public}s",
1686 AnonymizeWrapper(oldIp), AnonymizeWrapper(newIp));
1687 AnonymizeFree(newIp);
1688 AnonymizeFree(oldIp);
1689 return true;
1690 }
1691 if (newNodeInfo->connectInfo.ifInfo[ifIdx].authPort != oldNodeInfo->connectInfo.ifInfo[ifIdx].authPort) {
1692 LNN_LOGI(LNN_BUILDER, "peer authPort changed");
1693 return true;
1694 }
1695 if (newNodeInfo->connectInfo.ifInfo[ifIdx].proxyPort != oldNodeInfo->connectInfo.ifInfo[ifIdx].proxyPort) {
1696 LNN_LOGI(LNN_BUILDER, "peer proxyPort changed");
1697 return true;
1698 }
1699 if (newNodeInfo->connectInfo.ifInfo[ifIdx].sessionPort != oldNodeInfo->connectInfo.ifInfo[ifIdx].sessionPort) {
1700 LNN_LOGI(LNN_BUILDER, "peer sessionPort changed");
1701 return true;
1702 }
1703 return false;
1704 }
1705
IsNodeInfoChanged(const LnnConnectionFsm * connFsm,const NodeInfo * oldNodeInfo,const NodeInfo * newNodeInfo,ConnectionAddrType * type)1706 static bool IsNodeInfoChanged(const LnnConnectionFsm *connFsm, const NodeInfo *oldNodeInfo,
1707 const NodeInfo *newNodeInfo, ConnectionAddrType *type)
1708 {
1709 if (IsBasicNodeInfoChanged(oldNodeInfo, newNodeInfo, true)) {
1710 *type = CONNECTION_ADDR_MAX;
1711 return true;
1712 }
1713 if (connFsm->connInfo.addr.type == CONNECTION_ADDR_ETH || connFsm->connInfo.addr.type == CONNECTION_ADDR_WLAN ||
1714 connFsm->connInfo.addr.type == CONNECTION_ADDR_NCM) {
1715 if (IsWifiConnectInfoChanged(oldNodeInfo, newNodeInfo, connFsm->connInfo.addr.type)) {
1716 *type = connFsm->connInfo.addr.type;
1717 return true;
1718 }
1719 }
1720 return false;
1721 }
1722
LnnIsNeedCleanConnectionFsm(const NodeInfo * nodeInfo,ConnectionAddrType type)1723 bool LnnIsNeedCleanConnectionFsm(const NodeInfo *nodeInfo, ConnectionAddrType type)
1724 {
1725 NodeInfo oldNodeInfo ;
1726 (void)memset_s(&oldNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1727
1728 int32_t ret = LnnGetRemoteNodeInfoById(nodeInfo->deviceInfo.deviceUdid, CATEGORY_UDID, &oldNodeInfo);
1729 if (ret != SOFTBUS_OK || !LnnIsNodeOnline(&oldNodeInfo)) {
1730 LNN_LOGW(LNN_BUILDER, "device is not online, ret=%{public}d", ret);
1731 return false;
1732 }
1733 if (IsBasicNodeInfoChanged(&oldNodeInfo, nodeInfo, false)) {
1734 return true;
1735 }
1736 if (type == CONNECTION_ADDR_ETH || type == CONNECTION_ADDR_WLAN || type == CONNECTION_ADDR_NCM) {
1737 if (IsWifiConnectInfoChanged(&oldNodeInfo, nodeInfo, type)) {
1738 return true;
1739 }
1740 }
1741 return false;
1742 }
1743
IsSameIpOnlineDevice(LnnConntionInfo * connInfo,NodeInfo nodeInfo)1744 static bool IsSameIpOnlineDevice(LnnConntionInfo *connInfo, NodeInfo nodeInfo)
1745 {
1746 if (LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_WIFI) &&
1747 (nodeInfo.connectInfo.ifInfo[WLAN_IF].deviceIp[0] != '\0') &&
1748 strcmp(nodeInfo.connectInfo.ifInfo[WLAN_IF].deviceIp, connInfo->addr.info.ip.ip) == 0 &&
1749 strcmp(nodeInfo.deviceInfo.deviceUdid, connInfo->nodeInfo->deviceInfo.deviceUdid) != 0) {
1750 return true;
1751 }
1752 return false;
1753 }
1754
LeaveSameIpOnlineDevice(LnnConntionInfo * connInfo)1755 static void LeaveSameIpOnlineDevice(LnnConntionInfo *connInfo)
1756 {
1757 int32_t infoNum = 0;
1758 NodeBasicInfo *info = NULL;
1759 if (LnnGetAllOnlineNodeInfo(&info, &infoNum) != SOFTBUS_OK) {
1760 LNN_LOGE(LNN_BUILDER, "get online node info failed");
1761 return;
1762 }
1763 if (info == NULL || infoNum == 0) {
1764 LNN_LOGE(LNN_BUILDER, "get online node is 0");
1765 return;
1766 }
1767 NodeInfo nodeInfo;
1768 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1769 for (int32_t i = 0; i < infoNum; ++i) {
1770 if (LnnGetRemoteNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID, &nodeInfo) == SOFTBUS_OK &&
1771 IsSameIpOnlineDevice(connInfo, nodeInfo)) {
1772 char *anonyNetworkId = NULL;
1773 Anonymize(info[i].networkId, &anonyNetworkId);
1774 LNN_LOGI(
1775 LNN_BUILDER, "need old same ip device offline, networkId=%{public}s", AnonymizeWrapper(anonyNetworkId));
1776 AnonymizeFree(anonyNetworkId);
1777 LnnRequestLeaveSpecific(info[i].networkId, CONNECTION_ADDR_WLAN);
1778 SoftBusFree(info);
1779 return;
1780 }
1781 }
1782 SoftBusFree(info);
1783 }
1784
OnLeaveInvalidConn(LnnConnectionFsm * connFsm)1785 static void OnLeaveInvalidConn(LnnConnectionFsm *connFsm)
1786 {
1787 LnnConntionInfo *connInfo = &connFsm->connInfo;
1788 if (connInfo->nodeInfo == NULL) {
1789 return;
1790 }
1791 NodeInfo oldNodeInfo;
1792 (void)memset_s(&oldNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1793 NodeInfo *newNodeInfo = connInfo->nodeInfo;
1794 ConnectionAddrType addrType;
1795 if (connFsm->connInfo.addr.type == CONNECTION_ADDR_WLAN) {
1796 LeaveSameIpOnlineDevice(connInfo);
1797 }
1798 int32_t ret = LnnGetRemoteNodeInfoById(connInfo->nodeInfo->deviceInfo.deviceUdid, CATEGORY_UDID, &oldNodeInfo);
1799 if (CheckDeadFlag(connFsm, true)) {
1800 return;
1801 }
1802 if (ret == SOFTBUS_OK && LnnIsNodeOnline(&oldNodeInfo)) {
1803 if (IsNodeInfoChanged(connFsm, &oldNodeInfo, newNodeInfo, &addrType)) {
1804 LNN_LOGI(LNN_BUILDER, "node info changed, ready clean invalid connection. [id=%{public}u]",
1805 connFsm->id);
1806 LnnRequestLeaveInvalidConn(oldNodeInfo.networkId, addrType, newNodeInfo->networkId);
1807 return;
1808 }
1809 }
1810 LNN_LOGI(LNN_BUILDER, "no need clean invalid connection fsm. [id=%{public}u]", connFsm->id);
1811 LnnFsmTransactState(&connFsm->fsm, g_states + STATE_ONLINE_INDEX);
1812 }
1813
CleanInvalidConnStateProcess(FsmStateMachine * fsm,int32_t msgType,void * para)1814 static bool CleanInvalidConnStateProcess(FsmStateMachine *fsm, int32_t msgType, void *para)
1815 {
1816 LnnConnectionFsm *connFsm = NULL;
1817
1818 if (!CheckStateMsgCommonArgs(fsm)) {
1819 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
1820 FreeUnhandledMessage(msgType, para);
1821 return false;
1822 }
1823 connFsm = TO_CONN_FSM(fsm);
1824
1825 LNN_LOGI(LNN_BUILDER, "clean invalid state process message. [id=%{public}u], msgType=%{public}d",
1826 connFsm->id, msgType);
1827 switch (msgType) {
1828 case FSM_MSG_TYPE_LEAVE_LNN:
1829 TryCancelJoinProcedure(connFsm);
1830 break;
1831 case FSM_MSG_TYPE_NOT_TRUSTED:
1832 OnJoinFail(connFsm, SOFTBUS_NETWORK_DEV_NOT_TRUST);
1833 break;
1834 case FSM_MSG_TYPE_DISCONNECT:
1835 OnJoinFail(connFsm, SOFTBUS_NETWORK_AUTH_DISCONNECT);
1836 break;
1837 case FSM_MSG_TYPE_LEAVE_INVALID_CONN:
1838 OnLeaveInvalidConn(connFsm);
1839 break;
1840 case FSM_MSG_TYPE_INITIATE_ONLINE:
1841 LnnFsmTransactState(&connFsm->fsm, g_states + STATE_ONLINE_INDEX);
1842 break;
1843 case FSM_MSG_TYPE_JOIN_LNN_TIMEOUT:
1844 OnJoinFail(connFsm, SOFTBUS_NETWORK_JOIN_TIMEOUT);
1845 break;
1846 default:
1847 FreeUnhandledMessage(msgType, para);
1848 return false;
1849 }
1850 return true;
1851 }
1852
StartSparkGroupCreation(const ConnectionAddr * addr)1853 static void StartSparkGroupCreation(const ConnectionAddr *addr)
1854 {
1855 if (addr->type != CONNECTION_ADDR_BLE) {
1856 return;
1857 }
1858 TriggerSparkGroupBuildPacked(SPARK_GROUP_DELAY_TIME_MS);
1859 }
1860
OnlineStateEnter(FsmStateMachine * fsm)1861 static void OnlineStateEnter(FsmStateMachine *fsm)
1862 {
1863 LnnConnectionFsm *connFsm = NULL;
1864
1865 if (!CheckStateMsgCommonArgs(fsm)) {
1866 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
1867 return;
1868 }
1869 connFsm = TO_CONN_FSM(fsm);
1870 bool isNodeInfoValid = (connFsm->connInfo.nodeInfo != NULL);
1871 char *anonyUdid = NULL;
1872 char *anonyUuid = NULL;
1873 char *anonyNetworkId = NULL;
1874 char *anonyDeviceName = NULL;
1875 Anonymize(connFsm->connInfo.peerNetworkId, &anonyNetworkId);
1876 if (isNodeInfoValid) {
1877 Anonymize(connFsm->connInfo.nodeInfo->deviceInfo.deviceUdid, &anonyUdid);
1878 Anonymize(connFsm->connInfo.nodeInfo->uuid, &anonyUuid);
1879 AnonymizeDeviceName(connFsm->connInfo.nodeInfo->deviceInfo.deviceName, &anonyDeviceName);
1880 }
1881 LNN_LOGI(LNN_BUILDER,
1882 "online state enter. [id=%{public}u], networkId=%{public}s, udid=%{public}s, "
1883 "uuid=%{public}s, deviceName=%{public}s, peer%{public}s",
1884 connFsm->id, AnonymizeWrapper(anonyNetworkId), isNodeInfoValid ? AnonymizeWrapper(anonyUdid) : "",
1885 isNodeInfoValid ? AnonymizeWrapper(anonyUuid) : "",
1886 isNodeInfoValid ? AnonymizeWrapper(anonyDeviceName) : "",
1887 LnnPrintConnectionAddr(&connFsm->connInfo.addr));
1888 if (isNodeInfoValid) {
1889 AnonymizeFree(anonyUdid);
1890 AnonymizeFree(anonyUuid);
1891 AnonymizeFree(anonyDeviceName);
1892 } else {
1893 LNN_LOGI(LNN_BUILDER,
1894 "online state enter. [id=%{public}u], networkId=%{public}s, peer%{public}s",
1895 connFsm->id, AnonymizeWrapper(anonyNetworkId), LnnPrintConnectionAddr(&connFsm->connInfo.addr));
1896 }
1897 AnonymizeFree(anonyNetworkId);
1898 LnnNotifyOOBEStateChangeEvent(SOFTBUS_FACK_OOBE_END);
1899 if (CheckDeadFlag(connFsm, true)) {
1900 return;
1901 }
1902 int32_t ret = IsRepeatDeviceId(connFsm->connInfo.nodeInfo) ? SOFTBUS_NETWORK_REPEATED_DEVICEID : SOFTBUS_OK;
1903 CompleteJoinLNN(connFsm, connFsm->connInfo.peerNetworkId, ret);
1904 StartSparkGroupCreation(&connFsm->connInfo.addr);
1905 }
1906
OnJoinLNNInOnline(LnnConnectionFsm * connFsm)1907 static void OnJoinLNNInOnline(LnnConnectionFsm *connFsm)
1908 {
1909 LnnConntionInfo *connInfo = &connFsm->connInfo;
1910
1911 LNN_LOGI(LNN_BUILDER, "request addr is already online. [id=%{public}u]", connFsm->id);
1912 NotifyJoinResult(connFsm, connInfo->peerNetworkId, SOFTBUS_OK);
1913 }
1914
LeaveLNNInOnline(LnnConnectionFsm * connFsm)1915 static void LeaveLNNInOnline(LnnConnectionFsm *connFsm)
1916 {
1917 LNN_LOGI(LNN_BUILDER, "transact to leaving state. [id=%{public}u]", connFsm->id);
1918 if (CheckDeadFlag(connFsm, true)) {
1919 return;
1920 }
1921 LnnFsmTransactState(&connFsm->fsm, g_states + STATE_LEAVING_INDEX);
1922 }
1923
OnForceJoinLNNInOnline(LnnConnectionFsm * connFsm)1924 static void OnForceJoinLNNInOnline(LnnConnectionFsm *connFsm)
1925 {
1926 AuthConnInfo authConn;
1927 LnnConntionInfo *connInfo = &connFsm->connInfo;
1928 if (CheckDeadFlag(connFsm, true)) {
1929 NotifyJoinResult(connFsm, NULL, SOFTBUS_NETWORK_CONN_FSM_DEAD);
1930 return;
1931 }
1932 connInfo->requestId = AuthGenRequestId();
1933 AuthVerifyParam authVerifyParam = {
1934 .isFastAuth = true, .module = AUTH_MODULE_LNN, .requestId = connInfo->requestId,
1935 .deviceKeyId.hasDeviceKeyId = false, .deviceKeyId.localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID,
1936 .deviceKeyId.remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID,
1937 };
1938 authVerifyParam.forceJoinInfo.isForceJoin = true;
1939 authVerifyParam.forceJoinInfo.addr = connInfo->addr;
1940 if (strcpy_s(authVerifyParam.forceJoinInfo.networkId, NETWORK_ID_BUF_LEN, connInfo->peerNetworkId) != EOK) {
1941 LNN_LOGE(LNN_BUILDER, "strcpy networkId fail");
1942 NotifyJoinResult(connFsm, NULL, SOFTBUS_NETWORK_JOIN_REQUEST_ERR);
1943 return;
1944 }
1945 (void)LnnConvertAddrToAuthConnInfo(&connInfo->addr, &authConn);
1946 if (AuthStartVerify(&authConn, &authVerifyParam, LnnGetReAuthVerifyCallback()) != SOFTBUS_OK) {
1947 LNN_LOGE(LNN_BUILDER, "AuthStartVerify error");
1948 NotifyJoinResult(connFsm, NULL, SOFTBUS_AUTH_START_VERIFY_FAIL);
1949 }
1950 }
1951
OnlineStateProcess(FsmStateMachine * fsm,int32_t msgType,void * para)1952 static bool OnlineStateProcess(FsmStateMachine *fsm, int32_t msgType, void *para)
1953 {
1954 LnnConnectionFsm *connFsm = NULL;
1955
1956 if (!CheckStateMsgCommonArgs(fsm)) {
1957 FreeUnhandledMessage(msgType, para);
1958 return false;
1959 }
1960 connFsm = TO_CONN_FSM(fsm);
1961
1962 LNN_LOGI(LNN_BUILDER, "online process message. [id=%{public}u], msgType=%{public}d", connFsm->id, msgType);
1963 switch (msgType) {
1964 case FSM_MSG_TYPE_JOIN_LNN:
1965 OnJoinLNNInOnline(connFsm);
1966 break;
1967 case FSM_MSG_TYPE_FORCE_JOIN_LNN:
1968 OnForceJoinLNNInOnline(connFsm);
1969 break;
1970 case FSM_MSG_TYPE_LEAVE_LNN:
1971 case FSM_MSG_TYPE_NOT_TRUSTED:
1972 case FSM_MSG_TYPE_DISCONNECT:
1973 LeaveLNNInOnline(connFsm);
1974 break;
1975 default:
1976 FreeUnhandledMessage(msgType, para);
1977 return false;
1978 }
1979 return true;
1980 }
1981
SyncBrOffline(const LnnConnectionFsm * connFsm)1982 static int32_t SyncBrOffline(const LnnConnectionFsm *connFsm)
1983 {
1984 int16_t code;
1985 uint32_t combinedInt;
1986 char uuid[UUID_BUF_LEN];
1987
1988 if (connFsm->connInfo.addr.type != CONNECTION_ADDR_BR) {
1989 LNN_LOGI(LNN_BUILDER, "just br need send offline");
1990 return SOFTBUS_NETWORK_LEAVE_OFFLINE;
1991 }
1992 if (!((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_LEAVE_REQUEST) != 0)) {
1993 LNN_LOGI(LNN_BUILDER, "just leave lnn request need send offline");
1994 return SOFTBUS_NETWORK_LEAVE_OFFLINE;
1995 }
1996 (void)LnnConvertDlId(connFsm->connInfo.peerNetworkId, CATEGORY_NETWORK_ID, CATEGORY_UUID, uuid, UUID_BUF_LEN);
1997 code = LnnGetCnnCode(uuid, DISCOVERY_TYPE_BR);
1998 if (code == INVALID_CONNECTION_CODE_VALUE) {
1999 LNN_LOGE(LNN_BUILDER, "uuid not exist!");
2000 return SOFTBUS_INVALID_PARAM;
2001 }
2002 combinedInt = ((uint16_t)code << CONN_CODE_SHIFT) | ((uint16_t)DISCOVERY_TYPE_BR & DISCOVERY_TYPE_MASK);
2003 combinedInt = SoftBusHtoNl(combinedInt);
2004 LNN_LOGI(LNN_BUILDER, "GetOfflineMsg combinedInt=0x%{public}04x", combinedInt);
2005 if (LnnSendSyncInfoMsg(LNN_INFO_TYPE_OFFLINE, connFsm->connInfo.peerNetworkId,
2006 (uint8_t *)&combinedInt, sizeof(int32_t), LnnSyncOfflineComplete) != SOFTBUS_OK) {
2007 LNN_LOGE(LNN_BUILDER, "send sync offline fail");
2008 return SOFTBUS_NETWORK_SEND_SYNC_INFO_FAILED;
2009 }
2010 return SOFTBUS_OK;
2011 }
2012
LeavingStateEnter(FsmStateMachine * fsm)2013 static void LeavingStateEnter(FsmStateMachine *fsm)
2014 {
2015 LnnConnectionFsm *connFsm = NULL;
2016 int32_t rc;
2017 LnnConntionInfo *connInfo = NULL;
2018
2019 if (!CheckStateMsgCommonArgs(fsm)) {
2020 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2021 return;
2022 }
2023 connFsm = TO_CONN_FSM(fsm);
2024 connInfo = &connFsm->connInfo;
2025
2026 bool isNodeInfoValid = (connFsm->connInfo.nodeInfo != NULL);
2027 char *anonyUdid = NULL;
2028 char *anonyNetworkId = NULL;
2029 char *anonyDeviceName = NULL;
2030 Anonymize(connFsm->connInfo.peerNetworkId, &anonyNetworkId);
2031 if (isNodeInfoValid) {
2032 Anonymize(connFsm->connInfo.nodeInfo->deviceInfo.deviceUdid, &anonyUdid);
2033 AnonymizeDeviceName(connFsm->connInfo.nodeInfo->deviceInfo.deviceName, &anonyDeviceName);
2034 }
2035 DelUserKeyByNetworkId(connFsm->connInfo.peerNetworkId);
2036 LNN_LOGI(LNN_BUILDER,
2037 "leaving state enter. [id=%{public}u], networkId=%{public}s, udid=%{public}s, deviceName=%{public}s, "
2038 "peer%{public}s",
2039 connFsm->id, AnonymizeWrapper(anonyNetworkId), isNodeInfoValid ? AnonymizeWrapper(anonyUdid) : "",
2040 isNodeInfoValid ? AnonymizeWrapper(anonyDeviceName) : "",
2041 LnnPrintConnectionAddr(&connFsm->connInfo.addr));
2042 if (isNodeInfoValid) {
2043 AnonymizeFree(anonyUdid);
2044 AnonymizeFree(anonyDeviceName);
2045 } else {
2046 LNN_LOGI(LNN_BUILDER,
2047 "leaving state enter. [id=%{public}u], networkId=%{public}s, peer%{public}s",
2048 connFsm->id, AnonymizeWrapper(anonyNetworkId), LnnPrintConnectionAddr(&connFsm->connInfo.addr));
2049 }
2050 AnonymizeFree(anonyNetworkId);
2051 if (CheckDeadFlag(connFsm, true)) {
2052 return;
2053 }
2054 rc = SyncBrOffline(connFsm);
2055 if (rc == SOFTBUS_OK) {
2056 LnnFsmPostMessageDelay(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_LNN_TIMEOUT,
2057 NULL, LEAVE_LNN_TIMEOUT_LEN);
2058 } else {
2059 CompleteLeaveLNN(connFsm, connInfo->peerNetworkId, SOFTBUS_OK);
2060 }
2061 }
2062
LeavingStateProcess(FsmStateMachine * fsm,int32_t msgType,void * para)2063 static bool LeavingStateProcess(FsmStateMachine *fsm, int32_t msgType, void *para)
2064 {
2065 LnnConnectionFsm *connFsm = NULL;
2066
2067 if (!CheckStateMsgCommonArgs(fsm)) {
2068 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2069 FreeUnhandledMessage(msgType, para);
2070 return false;
2071 }
2072 connFsm = TO_CONN_FSM(fsm);
2073
2074 LNN_LOGI(LNN_BUILDER, "leaving process message. [id=%{public}u], msgType=%{public}d", connFsm->id, msgType);
2075 switch (msgType) {
2076 case FSM_MSG_TYPE_JOIN_LNN:
2077 NotifyJoinResult(connFsm, NULL, SOFTBUS_NETWORK_JOIN_LEAVING);
2078 break;
2079 case FSM_MSG_TYPE_SYNC_OFFLINE_DONE:
2080 case FSM_MSG_TYPE_LEAVE_LNN_TIMEOUT:
2081 CompleteLeaveLNN(connFsm, connFsm->connInfo.peerNetworkId, SOFTBUS_OK);
2082 break;
2083 default:
2084 FreeUnhandledMessage(msgType, para);
2085 return false;
2086 }
2087 return true;
2088 }
2089
GetNextConnectionFsmId(void)2090 static uint16_t GetNextConnectionFsmId(void)
2091 {
2092 static uint16_t connFsmId = 0;
2093 return ++connFsmId;
2094 }
2095
ConnectionFsmDinitCallback(FsmStateMachine * fsm)2096 static void ConnectionFsmDinitCallback(FsmStateMachine *fsm)
2097 {
2098 LnnConnectionFsm *connFsm = NULL;
2099
2100 LNN_LOGI(LNN_BUILDER, "connection fsm deinit callback enter");
2101 if (!CheckStateMsgCommonArgs(fsm)) {
2102 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2103 return;
2104 }
2105 connFsm = TO_CONN_FSM(fsm);
2106 if (connFsm == NULL) {
2107 LNN_LOGE(LNN_BUILDER, "connFsm is NULL!");
2108 return;
2109 }
2110 if (connFsm->stopCallback) {
2111 connFsm->stopCallback(connFsm);
2112 }
2113 }
2114
InitConnectionStateMachine(LnnConnectionFsm * connFsm)2115 static int32_t InitConnectionStateMachine(LnnConnectionFsm *connFsm)
2116 {
2117 int32_t i;
2118
2119 if (sprintf_s(connFsm->fsmName, LNN_CONNECTION_FSM_NAME_LEN, "LnnConnFsm-%u", connFsm->id) == -1) {
2120 LNN_LOGE(LNN_BUILDER, "format lnn connection fsm name failed");
2121 return SOFTBUS_SPRINTF_ERR;
2122 }
2123 if (LnnFsmInit(&connFsm->fsm, NULL, connFsm->fsmName, ConnectionFsmDinitCallback) != SOFTBUS_OK) {
2124 LNN_LOGE(LNN_BUILDER, "init fsm failed");
2125 return SOFTBUS_NETWORK_FSM_INIT_FAILED;
2126 }
2127 for (i = 0; i < STATE_CONN_NUM_MAX; ++i) {
2128 LnnFsmAddState(&connFsm->fsm, &g_states[i]);
2129 }
2130 return SOFTBUS_OK;
2131 }
2132
LnnCreateConnectionFsm(const ConnectionAddr * target,const char * pkgName,bool isNeedConnect)2133 LnnConnectionFsm *LnnCreateConnectionFsm(const ConnectionAddr *target, const char *pkgName,
2134 bool isNeedConnect)
2135 {
2136 LnnConnectionFsm *connFsm = NULL;
2137
2138 if (target == NULL) {
2139 LNN_LOGE(LNN_BUILDER, "connection target is null");
2140 return NULL;
2141 }
2142 connFsm = (LnnConnectionFsm *)SoftBusCalloc(sizeof(LnnConnectionFsm));
2143 if (connFsm == NULL) {
2144 LNN_LOGE(LNN_BUILDER, "malloc for connection fsm failed");
2145 return NULL;
2146 }
2147 ListInit(&connFsm->node);
2148 connFsm->id = GetNextConnectionFsmId();
2149 if (InitConnectionStateMachine(connFsm) != SOFTBUS_OK) {
2150 LNN_LOGE(LNN_BUILDER, "init connecton fsm failed");
2151 SoftBusFree(connFsm);
2152 return NULL;
2153 }
2154 connFsm->connInfo.addr = *target;
2155 if (pkgName != NULL) {
2156 if (strcpy_s(connFsm->pkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
2157 LNN_LOGE(LNN_BUILDER, "copy pkgName fail");
2158 SoftBusFree(connFsm);
2159 return NULL;
2160 }
2161 }
2162 connFsm->isNeedConnect = isNeedConnect;
2163 LNN_LOGI(LNN_BUILDER, "create a new connection fsm. [id=%{public}u], peerAddr=%{public}s, needConnect=%{public}d",
2164 connFsm->id, LnnPrintConnectionAddr(target), isNeedConnect);
2165 return connFsm;
2166 }
2167
LnnDestroyConnectionFsm(LnnConnectionFsm * connFsm)2168 void LnnDestroyConnectionFsm(LnnConnectionFsm *connFsm)
2169 {
2170 if (connFsm == NULL) {
2171 LNN_LOGE(LNN_BUILDER, "connFsm is null");
2172 return;
2173 }
2174 LNN_LOGI(LNN_BUILDER, "destroy a connection fsm. [id=%{public}u]", connFsm->id);
2175 if (connFsm->connInfo.cleanInfo != NULL) {
2176 SoftBusFree(connFsm->connInfo.cleanInfo);
2177 }
2178 if (connFsm->connInfo.nodeInfo != NULL) {
2179 SoftBusFree(connFsm->connInfo.nodeInfo);
2180 }
2181 if (connFsm->connInfo.dupInfo != NULL) {
2182 SoftBusFree(connFsm->connInfo.dupInfo);
2183 }
2184 SoftBusFree(connFsm);
2185 }
2186
LnnStartConnectionFsm(LnnConnectionFsm * connFsm)2187 int32_t LnnStartConnectionFsm(LnnConnectionFsm *connFsm)
2188 {
2189 if (connFsm == NULL) {
2190 LNN_LOGE(LNN_BUILDER, "connection fsm is null");
2191 return SOFTBUS_INVALID_PARAM;
2192 }
2193 int32_t ret = LnnFsmStart(&connFsm->fsm, g_states + STATE_AUTH_INDEX);
2194 if (ret != SOFTBUS_OK) {
2195 LNN_LOGE(LNN_BUILDER, "start connection fsm failed. [id=%{public}u]", connFsm->id);
2196 return ret;
2197 }
2198 LNN_LOGI(LNN_BUILDER, "connection fsm is starting. [id=%{public}u]", connFsm->id);
2199 return SOFTBUS_OK;
2200 }
2201
LnnStopConnectionFsm(LnnConnectionFsm * connFsm,LnnConnectionFsmStopCallback callback)2202 int32_t LnnStopConnectionFsm(LnnConnectionFsm *connFsm, LnnConnectionFsmStopCallback callback)
2203 {
2204 if (connFsm == NULL || callback == NULL) {
2205 LNN_LOGE(LNN_BUILDER, "connection fsm or stop callback is null");
2206 return SOFTBUS_INVALID_PARAM;
2207 }
2208 connFsm->stopCallback = callback;
2209 int32_t ret = LnnFsmStop(&connFsm->fsm);
2210 if (ret != SOFTBUS_OK) {
2211 LNN_LOGE(LNN_BUILDER, "stop connection fsm failed. [id=%{public}u]", connFsm->id);
2212 return ret;
2213 }
2214 return LnnFsmDeinit(&connFsm->fsm);
2215 }
2216
LnnSendJoinRequestToConnFsm(LnnConnectionFsm * connFsm,bool isForceJoin)2217 int32_t LnnSendJoinRequestToConnFsm(LnnConnectionFsm *connFsm, bool isForceJoin)
2218 {
2219 if (!CheckInterfaceCommonArgs(connFsm, true)) {
2220 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2221 return SOFTBUS_INVALID_PARAM;
2222 }
2223 SetWatchdogFlag(false);
2224 if ((connFsm->connInfo.addr.type == CONNECTION_ADDR_BLE || connFsm->connInfo.addr.type == CONNECTION_ADDR_BR) &&
2225 SoftBusGetBtState() != BLE_ENABLE) {
2226 LNN_LOGE(LNN_BUILDER, "send join request while bt is turn off");
2227 return SOFTBUS_NETWORK_BLE_DISABLE;
2228 }
2229 if (isForceJoin && ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_ONLINE) != 0)) {
2230 return LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_FORCE_JOIN_LNN, NULL);
2231 }
2232 return LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_JOIN_LNN, NULL);
2233 }
2234
LnnSendAuthResultMsgToConnFsm(LnnConnectionFsm * connFsm,int32_t retCode)2235 int32_t LnnSendAuthResultMsgToConnFsm(LnnConnectionFsm *connFsm, int32_t retCode)
2236 {
2237 int32_t *para = NULL;
2238
2239 if (!CheckInterfaceCommonArgs(connFsm, true)) {
2240 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2241 return SOFTBUS_INVALID_PARAM;
2242 }
2243 para = (int32_t *)SoftBusMalloc(sizeof(int32_t));
2244 if (para == NULL) {
2245 LNN_LOGE(LNN_BUILDER, "malloc auth result msg para fail");
2246 return SOFTBUS_MALLOC_ERR;
2247 }
2248 *para = retCode;
2249 if (LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_AUTH_DONE, para) != SOFTBUS_OK) {
2250 LNN_LOGE(LNN_BUILDER, "post auth result message to connFsm fail");
2251 SoftBusFree(para);
2252 return SOFTBUS_AUTH_SEND_FAIL;
2253 }
2254 return SOFTBUS_OK;
2255 }
2256
LnnSendNotTrustedToConnFsm(LnnConnectionFsm * connFsm)2257 int32_t LnnSendNotTrustedToConnFsm(LnnConnectionFsm *connFsm)
2258 {
2259 if (!CheckInterfaceCommonArgs(connFsm, true)) {
2260 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2261 return SOFTBUS_INVALID_PARAM;
2262 }
2263 return LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_NOT_TRUSTED, NULL);
2264 }
2265
LnnSendDisconnectMsgToConnFsm(LnnConnectionFsm * connFsm)2266 int32_t LnnSendDisconnectMsgToConnFsm(LnnConnectionFsm *connFsm)
2267 {
2268 if (!CheckInterfaceCommonArgs(connFsm, true)) {
2269 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2270 return SOFTBUS_INVALID_PARAM;
2271 }
2272 return LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_DISCONNECT, NULL);
2273 }
2274
LnnSendLeaveRequestToConnFsm(LnnConnectionFsm * connFsm)2275 int32_t LnnSendLeaveRequestToConnFsm(LnnConnectionFsm *connFsm)
2276 {
2277 if (!CheckInterfaceCommonArgs(connFsm, true)) {
2278 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2279 return SOFTBUS_INVALID_PARAM;
2280 }
2281 return LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_LEAVE_LNN, NULL);
2282 }
2283
LnnSendSyncOfflineFinishToConnFsm(LnnConnectionFsm * connFsm)2284 int32_t LnnSendSyncOfflineFinishToConnFsm(LnnConnectionFsm *connFsm)
2285 {
2286 if (!CheckInterfaceCommonArgs(connFsm, true)) {
2287 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2288 return SOFTBUS_INVALID_PARAM;
2289 }
2290 return LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_SYNC_OFFLINE_DONE, NULL);
2291 }
2292
LnnSendNewNetworkOnlineToConnFsm(LnnConnectionFsm * connFsm)2293 int32_t LnnSendNewNetworkOnlineToConnFsm(LnnConnectionFsm *connFsm)
2294 {
2295 if (!CheckInterfaceCommonArgs(connFsm, true)) {
2296 LNN_LOGE(LNN_BUILDER, "connFsm is invalid");
2297 return SOFTBUS_INVALID_PARAM;
2298 }
2299 return LnnFsmPostMessage(&connFsm->fsm, FSM_MSG_TYPE_INITIATE_ONLINE, NULL);
2300 }
2301