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