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