1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "lnn_net_builder.h"
17
18 #include <securec.h>
19 #include <inttypes.h>
20
21 #include "anonymizer.h"
22 #include "auth_deviceprofile.h"
23 #include "auth_interface.h"
24 #include "auth_request.h"
25 #include "bus_center_event.h"
26 #include "bus_center_manager.h"
27 #include "common_list.h"
28 #include "lnn_async_callback_utils.h"
29 #include "lnn_node_info.h"
30 #include "lnn_battery_info.h"
31 #include "lnn_cipherkey_manager.h"
32 #include "lnn_connection_addr_utils.h"
33 #include "lnn_connection_fsm.h"
34 #include "lnn_deviceinfo_to_profile.h"
35 #include "lnn_devicename_info.h"
36 #include "lnn_discovery_manager.h"
37 #include "lnn_distributed_net_ledger.h"
38 #include "lnn_event.h"
39 #include "lnn_fast_offline.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_network_id.h"
45 #include "lnn_network_info.h"
46 #include "lnn_network_manager.h"
47 #include "lnn_node_info.h"
48 #include "lnn_node_weight.h"
49 #include "lnn_p2p_info.h"
50 #include "lnn_physical_subnet_manager.h"
51 #include "lnn_sync_info_manager.h"
52 #include "lnn_ohos_account.h"
53 #include "lnn_sync_item_info.h"
54 #include "lnn_topo_manager.h"
55 #include "softbus_adapter_mem.h"
56 #include "softbus_adapter_crypto.h"
57 #include "softbus_adapter_json.h"
58 #include "softbus_errcode.h"
59 #include "softbus_feature_config.h"
60 #include "softbus_hisysevt_bus_center.h"
61 #include "softbus_json_utils.h"
62 #include "softbus_utils.h"
63
64 #define LNN_CONN_CAPABILITY_MSG_LEN 8
65 #define DEFAULT_MAX_LNN_CONNECTION_COUNT 10
66 #define JSON_KEY_MASTER_UDID "MasterUdid"
67 #define JSON_KEY_MASTER_WEIGHT "MasterWeight"
68 #define NOT_TRUSTED_DEVICE_MSG_DELAY 5000
69 #define SHORT_UDID_HASH_STR_LEN 16
70 #define DEFAULT_PKG_NAME "com.huawei.nearby"
71
72 typedef enum {
73 MSG_TYPE_JOIN_LNN = 0,
74 MSG_TYPE_DISCOVERY_DEVICE,
75 MSG_TYPE_CLEAN_CONN_FSM,
76 MSG_TYPE_VERIFY_RESULT,
77 MSG_TYPE_DEVICE_VERIFY_PASS,
78 MSG_TYPE_DEVICE_DISCONNECT = 5,
79 MSG_TYPE_DEVICE_NOT_TRUSTED,
80 MSG_TYPE_LEAVE_LNN,
81 MSG_TYPE_SYNC_OFFLINE_FINISH,
82 MSG_TYPE_NODE_STATE_CHANGED,
83 MSG_TYPE_MASTER_ELECT = 10,
84 MSG_TYPE_LEAVE_INVALID_CONN,
85 MSG_TYPE_LEAVE_BY_ADDR_TYPE,
86 MSG_TYPE_LEAVE_SPECIFIC,
87 MSG_TYPE_MAX,
88 } NetBuilderMessageType;
89
90 typedef int32_t (*NetBuilderMessageProcess)(const void *para);
91
92 typedef struct {
93 ListNode node;
94 ConnectionAddr addr;
95 bool needReportFailure;
96 } PendingJoinRequestNode;
97
98 typedef struct {
99 NodeType nodeType;
100
101 /* connection fsm list */
102 ListNode fsmList;
103 ListNode pendingList;
104 /* connection count */
105 int32_t connCount;
106
107 SoftBusLooper *looper;
108 SoftBusHandler handler;
109
110 int32_t maxConnCount;
111 int32_t maxConcurrentCount;
112 bool isInit;
113 } NetBuilder;
114
115 typedef struct {
116 uint32_t requestId;
117 int32_t retCode;
118 int64_t authId;
119 NodeInfo *nodeInfo;
120 } VerifyResultMsgPara;
121
122 typedef struct {
123 ConnectionAddr addr;
124 int64_t authId;
125 NodeInfo *nodeInfo;
126 } DeviceVerifyPassMsgPara;
127
128 typedef struct {
129 char networkId[NETWORK_ID_BUF_LEN];
130 char masterUdid[UDID_BUF_LEN];
131 int32_t masterWeight;
132 } ElectMsgPara;
133
134 typedef struct {
135 char oldNetworkId[NETWORK_ID_BUF_LEN];
136 ConnectionAddrType addrType;
137 char newNetworkId[NETWORK_ID_BUF_LEN];
138 } LeaveInvalidConnMsgPara;
139
140 typedef struct {
141 char networkId[NETWORK_ID_BUF_LEN];
142 ConnectionAddrType addrType;
143 } SpecificLeaveMsgPara;
144
145 typedef struct {
146 char pkgName[PKG_NAME_SIZE_MAX];
147 bool isNeedConnect;
148 ConnectionAddr addr;
149 } JoinLnnMsgPara;
150
151 typedef struct {
152 char pkgName[PKG_NAME_SIZE_MAX];
153 char networkId[NETWORK_ID_BUF_LEN];
154 } LeaveLnnMsgPara;
155
156 static NetBuilder g_netBuilder;
157 static bool g_watchdogFlag = true;
158
SfcSyncNodeAddrHandle(const char * networkId,int32_t code)159 void __attribute__((weak)) SfcSyncNodeAddrHandle(const char *networkId, int32_t code)
160 {
161 (void)networkId;
162 (void)code;
163 }
164
SetWatchdogFlag(bool flag)165 void SetWatchdogFlag(bool flag)
166 {
167 g_watchdogFlag = flag;
168 }
169
GetWatchdogFlag(void)170 bool GetWatchdogFlag(void)
171 {
172 return g_watchdogFlag;
173 }
174
NetBuilderConfigInit(void)175 static void NetBuilderConfigInit(void)
176 {
177 if (SoftbusGetConfig(SOFTBUS_INT_MAX_LNN_CONNECTION_CNT,
178 (unsigned char *)&g_netBuilder.maxConnCount, sizeof(g_netBuilder.maxConnCount)) != SOFTBUS_OK) {
179 LNN_LOGE(LNN_INIT, "get lnn max connection count fail, use default value");
180 g_netBuilder.maxConnCount = DEFAULT_MAX_LNN_CONNECTION_COUNT;
181 }
182 if (SoftbusGetConfig(SOFTBUS_INT_LNN_MAX_CONCURRENT_NUM,
183 (unsigned char *)&g_netBuilder.maxConcurrentCount, sizeof(g_netBuilder.maxConcurrentCount)) != SOFTBUS_OK) {
184 LNN_LOGE(LNN_INIT, "get lnn max conncurent count fail, use default value");
185 g_netBuilder.maxConcurrentCount = 0;
186 }
187 LNN_LOGD(LNN_INIT, "lnn config count: maxConnCount=%{public}d, maxConcurrentCount=%{public}d",
188 g_netBuilder.maxConnCount, g_netBuilder.maxConcurrentCount);
189 }
190
CreateNetBuilderMessage(int32_t msgType,void * para)191 static SoftBusMessage *CreateNetBuilderMessage(int32_t msgType, void *para)
192 {
193 SoftBusMessage *msg = (SoftBusMessage *)SoftBusCalloc(sizeof(SoftBusMessage));
194 if (msg == NULL) {
195 LNN_LOGE(LNN_BUILDER, "malloc softbus message failed");
196 return NULL;
197 }
198 msg->what = msgType;
199 msg->obj = para;
200 msg->handler = &g_netBuilder.handler;
201 return msg;
202 }
203
PostMessageToHandler(int32_t msgType,void * para)204 static int32_t PostMessageToHandler(int32_t msgType, void *para)
205 {
206 SoftBusMessage *msg = CreateNetBuilderMessage(msgType, para);
207 if (msg == NULL) {
208 LNN_LOGE(LNN_BUILDER, "create softbus message failed");
209 return SOFTBUS_ERR;
210 }
211 g_netBuilder.looper->PostMessage(g_netBuilder.looper, msg);
212 return SOFTBUS_OK;
213 }
214
FindConnectionFsmByAddr(const ConnectionAddr * addr,bool isShort)215 static LnnConnectionFsm *FindConnectionFsmByAddr(const ConnectionAddr *addr, bool isShort)
216 {
217 LnnConnectionFsm *item = NULL;
218
219 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
220 if (LnnIsSameConnectionAddr(addr, &item->connInfo.addr, isShort)) {
221 return item;
222 }
223 }
224 return NULL;
225 }
226
FindConnectionFsmByRequestId(uint32_t requestId)227 static LnnConnectionFsm *FindConnectionFsmByRequestId(uint32_t requestId)
228 {
229 LnnConnectionFsm *item = NULL;
230
231 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
232 if (item->connInfo.requestId == requestId) {
233 return item;
234 }
235 }
236 return NULL;
237 }
238
FindConnectionFsmByAuthId(int64_t authId)239 static LnnConnectionFsm *FindConnectionFsmByAuthId(int64_t authId)
240 {
241 LnnConnectionFsm *item = NULL;
242
243 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
244 if (item->connInfo.authId == authId) {
245 return item;
246 }
247 }
248 return NULL;
249 }
250
FindConnectionFsmByNetworkId(const char * networkId)251 static LnnConnectionFsm *FindConnectionFsmByNetworkId(const char *networkId)
252 {
253 LnnConnectionFsm *item = NULL;
254
255 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
256 if (strcmp(networkId, item->connInfo.peerNetworkId) == 0) {
257 return item;
258 }
259 }
260 return NULL;
261 }
262
FindConnectionFsmByConnFsmId(uint16_t connFsmId)263 static LnnConnectionFsm *FindConnectionFsmByConnFsmId(uint16_t connFsmId)
264 {
265 LnnConnectionFsm *item = NULL;
266
267 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
268 if (connFsmId == item->id) {
269 return item;
270 }
271 }
272 return NULL;
273 }
274
SetBeginJoinLnnTime(LnnConnectionFsm * connFsm)275 static void SetBeginJoinLnnTime(LnnConnectionFsm *connFsm)
276 {
277 connFsm->statisticData.beginJoinLnnTime = LnnUpTimeMs();
278 }
279
StartNewConnectionFsm(const ConnectionAddr * addr,const char * pkgName,bool isNeedConnect)280 static LnnConnectionFsm *StartNewConnectionFsm(const ConnectionAddr *addr, const char *pkgName, bool isNeedConnect)
281 {
282 LnnConnectionFsm *connFsm = NULL;
283
284 if (g_netBuilder.connCount >= g_netBuilder.maxConnCount) {
285 LNN_LOGE(LNN_BUILDER, "current connection num exceeds max limit, connCount=%{public}d", g_netBuilder.connCount);
286 return NULL;
287 }
288 connFsm = LnnCreateConnectionFsm(addr, pkgName, isNeedConnect);
289 if (connFsm == NULL) {
290 LNN_LOGE(LNN_BUILDER, "create connection fsm failed");
291 return NULL;
292 }
293 if (LnnStartConnectionFsm(connFsm) != SOFTBUS_OK) {
294 LNN_LOGE(LNN_BUILDER, "start connection failed. fsmId=%{public}u", connFsm->id);
295 LnnDestroyConnectionFsm(connFsm);
296 return NULL;
297 }
298 SetBeginJoinLnnTime(connFsm);
299 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
300 ++g_netBuilder.connCount;
301 return connFsm;
302 }
303
IsNodeOnline(const char * networkId)304 static bool IsNodeOnline(const char *networkId)
305 {
306 return LnnGetOnlineStateById(networkId, CATEGORY_NETWORK_ID);
307 }
308
UpdateLocalMasterNode(bool isCurrentNode,const char * masterUdid,int32_t weight)309 static void UpdateLocalMasterNode(bool isCurrentNode, const char *masterUdid, int32_t weight)
310 {
311 if (LnnSetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, masterUdid) != SOFTBUS_OK) {
312 LNN_LOGE(LNN_BUILDER, "set local master udid failed");
313 return;
314 }
315 if (LnnSetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, weight) != SOFTBUS_OK) {
316 LNN_LOGE(LNN_BUILDER, "set local master weight failed");
317 }
318 LnnNotifyMasterNodeChanged(isCurrentNode, masterUdid, weight);
319 LNN_LOGI(LNN_BUILDER, "update local master weight. weight=%{public}d", weight);
320 }
321
IsNeedSyncElectMsg(const char * networkId)322 static bool IsNeedSyncElectMsg(const char *networkId)
323 {
324 NodeInfo nodeInfo;
325 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
326 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &nodeInfo) != SOFTBUS_OK) {
327 LNN_LOGE(LNN_BUILDER, "get RemoteNodeInfo by id fail");
328 return false;
329 }
330 return LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_WIFI);
331 }
332
SyncElectMessage(const char * networkId)333 static int32_t SyncElectMessage(const char *networkId)
334 {
335 char masterUdid[UDID_BUF_LEN] = { 0 };
336 int32_t masterWeight;
337 char *data = NULL;
338 cJSON *json = NULL;
339 int32_t rc;
340
341 if (!IsNeedSyncElectMsg(networkId)) {
342 char *anonyNetworkId = NULL;
343 Anonymize(networkId, &anonyNetworkId);
344 LNN_LOGW(LNN_BUILDER, "no ip networking, dont sync elect msg, networkId=%{public}s", anonyNetworkId);
345 AnonymizeFree(anonyNetworkId);
346 return SOFTBUS_OK;
347 }
348 if (LnnGetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, masterUdid, UDID_BUF_LEN) != SOFTBUS_OK ||
349 LnnGetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, &masterWeight) != SOFTBUS_OK) {
350 LNN_LOGE(LNN_BUILDER, "get local master node info failed");
351 return SOFTBUS_INVALID_PARAM;
352 }
353 json = cJSON_CreateObject();
354 if (json == NULL) {
355 LNN_LOGE(LNN_BUILDER, "create elect json object failed");
356 return SOFTBUS_CREATE_JSON_ERR;
357 }
358 if (!AddStringToJsonObject(json, JSON_KEY_MASTER_UDID, masterUdid) ||
359 !AddNumberToJsonObject(json, JSON_KEY_MASTER_WEIGHT, masterWeight)) {
360 LNN_LOGE(LNN_BUILDER, "add elect info to json failed");
361 cJSON_Delete(json);
362 return SOFTBUS_ERR;
363 }
364 data = cJSON_PrintUnformatted(json);
365 cJSON_Delete(json);
366 if (data == NULL) {
367 LNN_LOGE(LNN_BUILDER, "format elect packet fail");
368 return SOFTBUS_ERR;
369 }
370 rc = LnnSendSyncInfoMsg(LNN_INFO_TYPE_MASTER_ELECT, networkId, (uint8_t *)data, strlen(data) + 1, NULL);
371 cJSON_free(data);
372 return rc;
373 }
374
SendElectMessageToAll(const char * skipNetworkId)375 static void SendElectMessageToAll(const char *skipNetworkId)
376 {
377 LnnConnectionFsm *item = NULL;
378
379 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
380 if (skipNetworkId != NULL && strcmp(item->connInfo.peerNetworkId, skipNetworkId) == 0) {
381 continue;
382 }
383 if (!IsNodeOnline(item->connInfo.peerNetworkId)) {
384 continue;
385 }
386 if (SyncElectMessage(item->connInfo.peerNetworkId) != SOFTBUS_OK) {
387 LNN_LOGE(LNN_BUILDER, "sync elect info to conn failed. connFsm=%{public}u", item->id);
388 }
389 }
390 }
391
NeedPendingJoinRequest(void)392 static bool NeedPendingJoinRequest(void)
393 {
394 int32_t count = 0;
395 LnnConnectionFsm *item = NULL;
396
397 if (g_netBuilder.maxConcurrentCount == 0) { // do not limit concurent
398 return false;
399 }
400 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
401 if (item->isDead) {
402 continue;
403 }
404 if ((item->connInfo.flag & LNN_CONN_INFO_FLAG_ONLINE) != 0) {
405 continue;
406 }
407 ++count;
408 if (count >= g_netBuilder.maxConcurrentCount) {
409 return true;
410 }
411 }
412 return false;
413 }
414
IsSamePendingRequest(const PendingJoinRequestNode * request)415 static bool IsSamePendingRequest(const PendingJoinRequestNode *request)
416 {
417 PendingJoinRequestNode *item = NULL;
418
419 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.pendingList, PendingJoinRequestNode, node) {
420 if (LnnIsSameConnectionAddr(&item->addr, &request->addr, false) &&
421 item->needReportFailure == request->needReportFailure) {
422 LNN_LOGD(LNN_BUILDER, "have the same pending join request");
423 return true;
424 }
425 }
426 return false;
427 }
428
TryPendingJoinRequest(const JoinLnnMsgPara * para,bool needReportFailure)429 static bool TryPendingJoinRequest(const JoinLnnMsgPara *para, bool needReportFailure)
430 {
431 PendingJoinRequestNode *request = NULL;
432 if (para == NULL || !para->isNeedConnect) {
433 LNN_LOGI(LNN_BUILDER, "no connect online, no need pending");
434 return false;
435 }
436 if (!NeedPendingJoinRequest()) {
437 LNN_LOGE(LNN_BUILDER, "NeedPendingJoinRequest fail");
438 return false;
439 }
440 request = (PendingJoinRequestNode *)SoftBusCalloc(sizeof(PendingJoinRequestNode));
441 if (request == NULL) {
442 LNN_LOGE(LNN_BUILDER, "malloc pending join request fail, go on it");
443 return false;
444 }
445 ListInit(&request->node);
446 request->addr = para->addr;
447 request->needReportFailure = needReportFailure;
448 if (IsSamePendingRequest(request)) {
449 SoftBusFree(request);
450 return true;
451 }
452 ListTailInsert(&g_netBuilder.pendingList, &request->node);
453 return true;
454 }
455
PostJoinRequestToConnFsm(LnnConnectionFsm * connFsm,const ConnectionAddr * addr,const char * pkgName,bool isNeedConnect,bool needReportFailure)456 static int32_t PostJoinRequestToConnFsm(LnnConnectionFsm *connFsm, const ConnectionAddr *addr,
457 const char *pkgName, bool isNeedConnect, bool needReportFailure)
458 {
459 int32_t rc = SOFTBUS_OK;
460 bool isCreate = false;
461
462 if (connFsm == NULL) {
463 connFsm = FindConnectionFsmByAddr(addr, false);
464 }
465 if (connFsm == NULL || connFsm->isDead) {
466 connFsm = StartNewConnectionFsm(addr, pkgName, isNeedConnect);
467 isCreate = true;
468 }
469 if (connFsm == NULL || LnnSendJoinRequestToConnFsm(connFsm) != SOFTBUS_OK) {
470 LNN_LOGE(LNN_BUILDER, "process join lnn request failed");
471 if (needReportFailure) {
472 LnnNotifyJoinResult((ConnectionAddr *)addr, NULL, SOFTBUS_ERR);
473 }
474 if (connFsm != NULL && isCreate) {
475 LnnFsmRemoveMessageByType(&connFsm->fsm, FSM_CTRL_MSG_START);
476 ListDelete(&connFsm->node);
477 --g_netBuilder.connCount;
478 LnnDestroyConnectionFsm(connFsm);
479 }
480 rc = SOFTBUS_ERR;
481 }
482 if (rc == SOFTBUS_OK) {
483 connFsm->connInfo.flag |=
484 (needReportFailure ? LNN_CONN_INFO_FLAG_JOIN_REQUEST : LNN_CONN_INFO_FLAG_JOIN_AUTO);
485 }
486 return rc;
487 }
488
TryRemovePendingJoinRequest(void)489 static void TryRemovePendingJoinRequest(void)
490 {
491 PendingJoinRequestNode *item = NULL;
492 PendingJoinRequestNode *next = NULL;
493
494 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_netBuilder.pendingList, PendingJoinRequestNode, node) {
495 if (NeedPendingJoinRequest()) {
496 return;
497 }
498 ListDelete(&item->node);
499 if (PostJoinRequestToConnFsm(NULL, &item->addr, DEFAULT_PKG_NAME, true, item->needReportFailure) !=
500 SOFTBUS_OK) {
501 LNN_LOGE(LNN_BUILDER, "post pending join request failed");
502 }
503 LNN_LOGI(
504 LNN_BUILDER, "remove a pending join request, peerAddr=%{public}s", LnnPrintConnectionAddr(&item->addr));
505 SoftBusFree(item);
506 break;
507 }
508 }
509
RemovePendingRequestByAddrType(const bool * addrType,uint32_t typeLen)510 static void RemovePendingRequestByAddrType(const bool *addrType, uint32_t typeLen)
511 {
512 PendingJoinRequestNode *item = NULL;
513 PendingJoinRequestNode *next = NULL;
514
515 if (addrType == NULL || typeLen != CONNECTION_ADDR_MAX) {
516 LNN_LOGE(LNN_BUILDER, "invalid typeLen=%{public}d", typeLen);
517 return;
518 }
519 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_netBuilder.pendingList, PendingJoinRequestNode, node) {
520 if (!addrType[item->addr.type]) {
521 continue;
522 }
523 ListDelete(&item->node);
524 LNN_LOGI(LNN_BUILDER, "clean a pending join request, peerAddr=%{public}s", LnnPrintConnectionAddr(&item->addr));
525 SoftBusFree(item);
526 }
527 }
528
IsNeedWifiReauth(const char * networkId,const char * newAccountHash,int32_t len)529 static bool IsNeedWifiReauth(const char *networkId, const char *newAccountHash, int32_t len)
530 {
531 if (LnnIsDefaultOhosAccount()) {
532 LNN_LOGE(LNN_BUILDER, "local account is default");
533 return false;
534 }
535 NodeInfo info;
536 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
537 if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &info) != SOFTBUS_OK) {
538 LNN_LOGE(LNN_BUILDER, "get node info fail");
539 return false;
540 }
541 char *anonyNetworkId = NULL;
542 Anonymize(networkId, &anonyNetworkId);
543 LNN_LOGI(LNN_BUILDER, "peer networkId=%{public}s, accountHash:%{public}02x%{public}02x->%{public}02x%{public}02x",
544 anonyNetworkId, info.accountHash[0], info.accountHash[1], newAccountHash[0], newAccountHash[1]);
545 AnonymizeFree(anonyNetworkId);
546 uint8_t defaultAccountHash[SHA_256_HASH_LEN] = {0};
547 const char *defaultUserId = "0";
548 if (SoftBusGenerateStrHash((const unsigned char *)defaultUserId, strlen(defaultUserId), defaultAccountHash) !=
549 SOFTBUS_OK) {
550 LNN_LOGE(LNN_BUILDER, "generate default str hash fail");
551 return false;
552 }
553 bool isNullAccount = true;
554 for (int32_t i = 0; i < len; ++i) {
555 if (newAccountHash[i] != 0) {
556 isNullAccount = false;
557 break;
558 }
559 }
560 if (isNullAccount || memcmp(newAccountHash, defaultAccountHash, HB_SHORT_ACCOUNT_HASH_LEN) == 0) {
561 LNN_LOGE(LNN_BUILDER, "accountHash is null or account is default");
562 return false;
563 }
564 return memcmp(info.accountHash, newAccountHash, HB_SHORT_ACCOUNT_HASH_LEN) != 0;
565 }
566
TrySendJoinLNNRequest(const JoinLnnMsgPara * para,bool needReportFailure,bool isShort)567 static int32_t TrySendJoinLNNRequest(const JoinLnnMsgPara *para, bool needReportFailure, bool isShort)
568 {
569 LnnConnectionFsm *connFsm = NULL;
570 int32_t ret = SOFTBUS_OK;
571 if (para == NULL) {
572 LNN_LOGW(LNN_BUILDER, "addr is null");
573 return SOFTBUS_INVALID_PARAM;
574 }
575 if (!para->isNeedConnect) {
576 isShort = true;
577 }
578 connFsm = FindConnectionFsmByAddr(¶->addr, isShort);
579 if (connFsm == NULL || connFsm->isDead) {
580 if (TryPendingJoinRequest(para, needReportFailure)) {
581 LNN_LOGI(LNN_BUILDER, "join request is pending, peerAddr=%{public}s", LnnPrintConnectionAddr(¶->addr));
582 SoftBusFree((void *)para);
583 return SOFTBUS_OK;
584 }
585 ret = PostJoinRequestToConnFsm(connFsm, ¶->addr, para->pkgName, para->isNeedConnect, needReportFailure);
586 SoftBusFree((void *)para);
587 return ret;
588 }
589 connFsm->connInfo.flag |=
590 (needReportFailure ? LNN_CONN_INFO_FLAG_JOIN_REQUEST : LNN_CONN_INFO_FLAG_JOIN_AUTO);
591 if ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_ONLINE) != 0) {
592 if ((LnnSendJoinRequestToConnFsm(connFsm) != SOFTBUS_OK) && needReportFailure) {
593 LNN_LOGE(LNN_BUILDER, "online status, process join lnn request failed");
594 LnnNotifyJoinResult((ConnectionAddr *)¶->addr, NULL, SOFTBUS_ERR);
595 }
596 }
597 LNN_LOGI(LNN_BUILDER, "addr same to before, peerAddr=%{public}s", LnnPrintConnectionAddr(¶->addr));
598 ConnectionAddr addr = para->addr;
599 SoftBusFree((void *)para);
600 if (addr.type != CONNECTION_ADDR_WLAN ||
601 !IsNeedWifiReauth(connFsm->connInfo.peerNetworkId, addr.peerUid, MAX_ACCOUNT_HASH_LEN)) {
602 LNN_LOGI(LNN_BUILDER, "account not change no need reauth");
603 return SOFTBUS_OK;
604 }
605 AuthConnInfo authConn;
606 uint32_t requestId = AuthGenRequestId();
607 (void)LnnConvertAddrToAuthConnInfo(&addr, &authConn);
608 if (AuthStartVerify(&authConn, requestId, LnnGetReAuthVerifyCallback(), false) != SOFTBUS_OK) {
609 LNN_LOGI(LNN_BUILDER, "AuthStartVerify error");
610 return SOFTBUS_ERR;
611 }
612 return SOFTBUS_OK;
613 }
614
ProcessJoinLNNRequest(const void * para)615 static int32_t ProcessJoinLNNRequest(const void *para)
616 {
617 return TrySendJoinLNNRequest((const JoinLnnMsgPara *)para, true, false);
618 }
619
ProcessDevDiscoveryRequest(const void * para)620 static int32_t ProcessDevDiscoveryRequest(const void *para)
621 {
622 return TrySendJoinLNNRequest((const JoinLnnMsgPara *)para, false, false);
623 }
624
InitiateNewNetworkOnline(ConnectionAddrType addrType,const char * networkId)625 static void InitiateNewNetworkOnline(ConnectionAddrType addrType, const char *networkId)
626 {
627 LnnConnectionFsm *item = NULL;
628 int32_t rc;
629
630 // find target connfsm, then notify it online
631 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
632 if (strcmp(networkId, item->connInfo.peerNetworkId) != 0) {
633 continue;
634 }
635 if (item->isDead) {
636 continue;
637 }
638 if (addrType != CONNECTION_ADDR_MAX && addrType != item->connInfo.addr.type) {
639 continue;
640 }
641 rc = LnnSendNewNetworkOnlineToConnFsm(item);
642 LNN_LOGI(LNN_INIT, "initiate new network online to connection. fsmId=%{public}u, rc=%{public}d", item->id, rc);
643 }
644 }
645
TryInitiateNewNetworkOnline(const LnnConnectionFsm * connFsm)646 static void TryInitiateNewNetworkOnline(const LnnConnectionFsm *connFsm)
647 {
648 LnnConnectionFsm *item = NULL;
649 LnnInvalidCleanInfo *cleanInfo = connFsm->connInfo.cleanInfo;
650
651 if ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_INITIATE_ONLINE) == 0) {
652 LNN_LOGI(LNN_INIT, "no need initiate new network online. fsmId=%{public}u", connFsm->id);
653 return;
654 }
655 // let last invalid connfsm notify new network online after it clean
656 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
657 if (strcmp(connFsm->connInfo.peerNetworkId, item->connInfo.peerNetworkId) != 0) {
658 continue;
659 }
660 if ((item->connInfo.flag & LNN_CONN_INFO_FLAG_INITIATE_ONLINE) == 0) {
661 continue;
662 }
663 LNN_LOGI(LNN_INIT, "wait last connfsm clean, then initiate new network online. fsmId=%{public}u", connFsm->id);
664 return;
665 }
666 InitiateNewNetworkOnline(cleanInfo->addrType, cleanInfo->networkId);
667 }
668
TryDisconnectAllConnection(const LnnConnectionFsm * connFsm)669 static void TryDisconnectAllConnection(const LnnConnectionFsm *connFsm)
670 {
671 LnnConnectionFsm *item = NULL;
672 const ConnectionAddr *addr1 = &connFsm->connInfo.addr;
673 const ConnectionAddr *addr2 = NULL;
674 ConnectOption option;
675
676 // Not really leaving lnn
677 if ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_ONLINE) == 0) {
678 return;
679 }
680 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
681 addr2 = &item->connInfo.addr;
682 if (addr1->type != addr2->type) {
683 continue;
684 }
685 if (addr1->type == CONNECTION_ADDR_BR || addr1->type == CONNECTION_ADDR_BLE) {
686 if (strncmp(item->connInfo.addr.info.br.brMac, addr2->info.br.brMac, BT_MAC_LEN) == 0) {
687 return;
688 }
689 } else if (addr1->type == CONNECTION_ADDR_WLAN || addr1->type == CONNECTION_ADDR_ETH) {
690 if (strncmp(addr1->info.ip.ip, addr2->info.ip.ip, strlen(addr1->info.ip.ip)) == 0) {
691 return;
692 }
693 }
694 }
695 LNN_LOGI(LNN_BUILDER, "disconnect all connection. fsmId=%{public}u, type=%{public}d", connFsm->id, addr1->type);
696 if (LnnConvertAddrToOption(addr1, &option)) {
697 ConnDisconnectDeviceAllConn(&option);
698 }
699 }
700
TryNotifyAllTypeOffline(const LnnConnectionFsm * connFsm)701 static void TryNotifyAllTypeOffline(const LnnConnectionFsm *connFsm)
702 {
703 LnnConnectionFsm *item = NULL;
704 const ConnectionAddr *addr1 = &connFsm->connInfo.addr;
705 const ConnectionAddr *addr2 = NULL;
706
707 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
708 addr2 = &item->connInfo.addr;
709 if (addr1->type == addr2->type) {
710 return;
711 }
712 }
713 LNN_LOGI(LNN_BUILDER, "notify all connection offline. fsmId=%{public}u, type=%{public}d", connFsm->id, addr1->type);
714 (void)LnnNotifyAllTypeOffline(addr1->type);
715 }
716
CleanConnectionFsm(LnnConnectionFsm * connFsm)717 static void CleanConnectionFsm(LnnConnectionFsm *connFsm)
718 {
719 if (connFsm == NULL) {
720 LNN_LOGE(LNN_BUILDER, "connection fsm is null");
721 return;
722 }
723 LNN_LOGI(LNN_BUILDER, "connection is cleaned. fsmId=%{public}u", connFsm->id);
724 LnnDestroyConnectionFsm(connFsm);
725 }
726
StopConnectionFsm(LnnConnectionFsm * connFsm)727 static void StopConnectionFsm(LnnConnectionFsm *connFsm)
728 {
729 if (LnnStopConnectionFsm(connFsm, CleanConnectionFsm) != SOFTBUS_OK) {
730 LNN_LOGE(LNN_BUILDER, "stop connection failed. fsmId=%{public}u", connFsm->id);
731 }
732 ListDelete(&connFsm->node);
733 --g_netBuilder.connCount;
734 }
735
ProcessCleanConnectionFsm(const void * para)736 static int32_t ProcessCleanConnectionFsm(const void *para)
737 {
738 uint16_t connFsmId;
739 LnnConnectionFsm *connFsm = NULL;
740 int32_t rc = SOFTBUS_ERR;
741
742 if (para == NULL) {
743 LNN_LOGW(LNN_BUILDER, "connFsmId is null");
744 return SOFTBUS_INVALID_PARAM;
745 }
746 connFsmId = *(uint16_t *)para;
747 do {
748 connFsm = FindConnectionFsmByConnFsmId(connFsmId);
749 if (connFsm == NULL) {
750 LNN_LOGE(LNN_BUILDER, "can not find connection fsm");
751 break;
752 }
753 StopConnectionFsm(connFsm);
754 TryInitiateNewNetworkOnline(connFsm);
755 TryDisconnectAllConnection(connFsm);
756 TryNotifyAllTypeOffline(connFsm);
757 TryRemovePendingJoinRequest();
758 rc = SOFTBUS_OK;
759 } while (false);
760 SoftBusFree((void *)para);
761 return rc;
762 }
763
ProcessVerifyResult(const void * para)764 static int32_t ProcessVerifyResult(const void *para)
765 {
766 int32_t rc;
767 LnnConnectionFsm *connFsm = NULL;
768 const VerifyResultMsgPara *msgPara = (const VerifyResultMsgPara *)para;
769
770 if (msgPara == NULL) {
771 LNN_LOGW(LNN_BUILDER, "para is null");
772 return SOFTBUS_INVALID_PARAM;
773 }
774
775 if (msgPara->retCode == SOFTBUS_OK && msgPara->nodeInfo == NULL) {
776 LNN_LOGE(LNN_BUILDER, "msgPara node Info is null");
777 SoftBusFree((void *)msgPara);
778 return SOFTBUS_INVALID_PARAM;
779 }
780
781 do {
782 connFsm = FindConnectionFsmByRequestId(msgPara->requestId);
783 if (connFsm == NULL || connFsm->isDead) {
784 LNN_LOGE(LNN_BUILDER, "can not find connection fsm by request. requestId=%{public}u", msgPara->requestId);
785 rc = SOFTBUS_NETWORK_NOT_FOUND;
786 break;
787 }
788 LNN_LOGI(LNN_BUILDER,
789 "connection fsm auth done, fsmId=%{public}u, authId=%{public}" PRId64 ", retCode=%{public}d",
790 connFsm->id, msgPara->authId, msgPara->retCode);
791 if (msgPara->retCode == SOFTBUS_OK) {
792 connFsm->connInfo.authId = msgPara->authId;
793 connFsm->connInfo.nodeInfo = msgPara->nodeInfo;
794 }
795 if (LnnSendAuthResultMsgToConnFsm(connFsm, msgPara->retCode) != SOFTBUS_OK) {
796 LNN_LOGE(LNN_BUILDER, "send auth result to connection failed. fsmId=%{public}u", connFsm->id);
797 connFsm->connInfo.nodeInfo = NULL;
798 rc = SOFTBUS_ERR;
799 break;
800 }
801 rc = SOFTBUS_OK;
802 } while (false);
803
804 if (rc != SOFTBUS_OK && msgPara->nodeInfo != NULL) {
805 SoftBusFree((void *)msgPara->nodeInfo);
806 }
807 SoftBusFree((void *)msgPara);
808 return rc;
809 }
810
CreatePassiveConnectionFsm(const DeviceVerifyPassMsgPara * msgPara)811 static int32_t CreatePassiveConnectionFsm(const DeviceVerifyPassMsgPara *msgPara)
812 {
813 LnnConnectionFsm *connFsm = NULL;
814 connFsm = StartNewConnectionFsm(&msgPara->addr, DEFAULT_PKG_NAME, true);
815 if (connFsm == NULL) {
816 LNN_LOGE(LNN_BUILDER, "start new connection fsm fail, authId=%{public}" PRId64, msgPara->authId);
817 return SOFTBUS_ERR;
818 }
819 connFsm->connInfo.authId = msgPara->authId;
820 connFsm->connInfo.nodeInfo = msgPara->nodeInfo;
821 connFsm->connInfo.flag |= LNN_CONN_INFO_FLAG_JOIN_PASSIVE;
822 LNN_LOGI(LNN_BUILDER, "start a passive connection fsm, fsmId=%{public}u, authId=%{public}" PRId64, connFsm->id,
823 msgPara->authId);
824 if (LnnSendAuthResultMsgToConnFsm(connFsm, SOFTBUS_OK) != SOFTBUS_OK) {
825 connFsm->connInfo.nodeInfo = NULL;
826 StopConnectionFsm(connFsm);
827 LNN_LOGE(LNN_BUILDER, "post auth result to connection fsm fail, fsmId=%{public}u, authId=%{public}" PRId64,
828 connFsm->id, msgPara->authId);
829 return SOFTBUS_ERR;
830 }
831 return SOFTBUS_OK;
832 }
833
ProcessDeviceVerifyPass(const void * para)834 static int32_t ProcessDeviceVerifyPass(const void *para)
835 {
836 int32_t rc = SOFTBUS_OK;
837 LnnConnectionFsm *connFsm = NULL;
838 const DeviceVerifyPassMsgPara *msgPara = (const DeviceVerifyPassMsgPara *)para;
839
840 if (msgPara == NULL) {
841 LNN_LOGW(LNN_BUILDER, "para is null");
842 return SOFTBUS_INVALID_PARAM;
843 }
844 if (msgPara->nodeInfo == NULL) {
845 LNN_LOGE(LNN_BUILDER, "msgPara nodeInfo is null");
846 SoftBusFree((void *)msgPara);
847 return SOFTBUS_INVALID_PARAM;
848 }
849
850 do {
851 connFsm = FindConnectionFsmByAuthId(msgPara->authId);
852 if (connFsm == NULL || connFsm->isDead) {
853 rc = CreatePassiveConnectionFsm(msgPara);
854 break;
855 }
856 if (strcmp(connFsm->connInfo.peerNetworkId, msgPara->nodeInfo->networkId) != 0) {
857 LNN_LOGI(LNN_BUILDER, "networkId changed, fsmId=%{public}u, authId=%{public}" PRId64, connFsm->id,
858 msgPara->authId);
859 rc = CreatePassiveConnectionFsm(msgPara);
860 break;
861 }
862 msgPara->nodeInfo->discoveryType = 1 << (uint32_t)LnnConvAddrTypeToDiscType(msgPara->addr.type);
863 if (LnnUpdateNodeInfo(msgPara->nodeInfo) != SOFTBUS_OK) {
864 LNN_LOGE(LNN_BUILDER, "LnnUpdateNodeInfo failed");
865 }
866 LNN_LOGI(LNN_BUILDER, "connection fsm exist, ignore VerifyPass. fsmId=%{public}u, authId=%{public}" PRId64,
867 connFsm->id, msgPara->authId);
868 rc = SOFTBUS_ERR;
869 } while (false);
870
871 if (rc != SOFTBUS_OK && msgPara->nodeInfo != NULL) {
872 SoftBusFree((void *)msgPara->nodeInfo);
873 }
874 SoftBusFree((void *)msgPara);
875 return rc;
876 }
877
ProcessDeviceDisconnect(const void * para)878 static int32_t ProcessDeviceDisconnect(const void *para)
879 {
880 int32_t rc = SOFTBUS_OK;
881 LnnConnectionFsm *connFsm = NULL;
882 const int64_t *authId = (const int64_t *)para;
883
884 if (authId == NULL) {
885 LNN_LOGW(LNN_BUILDER, "authId is null");
886 return SOFTBUS_INVALID_PARAM;
887 }
888
889 do {
890 connFsm = FindConnectionFsmByAuthId(*authId);
891 if (connFsm == NULL || connFsm->isDead) {
892 LNN_LOGE(LNN_BUILDER, "can not find connection fsm. authId=%{public}" PRId64, *authId);
893 rc = SOFTBUS_NETWORK_NOT_FOUND;
894 break;
895 }
896 LNN_LOGI(LNN_BUILDER, "device disconnect, fsmId=%{public}u, authId=%{public}" PRId64, connFsm->id, *authId);
897 if (LnnSendDisconnectMsgToConnFsm(connFsm) != SOFTBUS_OK) {
898 LNN_LOGE(LNN_BUILDER, "send disconnect to connection failed. fsmId=%{public}u", connFsm->id);
899 rc = SOFTBUS_ERR;
900 break;
901 }
902 } while (false);
903 SoftBusFree((void *)authId);
904 return rc;
905 }
906
ProcessDeviceNotTrusted(const void * para)907 static int32_t ProcessDeviceNotTrusted(const void *para)
908 {
909 int32_t rc;
910 const char *udid = NULL;
911 LnnConnectionFsm *item = NULL;
912 const char *peerUdid = (const char *)para;
913
914 if (peerUdid == NULL) {
915 LNN_LOGW(LNN_BUILDER, "peer udid is null");
916 return SOFTBUS_INVALID_PARAM;
917 }
918
919 do {
920 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
921 if (LnnGetNetworkIdByUdid(peerUdid, networkId, sizeof(networkId)) == SOFTBUS_OK) {
922 LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_MAX);
923 break;
924 }
925 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
926 udid = LnnGetDeviceUdid(item->connInfo.nodeInfo);
927 if (udid == NULL || strcmp(peerUdid, udid) != 0) {
928 continue;
929 }
930 rc = LnnSendNotTrustedToConnFsm(item);
931 LNN_LOGI(LNN_BUILDER, "send not trusted msg to connection fsm. fsmId=%{public}u, result=%{public}d",
932 item->id, rc);
933 }
934 } while (false);
935 SoftBusFree((void *)peerUdid);
936 return SOFTBUS_OK;
937 }
938
ProcessLeaveLNNRequest(const void * para)939 static int32_t ProcessLeaveLNNRequest(const void *para)
940 {
941 const char *networkId = (const char *)para;
942 LnnConnectionFsm *item = NULL;
943 int rc = SOFTBUS_ERR;
944
945 if (networkId == NULL) {
946 LNN_LOGW(LNN_BUILDER, "leave networkId is null");
947 return SOFTBUS_INVALID_PARAM;
948 }
949
950 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
951 if (strcmp(networkId, item->connInfo.peerNetworkId) != 0 || item->isDead) {
952 continue;
953 }
954 if (LnnSendLeaveRequestToConnFsm(item) != SOFTBUS_OK) {
955 LNN_LOGE(LNN_BUILDER, "send leave LNN msg to connection failed. fsmId=%{public}u", item->id);
956 } else {
957 rc = SOFTBUS_OK;
958 item->connInfo.flag |= LNN_CONN_INFO_FLAG_LEAVE_REQUEST;
959 LNN_LOGI(LNN_BUILDER, "send leave LNN msg to connection success. fsmId=%{public}u", item->id);
960 }
961 }
962 if (rc != SOFTBUS_OK) {
963 LnnNotifyLeaveResult(networkId, SOFTBUS_ERR);
964 }
965 SoftBusFree((void *)networkId);
966 return rc;
967 }
968
ProcessSyncOfflineFinish(const void * para)969 static int32_t ProcessSyncOfflineFinish(const void *para)
970 {
971 const char *networkId = (const char *)para;
972 LnnConnectionFsm *item = NULL;
973 int rc = SOFTBUS_OK;
974
975 if (networkId == NULL) {
976 LNN_LOGW(LNN_BUILDER, "sync offline finish networkId is null");
977 return SOFTBUS_INVALID_PARAM;
978 }
979 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
980 if (strcmp(networkId, item->connInfo.peerNetworkId) != 0 || item->isDead) {
981 continue;
982 }
983 rc = LnnSendSyncOfflineFinishToConnFsm(item);
984 LNN_LOGI(LNN_BUILDER, "send sync offline msg to connection fsmId=%{public}u, result=%{public}d", item->id, rc);
985 }
986 SoftBusFree((void *)networkId);
987 return rc;
988 }
989
IsInvalidConnectionFsm(const LnnConnectionFsm * connFsm,const LeaveInvalidConnMsgPara * msgPara)990 static bool IsInvalidConnectionFsm(const LnnConnectionFsm *connFsm, const LeaveInvalidConnMsgPara *msgPara)
991 {
992 if (strcmp(msgPara->oldNetworkId, connFsm->connInfo.peerNetworkId) != 0) {
993 return false;
994 }
995 if (connFsm->isDead) {
996 LNN_LOGI(LNN_BUILDER, "connection is dead. fsmId=%{public}u", connFsm->id);
997 return false;
998 }
999 if (msgPara->addrType != CONNECTION_ADDR_MAX && msgPara->addrType != connFsm->connInfo.addr.type) {
1000 LNN_LOGI(LNN_BUILDER,
1001 "connection type not match. fsmId=%{public}u, msgAddrType=%{public}d, connAddrType=%{public}d", connFsm->id,
1002 msgPara->addrType, connFsm->connInfo.addr.type);
1003 return false;
1004 }
1005 if ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_ONLINE) == 0) {
1006 LNN_LOGI(LNN_BUILDER, "connection is not online. fsmId=%{public}u", connFsm->id);
1007 return false;
1008 }
1009 if ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_INITIATE_ONLINE) != 0) {
1010 LNN_LOGI(LNN_BUILDER, "connection is already in leaving. fsmId=%{public}u", connFsm->id);
1011 return false;
1012 }
1013 return true;
1014 }
1015
ProcessLeaveInvalidConn(const void * para)1016 static int32_t ProcessLeaveInvalidConn(const void *para)
1017 {
1018 LnnConnectionFsm *item = NULL;
1019 int32_t rc = SOFTBUS_OK;
1020 int32_t count = 0;
1021 const LeaveInvalidConnMsgPara *msgPara = (const LeaveInvalidConnMsgPara *)para;
1022
1023 if (msgPara == NULL) {
1024 LNN_LOGW(LNN_BUILDER, "leave invalid connection msg para is null");
1025 return SOFTBUS_INVALID_PARAM;
1026 }
1027 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
1028 if (!IsInvalidConnectionFsm(item, msgPara)) {
1029 continue;
1030 }
1031 // The new connFsm should timeout when following errors occur
1032 ++count;
1033 item->connInfo.cleanInfo = (LnnInvalidCleanInfo *)SoftBusMalloc(sizeof(LnnInvalidCleanInfo));
1034 if (item->connInfo.cleanInfo == NULL) {
1035 LNN_LOGI(LNN_BUILDER, "malloc invalid clean info failed. fsmId=%{public}u", item->id);
1036 continue;
1037 }
1038 item->connInfo.cleanInfo->addrType = msgPara->addrType;
1039 if (strncpy_s(item->connInfo.cleanInfo->networkId, NETWORK_ID_BUF_LEN,
1040 msgPara->newNetworkId, strlen(msgPara->newNetworkId)) != EOK) {
1041 LNN_LOGE(LNN_BUILDER, "copy new networkId failed. fsmId=%{public}u", item->id);
1042 rc = SOFTBUS_ERR;
1043 SoftBusFree(item->connInfo.cleanInfo);
1044 item->connInfo.cleanInfo = NULL;
1045 continue;
1046 }
1047 rc = LnnSendLeaveRequestToConnFsm(item);
1048 if (rc == SOFTBUS_OK) {
1049 item->connInfo.flag |= LNN_CONN_INFO_FLAG_INITIATE_ONLINE;
1050 item->connInfo.flag |= LNN_CONN_INFO_FLAG_LEAVE_AUTO;
1051 } else {
1052 SoftBusFree(item->connInfo.cleanInfo);
1053 item->connInfo.cleanInfo = NULL;
1054 }
1055 LNN_LOGI(
1056 LNN_BUILDER, "send leave LNN msg to invalid connection. fsmId=%{public}u, result=%{public}d", item->id, rc);
1057 }
1058 if (count == 0) {
1059 InitiateNewNetworkOnline(msgPara->addrType, msgPara->newNetworkId);
1060 }
1061 SoftBusFree((void *)msgPara);
1062 return rc;
1063 }
1064
TryElectMasterNodeOnline(const LnnConnectionFsm * connFsm)1065 static int32_t TryElectMasterNodeOnline(const LnnConnectionFsm *connFsm)
1066 {
1067 char peerMasterUdid[UDID_BUF_LEN] = { 0 };
1068 char localMasterUdid[UDID_BUF_LEN] = { 0 };
1069 int32_t peerMasterWeight, localMasterWeight;
1070 int32_t rc;
1071
1072 // get local master node info
1073 if (LnnGetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, localMasterUdid, UDID_BUF_LEN) != SOFTBUS_OK ||
1074 LnnGetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, &localMasterWeight) != SOFTBUS_OK) {
1075 LNN_LOGE(LNN_BUILDER, "get local master node info from ledger failed");
1076 return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
1077 }
1078 LNN_LOGI(LNN_BUILDER, "local master fsmId=%{public}u, weight=%{public}d", connFsm->id, localMasterWeight);
1079 if (LnnGetRemoteStrInfo(connFsm->connInfo.peerNetworkId, STRING_KEY_MASTER_NODE_UDID,
1080 peerMasterUdid, UDID_BUF_LEN) != SOFTBUS_OK ||
1081 LnnGetRemoteNumInfo(connFsm->connInfo.peerNetworkId, NUM_KEY_MASTER_NODE_WEIGHT,
1082 &peerMasterWeight) != SOFTBUS_OK) {
1083 LNN_LOGE(LNN_BUILDER, "peer node info is not found. fsmId=%{public}u", connFsm->id);
1084 return SOFTBUS_NETWORK_NOT_FOUND;
1085 }
1086 LNN_LOGI(LNN_BUILDER, "peer master fsmId=%{public}u, weight=%{public}d", connFsm->id, peerMasterWeight);
1087 rc = LnnCompareNodeWeight(localMasterWeight, localMasterUdid, peerMasterWeight, peerMasterUdid);
1088 if (rc >= 0) {
1089 LNN_LOGI(LNN_BUILDER,
1090 "online node weight less than current, no need elect again. fsmId=%{public}u, compareResult=%{public}d",
1091 connFsm->id, rc);
1092 return SOFTBUS_OK;
1093 }
1094 UpdateLocalMasterNode(false, peerMasterUdid, peerMasterWeight);
1095 SendElectMessageToAll(connFsm->connInfo.peerNetworkId);
1096 return SOFTBUS_OK;
1097 }
1098
TryElectMasterNodeOffline(const LnnConnectionFsm * connFsm)1099 static int32_t TryElectMasterNodeOffline(const LnnConnectionFsm *connFsm)
1100 {
1101 char localUdid[UDID_BUF_LEN] = { 0 };
1102 char localMasterUdid[UDID_BUF_LEN] = { 0 };
1103
1104 if (LnnGetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, localMasterUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
1105 LNN_LOGE(LNN_BUILDER, "get local master node info from ledger failed");
1106 return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
1107 }
1108 LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN);
1109 if (strcmp(localMasterUdid, localUdid) == 0) {
1110 LNN_LOGI(LNN_BUILDER, "local is master node, no need elect again. fsmId=%{public}u", connFsm->id);
1111 } else {
1112 LNN_LOGI(LNN_BUILDER, "maybe master node offline, elect again. fsmId=%{public}u", connFsm->id);
1113 UpdateLocalMasterNode(true, localUdid, LnnGetLocalWeight());
1114 SendElectMessageToAll(connFsm->connInfo.peerNetworkId);
1115 }
1116 return SOFTBUS_OK;
1117 }
1118
IsSupportMasterNodeElect(SoftBusVersion version)1119 static bool IsSupportMasterNodeElect(SoftBusVersion version)
1120 {
1121 LNN_LOGD(LNN_BUILDER, "SoftBusVersion=%{public}d", version);
1122 return version >= SOFTBUS_NEW_V1;
1123 }
1124
TryElectAsMasterState(const char * networkId,bool isOnline)1125 static void TryElectAsMasterState(const char *networkId, bool isOnline)
1126 {
1127 if (networkId == NULL) {
1128 LNN_LOGW(LNN_BUILDER, "invalid networkId");
1129 return;
1130 }
1131 if (isOnline) {
1132 LNN_LOGD(LNN_BUILDER, "restore master state ignore online process");
1133 return;
1134 }
1135 char masterUdid[UDID_BUF_LEN] = { 0 };
1136 char localUdid[UDID_BUF_LEN] = { 0 };
1137 if (LnnGetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, masterUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
1138 LNN_LOGE(LNN_BUILDER, "get local master node info from ledger failed");
1139 return;
1140 }
1141 const char *peerUdid = LnnConvertDLidToUdid(networkId, CATEGORY_NETWORK_ID);
1142 if (peerUdid == NULL) {
1143 char *anonyNetworkId = NULL;
1144 Anonymize(networkId, &anonyNetworkId);
1145 LNN_LOGE(LNN_BUILDER, "get invalid peerUdid, networkId=%{public}s", anonyNetworkId);
1146 AnonymizeFree(anonyNetworkId);
1147 return;
1148 }
1149 if (strcmp(masterUdid, peerUdid) != 0) {
1150 char *anonyPeerUdid = NULL;
1151 char *anonyMasterUdid = NULL;
1152 Anonymize(peerUdid, &anonyPeerUdid);
1153 Anonymize(masterUdid, &anonyMasterUdid);
1154 LNN_LOGD(LNN_BUILDER, "offline node is not master node. peerUdid=%{public}s, masterUdid=%{public}s",
1155 anonyPeerUdid, anonyMasterUdid);
1156 AnonymizeFree(anonyPeerUdid);
1157 AnonymizeFree(anonyMasterUdid);
1158 return;
1159 }
1160 if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
1161 LNN_LOGE(LNN_BUILDER, "get local udid failed");
1162 return;
1163 }
1164 UpdateLocalMasterNode(true, localUdid, LnnGetLocalWeight());
1165 }
1166
ProcessNodeStateChanged(const void * para)1167 static int32_t ProcessNodeStateChanged(const void *para)
1168 {
1169 const ConnectionAddr *addr = (const ConnectionAddr *)para;
1170 LnnConnectionFsm *connFsm = NULL;
1171 int32_t rc = SOFTBUS_ERR;
1172 bool isOnline = false;
1173
1174 if (addr == NULL) {
1175 LNN_LOGW(LNN_BUILDER, "node state changed msg is null");
1176 return SOFTBUS_INVALID_PARAM;
1177 }
1178 do {
1179 connFsm = FindConnectionFsmByAddr(addr, false);
1180 if (connFsm == NULL) {
1181 LNN_LOGE(LNN_BUILDER, "can't find connection fsm when node online state changed");
1182 break;
1183 }
1184 isOnline = IsNodeOnline(connFsm->connInfo.peerNetworkId);
1185 TryElectAsMasterState(connFsm->connInfo.peerNetworkId, isOnline);
1186 if (!IsSupportMasterNodeElect(connFsm->connInfo.version)) {
1187 LNN_LOGI(LNN_BUILDER, "peer not support master node elect. fsmId=%{public}u", connFsm->id);
1188 rc = SOFTBUS_OK;
1189 break;
1190 }
1191 rc = isOnline ? TryElectMasterNodeOnline(connFsm) : TryElectMasterNodeOffline(connFsm);
1192 } while (false);
1193 SoftBusFree((void *)addr);
1194 if (isOnline) {
1195 TryRemovePendingJoinRequest();
1196 }
1197 return rc;
1198 }
1199
ProcessMasterElect(const void * para)1200 static int32_t ProcessMasterElect(const void *para)
1201 {
1202 const ElectMsgPara *msgPara = (const ElectMsgPara *)para;
1203 LnnConnectionFsm *connFsm = NULL;
1204 char localMasterUdid[UDID_BUF_LEN] = { 0 };
1205 int32_t localMasterWeight, compareRet;
1206 int32_t rc = SOFTBUS_ERR;
1207
1208 if (msgPara == NULL) {
1209 LNN_LOGW(LNN_BUILDER, "elect msg para is null");
1210 return SOFTBUS_INVALID_PARAM;
1211 }
1212 do {
1213 connFsm = FindConnectionFsmByNetworkId(msgPara->networkId);
1214 if (connFsm == NULL || connFsm->isDead) {
1215 LNN_LOGE(LNN_BUILDER, "can't find connection fsm when receive elect node");
1216 break;
1217 }
1218 if (!IsNodeOnline(connFsm->connInfo.peerNetworkId)) {
1219 LNN_LOGE(LNN_BUILDER, "peer node is already offline. fsmId=%{public}u", connFsm->id);
1220 break;
1221 }
1222 if (LnnGetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, localMasterUdid, UDID_BUF_LEN) != SOFTBUS_OK ||
1223 LnnGetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, &localMasterWeight) != SOFTBUS_OK) {
1224 LNN_LOGE(LNN_BUILDER, "get local master node info from ledger failed. fsmId=%{public}u", connFsm->id);
1225 break;
1226 }
1227 compareRet = LnnCompareNodeWeight(localMasterWeight, localMasterUdid,
1228 msgPara->masterWeight, msgPara->masterUdid);
1229 LNN_LOGI(LNN_BUILDER, "weight compare result: fsmId=%{public}u, result=%{public}d", connFsm->id, compareRet);
1230 if (compareRet != 0) {
1231 if (compareRet < 0) {
1232 UpdateLocalMasterNode(false, msgPara->masterUdid, msgPara->masterWeight);
1233 SendElectMessageToAll(connFsm->connInfo.peerNetworkId);
1234 } else {
1235 rc = SyncElectMessage(connFsm->connInfo.peerNetworkId);
1236 LNN_LOGI(LNN_BUILDER, "sync elect info to connFsmId=%{public}u, result=%{public}d", connFsm->id, rc);
1237 }
1238 }
1239 rc = SOFTBUS_OK;
1240 } while (false);
1241 SoftBusFree((void *)msgPara);
1242 return rc;
1243 }
1244
ProcessLeaveByAddrType(const void * para)1245 static int32_t ProcessLeaveByAddrType(const void *para)
1246 {
1247 bool *addrType = NULL;
1248 LnnConnectionFsm *item = NULL;
1249 int32_t rc;
1250 bool notify = true;
1251
1252 if (para == NULL) {
1253 LNN_LOGW(LNN_BUILDER, "leave by addr type msg para is null");
1254 return SOFTBUS_INVALID_PARAM;
1255 }
1256
1257 addrType = (bool *)para;
1258 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
1259 if (!addrType[item->connInfo.addr.type]) {
1260 continue;
1261 }
1262 // if there are any same addr type, let last one send notify
1263 notify = false;
1264 if (item->isDead) {
1265 continue;
1266 }
1267 rc = LnnSendLeaveRequestToConnFsm(item);
1268 LNN_LOGI(LNN_BUILDER, "leave conn by addr. fsmId=%{public}u, type=%{public}d, rc=%{public}d", item->id,
1269 item->connInfo.addr.type, rc);
1270 if (rc == SOFTBUS_OK) {
1271 item->connInfo.flag |= LNN_CONN_INFO_FLAG_LEAVE_AUTO;
1272 }
1273 }
1274 LNN_LOGD(LNN_BUILDER, "notify=%{public}d, eth=%{public}d, wifi=%{public}d", notify, addrType[CONNECTION_ADDR_ETH],
1275 addrType[CONNECTION_ADDR_WLAN]);
1276 if (notify && (addrType[CONNECTION_ADDR_ETH] || addrType[CONNECTION_ADDR_WLAN])) {
1277 (void)LnnNotifyAllTypeOffline(CONNECTION_ADDR_MAX);
1278 }
1279 RemovePendingRequestByAddrType(addrType, CONNECTION_ADDR_MAX);
1280 SoftBusFree((void *)para);
1281 return SOFTBUS_OK;
1282 }
1283
ProcessLeaveSpecific(const void * para)1284 static int32_t ProcessLeaveSpecific(const void *para)
1285 {
1286 const SpecificLeaveMsgPara *msgPara = (const SpecificLeaveMsgPara *)para;
1287 LnnConnectionFsm *item = NULL;
1288
1289 if (msgPara == NULL) {
1290 LNN_LOGW(LNN_BUILDER, "leave specific msg is null");
1291 return SOFTBUS_INVALID_PARAM;
1292 }
1293
1294 int32_t rc;
1295 bool deviceLeave = false;
1296 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
1297 if (strcmp(item->connInfo.peerNetworkId, msgPara->networkId) != 0 ||
1298 (item->connInfo.addr.type != msgPara->addrType &&
1299 msgPara->addrType != CONNECTION_ADDR_MAX)) {
1300 continue;
1301 }
1302 deviceLeave = true;
1303 rc = LnnSendLeaveRequestToConnFsm(item);
1304 if (rc == SOFTBUS_OK) {
1305 item->connInfo.flag |= LNN_CONN_INFO_FLAG_LEAVE_AUTO;
1306 }
1307 LNN_LOGI(LNN_BUILDER, "send leave LNN msg to connection. fsmId=%{public}u, result=%{public}d", item->id, rc);
1308 }
1309
1310 if (deviceLeave) {
1311 SoftBusFree((void *)msgPara);
1312 return SOFTBUS_OK;
1313 }
1314
1315 do {
1316 NodeInfo nodeInfo;
1317 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1318 if (LnnGetRemoteNodeInfoById(msgPara->networkId, CATEGORY_NETWORK_ID, &nodeInfo)) {
1319 break;
1320 }
1321
1322 if (nodeInfo.deviceInfo.deviceTypeId != TYPE_PC_ID ||
1323 strcmp(nodeInfo.networkId, nodeInfo.deviceInfo.deviceUdid) != 0) {
1324 break;
1325 }
1326
1327 (void)LnnClearDiscoveryType(&nodeInfo, LnnConvAddrTypeToDiscType(msgPara->addrType));
1328 if (nodeInfo.discoveryType != 0) {
1329 LNN_LOGI(LNN_BUILDER, "pc without softbus has another discovery type");
1330 break;
1331 }
1332
1333 LNN_LOGI(LNN_BUILDER, "pc without softbus offline");
1334 DeleteFromProfile(nodeInfo.deviceInfo.deviceUdid);
1335 LnnRemoveNode(nodeInfo.deviceInfo.deviceUdid);
1336 } while (false);
1337 SoftBusFree((void *)msgPara);
1338 return SOFTBUS_OK;
1339 }
1340
DupNodeInfo(const NodeInfo * nodeInfo)1341 static NodeInfo *DupNodeInfo(const NodeInfo *nodeInfo)
1342 {
1343 NodeInfo *node = (NodeInfo *)SoftBusMalloc(sizeof(NodeInfo));
1344 if (node == NULL) {
1345 LNN_LOGE(LNN_BUILDER, "malloc NodeInfo fail");
1346 return NULL;
1347 }
1348 if (memcpy_s(node, sizeof(NodeInfo), nodeInfo, sizeof(NodeInfo)) != EOK) {
1349 LNN_LOGE(LNN_BUILDER, "copy NodeInfo fail");
1350 SoftBusFree(node);
1351 return NULL;
1352 }
1353 return node;
1354 }
1355
1356 static NetBuilderMessageProcess g_messageProcessor[MSG_TYPE_MAX] = {
1357 ProcessJoinLNNRequest,
1358 ProcessDevDiscoveryRequest,
1359 ProcessCleanConnectionFsm,
1360 ProcessVerifyResult,
1361 ProcessDeviceVerifyPass,
1362 ProcessDeviceDisconnect,
1363 ProcessDeviceNotTrusted,
1364 ProcessLeaveLNNRequest,
1365 ProcessSyncOfflineFinish,
1366 ProcessNodeStateChanged,
1367 ProcessMasterElect,
1368 ProcessLeaveInvalidConn,
1369 ProcessLeaveByAddrType,
1370 ProcessLeaveSpecific,
1371 };
1372
NetBuilderMessageHandler(SoftBusMessage * msg)1373 static void NetBuilderMessageHandler(SoftBusMessage *msg)
1374 {
1375 int32_t ret;
1376
1377 if (msg == NULL) {
1378 LNN_LOGE(LNN_BUILDER, "msg is null in net builder handler");
1379 return;
1380 }
1381 LNN_LOGI(LNN_BUILDER, "net builder process msg=%{public}d", msg->what);
1382 if (msg->what >= MSG_TYPE_MAX) {
1383 LNN_LOGE(LNN_BUILDER, "invalid msg type");
1384 return;
1385 }
1386 ret = g_messageProcessor[msg->what](msg->obj);
1387 LNN_LOGD(LNN_BUILDER, "net builder process msg done, msg=%{public}d, ret=%{public}d", msg->what, ret);
1388 }
1389
GetCurrentConnectType(void)1390 static ConnectionAddrType GetCurrentConnectType(void)
1391 {
1392 char ifCurrentName[NET_IF_NAME_LEN] = { 0 };
1393 ConnectionAddrType type = CONNECTION_ADDR_MAX;
1394
1395 if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifCurrentName, NET_IF_NAME_LEN) != SOFTBUS_OK) {
1396 LNN_LOGE(LNN_BUILDER, "LnnGetLocalStrInfo getCurrentConnectType failed");
1397 return type;
1398 }
1399 if (LnnGetAddrTypeByIfName(ifCurrentName, &type) != SOFTBUS_OK) {
1400 LNN_LOGE(LNN_BUILDER, "getCurrentConnectType unknown connect type");
1401 }
1402 return type;
1403 }
1404
OnDeviceVerifyPass(int64_t authId,const NodeInfo * info)1405 static void OnDeviceVerifyPass(int64_t authId, const NodeInfo *info)
1406 {
1407 AuthConnInfo connInfo;
1408 DeviceVerifyPassMsgPara *para = NULL;
1409 LNN_LOGI(LNN_BUILDER, "verify passed passively, authId=%{public}" PRId64, authId);
1410 if (AuthGetConnInfo(authId, &connInfo) != SOFTBUS_OK) {
1411 LNN_LOGE(LNN_BUILDER, "get AuthConnInfo fail, authId=%{public}" PRId64, authId);
1412 return;
1413 }
1414 para = (DeviceVerifyPassMsgPara *)SoftBusMalloc(sizeof(DeviceVerifyPassMsgPara));
1415 if (para == NULL) {
1416 LNN_LOGE(LNN_BUILDER, "malloc DeviceVerifyPassMsgPara fail");
1417 return;
1418 }
1419 if (!LnnConvertAuthConnInfoToAddr(¶->addr, &connInfo, GetCurrentConnectType())) {
1420 LNN_LOGE(LNN_BUILDER, "convert connInfo to addr fail");
1421 SoftBusFree(para);
1422 return;
1423 }
1424 para->authId = authId;
1425 para->nodeInfo = DupNodeInfo(info);
1426 if (para->nodeInfo == NULL) {
1427 LNN_LOGE(LNN_BUILDER, "dup NodeInfo fail");
1428 SoftBusFree(para);
1429 return;
1430 }
1431 if (PostMessageToHandler(MSG_TYPE_DEVICE_VERIFY_PASS, para) != SOFTBUS_OK) {
1432 LNN_LOGE(LNN_BUILDER, "post DEVICE_VERIFY_PASS msg fail");
1433 SoftBusFree(para->nodeInfo);
1434 SoftBusFree(para);
1435 }
1436 if (info != NULL) {
1437 LnnNotifyDeviceVerified(info->deviceInfo.deviceUdid);
1438 }
1439 }
1440
OnDeviceDisconnect(int64_t authId)1441 static void OnDeviceDisconnect(int64_t authId)
1442 {
1443 int64_t *para = NULL;
1444 para = (int64_t *)SoftBusMalloc(sizeof(int64_t));
1445 if (para == NULL) {
1446 LNN_LOGE(LNN_BUILDER, "malloc DeviceDisconnect para fail");
1447 return;
1448 }
1449 LNN_LOGI(LNN_BUILDER, "auth device disconnect, authId=%{public}" PRId64, authId);
1450 *para = authId;
1451 if (PostMessageToHandler(MSG_TYPE_DEVICE_DISCONNECT, para) != SOFTBUS_OK) {
1452 LNN_LOGE(LNN_BUILDER, "post DEVICE_DISCONNECT msg fail");
1453 SoftBusFree(para);
1454 }
1455 }
1456
OnLnnProcessNotTrustedMsgDelay(void * para)1457 static void OnLnnProcessNotTrustedMsgDelay(void *para)
1458 {
1459 if (para == NULL) {
1460 LNN_LOGW(LNN_BUILDER, "invalid para");
1461 return;
1462 }
1463 int64_t authSeq[DISCOVERY_TYPE_COUNT] = { 0 };
1464 NotTrustedDelayInfo *info = (NotTrustedDelayInfo *)para;
1465 if (!LnnGetOnlineStateById(info->udid, CATEGORY_UDID)) {
1466 LNN_LOGI(LNN_BUILDER, "device is offline");
1467 SoftBusFree(info);
1468 return;
1469 }
1470 if (AuthGetLatestAuthSeqList(info->udid, authSeq, DISCOVERY_TYPE_COUNT) != SOFTBUS_OK) {
1471 LNN_LOGE(LNN_BUILDER, "get latest authSeq list fail");
1472 SoftBusFree(info);
1473 return;
1474 }
1475 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
1476 if (LnnConvertDlId(info->udid, CATEGORY_UDID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
1477 LNN_LOGE(LNN_BUILDER, "LnnConvertDlId fail");
1478 SoftBusFree(info);
1479 return;
1480 }
1481 uint32_t type;
1482 for (type = DISCOVERY_TYPE_WIFI; type < DISCOVERY_TYPE_P2P; type++) {
1483 LNN_LOGI(
1484 LNN_BUILDER, "after 5s, authSeq:%{public}" PRId64 "->%{public}" PRId64, info->authSeq[type], authSeq[type]);
1485 if (authSeq[type] == info->authSeq[type] && authSeq[type] != 0 && info->authSeq[type] != 0) {
1486 char *anonyNetworkId = NULL;
1487 Anonymize(networkId, &anonyNetworkId);
1488 LNN_LOGI(LNN_BUILDER, "networkId=%{public}s, LnnRequestLeaveSpecificType=%{public}d", anonyNetworkId, type);
1489 AnonymizeFree(anonyNetworkId);
1490 LnnRequestLeaveSpecific(networkId, LnnDiscTypeToConnAddrType((DiscoveryType)type));
1491 continue;
1492 }
1493 }
1494 SoftBusFree(info);
1495 }
1496
LnnProcessCompleteNotTrustedMsg(LnnSyncInfoType syncType,const char * networkId,const uint8_t * msg,uint32_t len)1497 static void LnnProcessCompleteNotTrustedMsg(LnnSyncInfoType syncType, const char *networkId,
1498 const uint8_t *msg, uint32_t len)
1499 {
1500 if (networkId == NULL || syncType != LNN_INFO_TYPE_NOT_TRUSTED || msg == NULL) {
1501 LNN_LOGW(LNN_BUILDER, "invalid param");
1502 return;
1503 }
1504 if (!LnnGetOnlineStateById(networkId, CATEGORY_NETWORK_ID)) {
1505 LNN_LOGI(LNN_BUILDER, "device is offline");
1506 return;
1507 }
1508 JsonObj *json = JSON_Parse((const char *)msg, len);
1509 if (json == NULL) {
1510 LNN_LOGE(LNN_BUILDER, "json parse fail");
1511 return;
1512 }
1513 int64_t authSeq[DISCOVERY_TYPE_COUNT] = { 0 };
1514 (void)JSON_GetInt64FromOject(json, NETWORK_TYPE_WIFI, &authSeq[DISCOVERY_TYPE_WIFI]);
1515 (void)JSON_GetInt64FromOject(json, NETWORK_TYPE_BLE, &authSeq[DISCOVERY_TYPE_BLE]);
1516 (void)JSON_GetInt64FromOject(json, NETWORK_TYPE_BR, &authSeq[DISCOVERY_TYPE_BR]);
1517 JSON_Delete(json);
1518 int64_t curAuthSeq[DISCOVERY_TYPE_COUNT] = { 0 };
1519 char udid[UDID_BUF_LEN] = { 0 };
1520 (void)LnnConvertDlId(networkId, CATEGORY_NETWORK_ID, CATEGORY_UDID, udid, UDID_BUF_LEN);
1521 if (AuthGetLatestAuthSeqList(udid, curAuthSeq, DISCOVERY_TYPE_COUNT) != SOFTBUS_OK) {
1522 LNN_LOGE(LNN_BUILDER, "get latest authSeq fail");
1523 return;
1524 }
1525 uint32_t type;
1526 for (type = DISCOVERY_TYPE_WIFI; type < DISCOVERY_TYPE_P2P; type++) {
1527 LNN_LOGI(LNN_BUILDER, "authSeq:%{public}" PRId64 "->%{public}" PRId64, curAuthSeq[type], authSeq[type]);
1528 if (authSeq[type] == curAuthSeq[type] && authSeq[type] != 0 && curAuthSeq[type] != 0) {
1529 char *anonyNetworkId = NULL;
1530 Anonymize(networkId, &anonyNetworkId);
1531 LNN_LOGI(LNN_BUILDER, "networkId=%{public}s, LnnRequestLeaveSpecificType=%{public}d", anonyNetworkId, type);
1532 AnonymizeFree(anonyNetworkId);
1533 LnnRequestLeaveSpecific(networkId, LnnDiscTypeToConnAddrType((DiscoveryType)type));
1534 continue;
1535 }
1536 }
1537 }
1538
DeletePcNodeInfo(const char * peerUdid)1539 static bool DeletePcNodeInfo(const char *peerUdid)
1540 {
1541 NodeInfo *localNodeInfo = NULL;
1542 NodeInfo remoteNodeInfo;
1543 (void)memset_s(&remoteNodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1544 if (LnnGetRemoteNodeInfoById(peerUdid, CATEGORY_UDID, &remoteNodeInfo)) {
1545 LNN_LOGE(LNN_BUILDER, "get nodeInfo fail");
1546 return false;
1547 }
1548 if (strcmp(remoteNodeInfo.deviceInfo.deviceUdid, remoteNodeInfo.uuid) != 0) {
1549 LNN_LOGW(LNN_BUILDER, "isn't pc without softbus");
1550 return false;
1551 }
1552 localNodeInfo = (NodeInfo *)LnnGetLocalNodeInfo();
1553 if (localNodeInfo == NULL) {
1554 LNN_LOGE(LNN_BUILDER, "get localinfo fail");
1555 return false;
1556 }
1557 if (remoteNodeInfo.accountId == localNodeInfo->accountId) {
1558 LNN_LOGI(LNN_BUILDER, "exist sameAccount, don't handle offline");
1559 return false;
1560 }
1561 LNN_LOGI(LNN_BUILDER, "device not trust, delete pc online node");
1562 DeleteFromProfile(remoteNodeInfo.deviceInfo.deviceUdid);
1563 LnnRemoveNode(remoteNodeInfo.deviceInfo.deviceUdid);
1564 return true;
1565 }
1566
SelectUseUdid(const char * peerUdid,const char * lowerUdid)1567 static const char *SelectUseUdid(const char *peerUdid, const char *lowerUdid)
1568 {
1569 char *anonyPeerUdid = NULL;
1570 Anonymize(peerUdid, &anonyPeerUdid);
1571 if (LnnGetOnlineStateById(peerUdid, CATEGORY_UDID)) {
1572 LNN_LOGD(LNN_BUILDER, "not trusted device online! peerUdid=%{public}s", anonyPeerUdid);
1573 AnonymizeFree(anonyPeerUdid);
1574 return peerUdid;
1575 } else if (LnnGetOnlineStateById(lowerUdid, CATEGORY_UDID)) {
1576 char *anonyLowerUdid = NULL;
1577 Anonymize(peerUdid, &anonyLowerUdid);
1578 LNN_LOGD(LNN_BUILDER, "not trusted device online! peerUdid=%{public}s", anonyLowerUdid);
1579 AnonymizeFree(anonyLowerUdid);
1580 AnonymizeFree(anonyPeerUdid);
1581 return lowerUdid;
1582 } else {
1583 LNN_LOGW(LNN_BUILDER, "not trusted device not online! peerUdid=%{public}s", anonyPeerUdid);
1584 AnonymizeFree(anonyPeerUdid);
1585 return NULL;
1586 }
1587 }
1588
LnnDeleteLinkFinderInfo(const char * peerUdid)1589 static void LnnDeleteLinkFinderInfo(const char *peerUdid)
1590 {
1591 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
1592 if (LnnGetNetworkIdByUdid(peerUdid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
1593 LNN_LOGE(LNN_BUILDER, "get networkId fail.");
1594 return;
1595 }
1596
1597 if (LnnRemoveLinkFinderInfo(networkId) != SOFTBUS_OK) {
1598 LNN_LOGE(LNN_BUILDER, "remove a rpa info fail.");
1599 return;
1600 }
1601 }
1602
OnDeviceNotTrusted(const char * peerUdid)1603 static void OnDeviceNotTrusted(const char *peerUdid)
1604 {
1605 if (peerUdid == NULL) {
1606 LNN_LOGE(LNN_BUILDER, "invalid udid");
1607 return;
1608 }
1609 uint32_t udidLen = strlen(peerUdid) + 1;
1610 if (udidLen > UDID_BUF_LEN) {
1611 LNN_LOGE(LNN_BUILDER, "udid is too long");
1612 return;
1613 }
1614 if (DeletePcNodeInfo(peerUdid)) {
1615 LNN_LOGI(LNN_BUILDER, "pc without softbus, handle offline");
1616 return;
1617 }
1618 const char *useUdid = NULL;
1619 char udid[UDID_BUF_LEN] = { 0 };
1620 if (StringToLowerCase(peerUdid, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
1621 return;
1622 }
1623 useUdid = SelectUseUdid(peerUdid, udid);
1624 if (useUdid == NULL) {
1625 return;
1626 }
1627 LnnDeleteLinkFinderInfo(peerUdid);
1628 NotTrustedDelayInfo *info = (NotTrustedDelayInfo *)SoftBusCalloc(sizeof(NotTrustedDelayInfo));
1629 if (info == NULL) {
1630 LNN_LOGE(LNN_BUILDER, "malloc NotTrustedDelayInfo fail");
1631 return;
1632 }
1633 if (AuthGetLatestAuthSeqList(useUdid, info->authSeq, DISCOVERY_TYPE_COUNT) != SOFTBUS_OK) {
1634 LNN_LOGE(LNN_BUILDER, "get latest AuthSeq list fail");
1635 SoftBusFree(info);
1636 return;
1637 }
1638 if (strcpy_s(info->udid, UDID_BUF_LEN, useUdid) != EOK) {
1639 LNN_LOGE(LNN_BUILDER, "copy udid fail");
1640 SoftBusFree(info);
1641 return;
1642 }
1643 if (LnnSendNotTrustedInfo(info, DISCOVERY_TYPE_COUNT, LnnProcessCompleteNotTrustedMsg) != SOFTBUS_OK) {
1644 LNN_LOGE(LNN_BUILDER, "send NotTrustedInfo fail");
1645 OnLnnProcessNotTrustedMsgDelay((void *)info);
1646 return;
1647 }
1648 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), OnLnnProcessNotTrustedMsgDelay,
1649 (void *)info, NOT_TRUSTED_DEVICE_MSG_DELAY) != SOFTBUS_OK) {
1650 LNN_LOGE(LNN_BUILDER, "async not trusted msg delay fail");
1651 SoftBusFree(info);
1652 }
1653 }
1654
1655 static AuthVerifyListener g_verifyListener = {
1656 .onDeviceVerifyPass = OnDeviceVerifyPass,
1657 .onDeviceNotTrusted = OnDeviceNotTrusted,
1658 .onDeviceDisconnect = OnDeviceDisconnect,
1659 };
1660
PostVerifyResult(uint32_t requestId,int32_t retCode,int64_t authId,const NodeInfo * info)1661 static void PostVerifyResult(uint32_t requestId, int32_t retCode, int64_t authId, const NodeInfo *info)
1662 {
1663 VerifyResultMsgPara *para = NULL;
1664 para = (VerifyResultMsgPara *)SoftBusCalloc(sizeof(VerifyResultMsgPara));
1665 if (para == NULL) {
1666 LNN_LOGE(LNN_BUILDER, "malloc verify result msg para fail");
1667 return;
1668 }
1669 para->requestId = requestId;
1670 para->retCode = retCode;
1671 if (retCode == SOFTBUS_OK) {
1672 para->nodeInfo = DupNodeInfo(info);
1673 if (para->nodeInfo == NULL) {
1674 LNN_LOGE(LNN_BUILDER, "dup NodeInfo fail");
1675 SoftBusFree(para);
1676 return;
1677 }
1678 para->authId = authId;
1679 }
1680 if (PostMessageToHandler(MSG_TYPE_VERIFY_RESULT, para) != SOFTBUS_OK) {
1681 LNN_LOGE(LNN_BUILDER, "post verify result message failed");
1682 SoftBusFree(para->nodeInfo);
1683 SoftBusFree(para);
1684 }
1685 if (info != NULL && retCode == SOFTBUS_OK) {
1686 LnnNotifyDeviceVerified(info->deviceInfo.deviceUdid);
1687 }
1688 }
1689
OnVerifyPassed(uint32_t requestId,int64_t authId,const NodeInfo * info)1690 static void OnVerifyPassed(uint32_t requestId, int64_t authId, const NodeInfo *info)
1691 {
1692 LNN_LOGI(LNN_BUILDER, "verify passed. requestId=%{public}u, authId=%{public}" PRId64, requestId, authId);
1693 if (info == NULL) {
1694 LNN_LOGE(LNN_BUILDER, "post verify result message failed");
1695 return;
1696 }
1697 PostVerifyResult(requestId, SOFTBUS_OK, authId, info);
1698 }
1699
OnVerifyFailed(uint32_t requestId,int32_t reason)1700 static void OnVerifyFailed(uint32_t requestId, int32_t reason)
1701 {
1702 LNN_LOGI(LNN_BUILDER, "verify failed. requestId=%{public}u, reason=%{public}d", requestId, reason);
1703 PostVerifyResult(requestId, reason, AUTH_INVALID_ID, NULL);
1704 }
1705
1706 static AuthVerifyCallback g_verifyCallback = {
1707 .onVerifyPassed = OnVerifyPassed,
1708 .onVerifyFailed = OnVerifyFailed,
1709 };
1710
LnnGetVerifyCallback(void)1711 AuthVerifyCallback *LnnGetVerifyCallback(void)
1712 {
1713 return &g_verifyCallback;
1714 }
1715
OnReAuthVerifyPassed(uint32_t requestId,int64_t authId,const NodeInfo * info)1716 static void OnReAuthVerifyPassed(uint32_t requestId, int64_t authId, const NodeInfo *info)
1717 {
1718 LNN_LOGI(LNN_BUILDER, "reAuth verify passed. requestId=%{public}u, authId=%{public}" PRId64, requestId, authId);
1719 if (info == NULL) {
1720 LNN_LOGE(LNN_BUILDER, "reAuth verify result error");
1721 return;
1722 }
1723 AuthRequest authRequest = { 0 };
1724 if (GetAuthRequest(requestId, &authRequest) != SOFTBUS_OK) {
1725 LNN_LOGE(LNN_BUILDER, "auth request not found");
1726 return;
1727 }
1728 ConnectionAddr addr;
1729 (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
1730 if (!LnnConvertAuthConnInfoToAddr(&addr, &authRequest.connInfo, GetCurrentConnectType())) {
1731 LNN_LOGE(LNN_BUILDER, "ConvertToConnectionAddr failed");
1732 return;
1733 }
1734 int32_t ret = SoftBusGenerateStrHash((unsigned char *)info->deviceInfo.deviceUdid,
1735 strlen(info->deviceInfo.deviceUdid), (unsigned char *)addr.info.ble.udidHash);
1736 if (ret != SOFTBUS_OK) {
1737 LNN_LOGE(LNN_BUILDER, "gen udidHash fail");
1738 return;
1739 }
1740 LnnConnectionFsm *connFsm = FindConnectionFsmByAddr(&addr, true);
1741 if (connFsm != NULL && ((connFsm->connInfo.flag & LNN_CONN_INFO_FLAG_JOIN_PASSIVE) == 0)) {
1742 if (info != NULL && LnnUpdateGroupType(info) == SOFTBUS_OK && LnnUpdateAccountInfo(info) == SOFTBUS_OK) {
1743 UpdateProfile(info);
1744 NodeInfo nodeInfo;
1745 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1746 (void)LnnGetRemoteNodeInfoById(info->deviceInfo.deviceUdid, CATEGORY_UDID, &nodeInfo);
1747 UpdateDpSameAccount(nodeInfo.accountHash, nodeInfo.deviceInfo.deviceUdid);
1748 LNN_LOGI(LNN_BUILDER, "reauth finish and updateProfile");
1749 }
1750 } else {
1751 connFsm = StartNewConnectionFsm(&addr, DEFAULT_PKG_NAME, true);
1752 if (connFsm == NULL) {
1753 LNN_LOGE(LNN_BUILDER, "start new connection fsm fail. authId=%{public}" PRId64, authId);
1754 return;
1755 }
1756 connFsm->connInfo.authId = authId;
1757 connFsm->connInfo.nodeInfo = DupNodeInfo(info);
1758 connFsm->connInfo.flag |= LNN_CONN_INFO_FLAG_JOIN_AUTO;
1759 LNN_LOGI(LNN_BUILDER, "start a connection fsm, fsmId=%{public}u, authId=%{public}" PRId64, connFsm->id, authId);
1760 if (LnnSendAuthResultMsgToConnFsm(connFsm, SOFTBUS_OK) != SOFTBUS_OK) {
1761 connFsm->connInfo.nodeInfo = NULL;
1762 StopConnectionFsm(connFsm);
1763 LNN_LOGE(LNN_BUILDER, "post auth result to connection fsm fail. fsmId=%{public}u, authId=%{public}" PRId64,
1764 connFsm->id, authId);
1765 }
1766 }
1767 }
1768
OnReAuthVerifyFailed(uint32_t requestId,int32_t reason)1769 static void OnReAuthVerifyFailed(uint32_t requestId, int32_t reason)
1770 {
1771 LNN_LOGI(LNN_BUILDER, "verify failed. requestId=%{public}u, reason=%{public}d", requestId, reason);
1772 if (reason != SOFTBUS_AUTH_HICHAIN_AUTH_ERROR) {
1773 return;
1774 }
1775 PostVerifyResult(requestId, reason, AUTH_INVALID_ID, NULL);
1776 }
1777
1778 static AuthVerifyCallback g_reAuthVerifyCallback = {
1779 .onVerifyPassed = OnReAuthVerifyPassed,
1780 .onVerifyFailed = OnReAuthVerifyFailed,
1781 };
1782
LnnGetReAuthVerifyCallback(void)1783 AuthVerifyCallback *LnnGetReAuthVerifyCallback(void)
1784 {
1785 return &g_reAuthVerifyCallback;
1786 }
1787
FindNodeInfoByRquestId(uint32_t requestId)1788 NodeInfo *FindNodeInfoByRquestId(uint32_t requestId)
1789 {
1790 LnnConnectionFsm *connFsm = FindConnectionFsmByRequestId(requestId);
1791 if (connFsm == NULL || connFsm->isDead) {
1792 LNN_LOGE(LNN_BUILDER, "can not find connection fsm. requestId=%{public}u", requestId);
1793 return NULL;
1794 }
1795 LNN_LOGI(LNN_BUILDER, "find connFsm success");
1796 if (connFsm->connInfo.nodeInfo == NULL) {
1797 return NULL;
1798 }
1799 return connFsm->connInfo.nodeInfo;
1800 }
1801
FindRequestIdByAddr(ConnectionAddr * connetionAddr,uint32_t * requestId)1802 int32_t FindRequestIdByAddr(ConnectionAddr *connetionAddr, uint32_t *requestId)
1803 {
1804 if (requestId == NULL) {
1805 LNN_LOGE(LNN_BUILDER, "requestId is null");
1806 }
1807 LnnConnectionFsm *connFsm = FindConnectionFsmByAddr(connetionAddr, false);
1808 if (connFsm == NULL || connFsm->isDead) {
1809 LNN_LOGE(LNN_BUILDER, "can not find connection fsm by addr");
1810 return SOFTBUS_NETWORK_NOT_FOUND;
1811 }
1812 LNN_LOGD(LNN_BUILDER, "find connFsm success");
1813 *requestId = connFsm->connInfo.requestId;
1814 return SOFTBUS_OK;
1815 }
1816
CreateConnectionAddrMsgPara(const ConnectionAddr * addr)1817 static ConnectionAddr *CreateConnectionAddrMsgPara(const ConnectionAddr *addr)
1818 {
1819 ConnectionAddr *para = NULL;
1820
1821 if (addr == NULL) {
1822 LNN_LOGE(LNN_BUILDER, "addr is null");
1823 return NULL;
1824 }
1825 para = (ConnectionAddr *)SoftBusCalloc(sizeof(ConnectionAddr));
1826 if (para == NULL) {
1827 LNN_LOGE(LNN_BUILDER, "malloc connecton addr message fail");
1828 return NULL;
1829 }
1830 *para = *addr;
1831 return para;
1832 }
1833
CreateJoinLnnMsgPara(const ConnectionAddr * addr,const char * pkgName,bool isNeedConnect)1834 static JoinLnnMsgPara *CreateJoinLnnMsgPara(const ConnectionAddr *addr, const char *pkgName, bool isNeedConnect)
1835 {
1836 JoinLnnMsgPara *para = NULL;
1837
1838 if (addr == NULL || pkgName == NULL) {
1839 LNN_LOGE(LNN_BUILDER, "create join lnn msg para is null");
1840 return NULL;
1841 }
1842 para = (JoinLnnMsgPara *)SoftBusCalloc(sizeof(JoinLnnMsgPara));
1843 if (para == NULL) {
1844 LNN_LOGE(LNN_BUILDER, "malloc connecton addr message fail");
1845 return NULL;
1846 }
1847 if (strcpy_s(para->pkgName, PKG_NAME_SIZE_MAX, pkgName) != EOK) {
1848 LNN_LOGE(LNN_BUILDER, "copy pkgName fail");
1849 SoftBusFree(para);
1850 return NULL;
1851 }
1852 para->isNeedConnect = isNeedConnect;
1853 para->addr = *addr;
1854 return para;
1855 }
1856
BuildLnnEvent(LnnEventExtra * lnnEventExtra,ConnectionAddr * addr)1857 static void BuildLnnEvent(LnnEventExtra *lnnEventExtra, ConnectionAddr *addr)
1858 {
1859 if (lnnEventExtra == NULL || addr == NULL) {
1860 LNN_LOGW(LNN_STATE, "lnnEventExtra or addr is null");
1861 return;
1862 }
1863 switch (addr->type) {
1864 case CONNECTION_ADDR_BR:
1865 lnnEventExtra->peerBrMac = addr->info.br.brMac;
1866 break;
1867 case CONNECTION_ADDR_BLE:
1868 lnnEventExtra->peerBleMac = addr->info.ble.bleMac;
1869 break;
1870 case CONNECTION_ADDR_WLAN:
1871 /* fall-through */
1872 case CONNECTION_ADDR_ETH:
1873 lnnEventExtra->peerIp = addr->info.ip.ip;
1874 break;
1875 default:
1876 LNN_LOGE(LNN_BUILDER, "unknown param type!");
1877 break;
1878 }
1879 }
1880
DfxRecordLnnServerjoinEnd(ConnectionAddr * addr,const char * packageName,int32_t reason)1881 static void DfxRecordLnnServerjoinEnd(ConnectionAddr *addr, const char *packageName, int32_t reason)
1882 {
1883 LnnEventExtra extra = { 0 };
1884 LnnEventExtraInit(&extra);
1885 extra.errcode = reason;
1886 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
1887
1888 char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
1889 if (packageName != NULL && IsValidString(packageName, PKG_NAME_SIZE_MAX - 1) && strncpy_s(pkgName,
1890 PKG_NAME_SIZE_MAX, packageName, PKG_NAME_SIZE_MAX - 1) == EOK) {
1891 extra.callerPkg = pkgName;
1892 }
1893 if (addr != NULL) {
1894 BuildLnnEvent(&extra, addr);
1895 }
1896 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_JOIN_LNN_START, extra);
1897 }
1898
CreateNetworkIdMsgPara(const char * networkId)1899 static char *CreateNetworkIdMsgPara(const char *networkId)
1900 {
1901 char *para = NULL;
1902
1903 if (networkId == NULL) {
1904 LNN_LOGE(LNN_BUILDER, "networkId is null");
1905 return NULL;
1906 }
1907 para = (char *)SoftBusMalloc(NETWORK_ID_BUF_LEN);
1908 if (para == NULL) {
1909 LNN_LOGE(LNN_BUILDER, "malloc networkId message fail");
1910 return NULL;
1911 }
1912 if (strncpy_s(para, NETWORK_ID_BUF_LEN, networkId, strlen(networkId)) != EOK) {
1913 LNN_LOGE(LNN_BUILDER, "copy network id fail");
1914 SoftBusFree(para);
1915 return NULL;
1916 }
1917 return para;
1918 }
1919
ConifgLocalLedger(void)1920 static int32_t ConifgLocalLedger(void)
1921 {
1922 char uuid[UUID_BUF_LEN] = { 0 };
1923 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
1924 unsigned char irk[LFINDER_IRK_LEN] = { 0 };
1925
1926 // set local networkId and uuid
1927 if (LnnGenLocalNetworkId(networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK ||
1928 LnnGenLocalUuid(uuid, UUID_BUF_LEN) != SOFTBUS_OK) {
1929 LNN_LOGE(LNN_BUILDER, "get local id fail");
1930 return SOFTBUS_NOT_FIND;
1931 }
1932
1933 // irk fail should not cause softbus init fail
1934 if (LnnGenLocalIrk(irk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
1935 LNN_LOGE(LNN_BUILDER, "get local irk fail");
1936 }
1937 LnnSetLocalStrInfo(STRING_KEY_UUID, uuid);
1938 LnnSetLocalStrInfo(STRING_KEY_NETWORKID, networkId);
1939 LnnSetLocalByteInfo(BYTE_KEY_IRK, irk, LFINDER_IRK_LEN);
1940
1941 // irk fail should not cause softbus init fail
1942 if (LnnUpdateLinkFinderInfo() != SOFTBUS_OK) {
1943 LNN_LOGE(LNN_BUILDER, "sync rpa info to linkfinder fail.");
1944 }
1945 return SOFTBUS_OK;
1946 }
1947
OnReceiveMasterElectMsg(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)1948 static void OnReceiveMasterElectMsg(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
1949 {
1950 JsonObj *json = NULL;
1951 ElectMsgPara *para = NULL;
1952
1953 LNN_LOGI(LNN_BUILDER, "recv master elect msg, type=%{public}d, len=%{public}d", type, len);
1954 if (g_netBuilder.isInit == false) {
1955 LNN_LOGE(LNN_BUILDER, "no init");
1956 return;
1957 }
1958 if (type != LNN_INFO_TYPE_MASTER_ELECT) {
1959 return;
1960 }
1961 json = JSON_Parse((char *)msg, len);
1962 if (json == NULL) {
1963 LNN_LOGE(LNN_BUILDER, "parse elect msg json fail");
1964 return;
1965 }
1966 para = (ElectMsgPara *)SoftBusMalloc(sizeof(ElectMsgPara));
1967 if (para == NULL) {
1968 LNN_LOGE(LNN_BUILDER, "malloc elect msg para fail");
1969 JSON_Delete(json);
1970 return;
1971 }
1972 if (!JSON_GetInt32FromOject(json, JSON_KEY_MASTER_WEIGHT, ¶->masterWeight) ||
1973 !JSON_GetStringFromOject(json, JSON_KEY_MASTER_UDID, para->masterUdid, UDID_BUF_LEN)) {
1974 LNN_LOGE(LNN_BUILDER, "parse master info json fail");
1975 JSON_Delete(json);
1976 SoftBusFree(para);
1977 return;
1978 }
1979 JSON_Delete(json);
1980 if (strcpy_s(para->networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
1981 LNN_LOGE(LNN_BUILDER, "copy network id fail");
1982 SoftBusFree(para);
1983 return;
1984 }
1985 if (PostMessageToHandler(MSG_TYPE_MASTER_ELECT, para) != SOFTBUS_OK) {
1986 LNN_LOGE(LNN_BUILDER, "post elect message fail");
1987 SoftBusFree(para);
1988 }
1989 }
1990
LnnUnpackNodeAddr(const uint8_t * data,uint32_t dataLen,LnnNodeAddr * addr)1991 static int32_t LnnUnpackNodeAddr(const uint8_t *data, uint32_t dataLen, LnnNodeAddr *addr)
1992 {
1993 cJSON *json = cJSON_Parse((char *)data);
1994 if (json == NULL) {
1995 LNN_LOGE(LNN_BUILDER, "json parse failed");
1996 return SOFTBUS_PARSE_JSON_ERR;
1997 }
1998 if (!GetJsonObjectNumberItem(json, JSON_KEY_NODE_CODE, &addr->code) ||
1999 !GetJsonObjectStringItem(json, JSON_KEY_NODE_ADDR, addr->nodeAddr, SHORT_ADDRESS_MAX_LEN) ||
2000 !GetJsonObjectNumberItem(json, JSON_KEY_NODE_PROXY_PORT, &addr->proxyPort) ||
2001 !GetJsonObjectNumberItem(json, JSON_KEY_NODE_SESSION_PORT, &addr->sessionPort)) {
2002 LNN_LOGE(LNN_BUILDER, "parse addr info failed");
2003 cJSON_Delete(json);
2004 return SOFTBUS_PARSE_JSON_ERR;
2005 }
2006
2007 cJSON_Delete(json);
2008 return SOFTBUS_OK;
2009 }
2010
OnReceiveNodeAddrChangedMsg(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t size)2011 static void OnReceiveNodeAddrChangedMsg(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t size)
2012 {
2013 if (type != LNN_INFO_TYPE_NODE_ADDR) {
2014 return;
2015 }
2016 size_t addrLen = strnlen((const char *)msg, size);
2017 if (addrLen != size - 1 || addrLen == 0) {
2018 return;
2019 }
2020 char *anonyNetworkId = NULL;
2021 Anonymize(networkId, &anonyNetworkId);
2022 LNN_LOGI(LNN_BUILDER, "networkId=%{public}s", anonyNetworkId);
2023 AnonymizeFree(anonyNetworkId);
2024
2025 LnnNodeAddr addr;
2026 (void)memset_s(&addr, sizeof(LnnNodeAddr), 0, sizeof(LnnNodeAddr));
2027 if (LnnUnpackNodeAddr(msg, size, &addr) != SOFTBUS_OK) {
2028 return;
2029 }
2030
2031 SfcSyncNodeAddrHandle(networkId, addr.code);
2032
2033 if (LnnSetDLNodeAddr(networkId, CATEGORY_NETWORK_ID, addr.nodeAddr) != SOFTBUS_OK) {
2034 return;
2035 }
2036
2037 if (addr.proxyPort > 0) {
2038 (void)LnnSetDLProxyPort(networkId, CATEGORY_NETWORK_ID, addr.proxyPort);
2039 }
2040
2041 if (addr.sessionPort > 0) {
2042 (void)LnnSetDLSessionPort(networkId, CATEGORY_NETWORK_ID, addr.sessionPort);
2043 }
2044
2045 if (addr.authPort > 0) {
2046 (void)LnnSetDLAuthPort(networkId, CATEGORY_NETWORK_ID, addr.authPort);
2047 }
2048
2049 LnnNotifyNodeAddressChanged(addr.nodeAddr, networkId, false);
2050 }
2051
LnnUpdateNodeAddr(const char * addr)2052 int32_t LnnUpdateNodeAddr(const char *addr)
2053 {
2054 if (addr == NULL) {
2055 return SOFTBUS_INVALID_PARAM;
2056 }
2057
2058 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_NODE_ADDR, addr);
2059 if (ret != SOFTBUS_OK) {
2060 LNN_LOGE(LNN_BUILDER, "set local node addr failed");
2061 return ret;
2062 }
2063
2064 char localNetworkId[NETWORK_ID_BUF_LEN] = { 0 };
2065 ret = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, sizeof(localNetworkId));
2066 if (ret != SOFTBUS_OK) {
2067 LNN_LOGE(LNN_BUILDER, "get local network id failed");
2068 return SOFTBUS_NETWORK_NOT_FOUND;
2069 }
2070 LnnNotifyNodeAddressChanged(addr, localNetworkId, true);
2071
2072 return SOFTBUS_OK;
2073 }
2074
InitNodeInfoSync(void)2075 static int32_t InitNodeInfoSync(void)
2076 {
2077 if (LnnInitP2p() != SOFTBUS_OK) {
2078 LNN_LOGE(LNN_INIT, "init lnn p2p fail");
2079 return SOFTBUS_ERR;
2080 }
2081 if (LnnInitNetworkInfo() != SOFTBUS_OK) {
2082 LNN_LOGE(LNN_INIT, "LnnInitNetworkInfo fail");
2083 return SOFTBUS_ERR;
2084 }
2085 if (LnnInitDevicename() != SOFTBUS_OK) {
2086 LNN_LOGE(LNN_INIT, "LnnInitDeviceName fail");
2087 return SOFTBUS_ERR;
2088 }
2089 if (LnnInitOffline() != SOFTBUS_OK) {
2090 LNN_LOGE(LNN_INIT, "LnnInitOffline fail");
2091 return SOFTBUS_ERR;
2092 }
2093 if (LnnInitBatteryInfo() != SOFTBUS_OK) {
2094 LNN_LOGE(LNN_INIT, "LnnInitBatteryInfo fail");
2095 return SOFTBUS_ERR;
2096 }
2097 if (LnnInitCipherKeyManager() != SOFTBUS_OK) {
2098 LNN_LOGE(LNN_INIT, "LnnInitCipherKeyManager fail");
2099 return SOFTBUS_ERR;
2100 }
2101 if (LnnInitWifiDirect() != SOFTBUS_OK) {
2102 LNN_LOGE(LNN_INIT, "init lnn wifidirect addr fail");
2103 return SOFTBUS_ERR;
2104 }
2105 return SOFTBUS_OK;
2106 }
2107
DeinitNodeInfoSync(void)2108 static void DeinitNodeInfoSync(void)
2109 {
2110 LnnDeinitP2p();
2111 LnnDeinitNetworkInfo();
2112 LnnDeinitDevicename();
2113 LnnDeinitOffline();
2114 LnnDeinitBatteryInfo();
2115 LnnDeinitWifiDirect();
2116 }
2117
UpdatePCInfoWithoutSoftbus(void)2118 static void UpdatePCInfoWithoutSoftbus(void)
2119 {
2120 int32_t onlineNum = 0;
2121 NodeBasicInfo *info = NULL;
2122 if (LnnGetAllOnlineNodeInfo(&info, &onlineNum) != 0) {
2123 LNN_LOGE(LNN_BUILDER, "LnnGetAllOnlineNodeInfo failed!");
2124 return;
2125 }
2126 if (info == NULL || onlineNum == 0) {
2127 LNN_LOGW(LNN_BUILDER, "not online node");
2128 return;
2129 }
2130 // mark-- remove pc offline
2131 SoftBusFree(info);
2132 }
2133
AccountStateChangeHandler(const LnnEventBasicInfo * info)2134 static void AccountStateChangeHandler(const LnnEventBasicInfo *info)
2135 {
2136 if (info == NULL || info->event != LNN_EVENT_ACCOUNT_CHANGED) {
2137 LNN_LOGW(LNN_BUILDER, "invalid param");
2138 return;
2139 }
2140 const LnnMonitorHbStateChangedEvent *event = (const LnnMonitorHbStateChangedEvent *)info;
2141 SoftBusAccountState accountState = (SoftBusAccountState)event->status;
2142 switch (accountState) {
2143 case SOFTBUS_ACCOUNT_LOG_IN:
2144 LNN_LOGI(LNN_BUILDER, "ignore SOFTBUS_ACCOUNT_LOG_IN");
2145 break;
2146 case SOFTBUS_ACCOUNT_LOG_OUT:
2147 LNN_LOGI(LNN_BUILDER, "handle SOFTBUS_ACCOUNT_LOG_OUT");
2148 UpdatePCInfoWithoutSoftbus();
2149 break;
2150 default:
2151 return;
2152 }
2153 }
2154
LnnInitNetBuilder(void)2155 int32_t LnnInitNetBuilder(void)
2156 {
2157 if (g_netBuilder.isInit == true) {
2158 LNN_LOGI(LNN_INIT, "init net builder repeatly");
2159 return SOFTBUS_OK;
2160 }
2161 if (LnnInitSyncInfoManager() != SOFTBUS_OK) {
2162 LNN_LOGE(LNN_INIT, "init sync info manager fail");
2163 return SOFTBUS_ERR;
2164 }
2165 LnnInitTopoManager();
2166 InitNodeInfoSync();
2167 NetBuilderConfigInit();
2168 // link finder init fail will not cause softbus init fail
2169 if (LnnLinkFinderInit() != SOFTBUS_OK) {
2170 LNN_LOGE(LNN_INIT, "link finder init fail");
2171 }
2172 if (RegAuthVerifyListener(&g_verifyListener) != SOFTBUS_OK) {
2173 LNN_LOGE(LNN_INIT, "register auth verify listener fail");
2174 return SOFTBUS_ERR;
2175 }
2176 if (LnnRegSyncInfoHandler(LNN_INFO_TYPE_MASTER_ELECT, OnReceiveMasterElectMsg) != SOFTBUS_OK) {
2177 LNN_LOGE(LNN_INIT, "register sync master elect msg fail");
2178 return SOFTBUS_ERR;
2179 }
2180 if (LnnRegSyncInfoHandler(LNN_INFO_TYPE_NODE_ADDR, OnReceiveNodeAddrChangedMsg) != SOFTBUS_OK) {
2181 LNN_LOGE(LNN_INIT, "register node addr changed msg fail");
2182 return SOFTBUS_ERR;
2183 }
2184 if (ConifgLocalLedger() != SOFTBUS_OK) {
2185 LNN_LOGE(LNN_INIT, "config local ledger fail");
2186 return SOFTBUS_ERR;
2187 }
2188 if (LnnRegisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, AccountStateChangeHandler) != SOFTBUS_OK) {
2189 LNN_LOGE(LNN_INIT, "regist account change evt handler fail!");
2190 return SOFTBUS_ERR;
2191 }
2192 ListInit(&g_netBuilder.fsmList);
2193 ListInit(&g_netBuilder.pendingList);
2194 g_netBuilder.nodeType = NODE_TYPE_L;
2195 g_netBuilder.looper = GetLooper(LOOP_TYPE_DEFAULT);
2196 if (g_netBuilder.looper == NULL) {
2197 LNN_LOGE(LNN_INIT, "get default looper fail");
2198 return SOFTBUS_ERR;
2199 }
2200 g_netBuilder.handler.name = (char *)"NetBuilderHandler";
2201 g_netBuilder.handler.looper = g_netBuilder.looper;
2202 g_netBuilder.handler.HandleMessage = NetBuilderMessageHandler;
2203 g_netBuilder.isInit = true;
2204 LNN_LOGI(LNN_INIT, "init net builder success");
2205 return SOFTBUS_OK;
2206 }
2207
LnnInitNetBuilderDelay(void)2208 int32_t LnnInitNetBuilderDelay(void)
2209 {
2210 char udid[UDID_BUF_LEN] = { 0 };
2211 // set master weight and master udid
2212 int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN);
2213 if (ret != SOFTBUS_OK) {
2214 LNN_LOGE(LNN_INIT, "get local udid error!");
2215 return ret;
2216 }
2217 LnnSetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, udid);
2218 LnnSetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, LnnGetLocalWeight());
2219 if (LnnInitFastOffline() != SOFTBUS_OK) {
2220 LNN_LOGE(LNN_INIT, "fast offline init fail!");
2221 return SOFTBUS_ERR;
2222 }
2223 return SOFTBUS_OK;
2224 }
2225
LnnDeinitNetBuilder(void)2226 void LnnDeinitNetBuilder(void)
2227 {
2228 LnnConnectionFsm *item = NULL;
2229 LnnConnectionFsm *nextItem = NULL;
2230
2231 if (!g_netBuilder.isInit) {
2232 return;
2233 }
2234 LIST_FOR_EACH_ENTRY_SAFE(item, nextItem, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
2235 StopConnectionFsm(item);
2236 }
2237 LnnUnregSyncInfoHandler(LNN_INFO_TYPE_MASTER_ELECT, OnReceiveMasterElectMsg);
2238 LnnUnregSyncInfoHandler(LNN_INFO_TYPE_NODE_ADDR, OnReceiveNodeAddrChangedMsg);
2239 LnnUnregisterEventHandler(LNN_EVENT_ACCOUNT_CHANGED, AccountStateChangeHandler);
2240 UnregAuthVerifyListener();
2241 LnnDeinitTopoManager();
2242 DeinitNodeInfoSync();
2243 LnnDeinitFastOffline();
2244 LnnDeinitSyncInfoManager();
2245 g_netBuilder.isInit = false;
2246 }
2247
LnnServerJoin(ConnectionAddr * addr,const char * pkgName)2248 int32_t LnnServerJoin(ConnectionAddr *addr, const char *pkgName)
2249 {
2250 JoinLnnMsgPara *para = NULL;
2251
2252 LNN_LOGI(LNN_BUILDER, "enter!");
2253 if (g_netBuilder.isInit == false) {
2254 DfxRecordLnnServerjoinEnd(addr, pkgName, SOFTBUS_NO_INIT);
2255 LNN_LOGE(LNN_BUILDER, "no init");
2256 return SOFTBUS_NO_INIT;
2257 }
2258 para = CreateJoinLnnMsgPara(addr, pkgName, true);
2259 if (para == NULL) {
2260 DfxRecordLnnServerjoinEnd(addr, pkgName, SOFTBUS_MALLOC_ERR);
2261 LNN_LOGE(LNN_BUILDER, "prepare join lnn message fail");
2262 return SOFTBUS_MALLOC_ERR;
2263 }
2264 if (PostMessageToHandler(MSG_TYPE_JOIN_LNN, para) != SOFTBUS_OK) {
2265 DfxRecordLnnServerjoinEnd(addr, pkgName, SOFTBUS_NETWORK_LOOPER_ERR);
2266 LNN_LOGE(LNN_BUILDER, "post join lnn message fail");
2267 SoftBusFree(para);
2268 return SOFTBUS_NETWORK_LOOPER_ERR;
2269 }
2270 DfxRecordLnnServerjoinEnd(addr, pkgName, SOFTBUS_OK);
2271 return SOFTBUS_OK;
2272 }
2273
LnnServerLeave(const char * networkId,const char * pkgName)2274 int32_t LnnServerLeave(const char *networkId, const char *pkgName)
2275 {
2276 (void)pkgName;
2277 char *para = NULL;
2278
2279 LNN_LOGI(LNN_BUILDER, "enter");
2280 if (g_netBuilder.isInit == false) {
2281 LNN_LOGE(LNN_BUILDER, "no init");
2282 return SOFTBUS_NO_INIT;
2283 }
2284 para = CreateNetworkIdMsgPara(networkId);
2285 if (para == NULL) {
2286 LNN_LOGE(LNN_BUILDER, "prepare leave lnn message fail");
2287 return SOFTBUS_MALLOC_ERR;
2288 }
2289 if (PostMessageToHandler(MSG_TYPE_LEAVE_LNN, para) != SOFTBUS_OK) {
2290 LNN_LOGE(LNN_BUILDER, "post leave lnn message fail");
2291 SoftBusFree(para);
2292 return SOFTBUS_NETWORK_LOOPER_ERR;
2293 }
2294 return SOFTBUS_OK;
2295 }
2296
LnnNotifyDiscoveryDevice(const ConnectionAddr * addr,bool isNeedConnect)2297 int32_t LnnNotifyDiscoveryDevice(const ConnectionAddr *addr, bool isNeedConnect)
2298 {
2299 JoinLnnMsgPara *para = NULL;
2300
2301 LNN_LOGI(LNN_BUILDER, "notify discovery device enter! isNeedConnect=%{public}d", isNeedConnect);
2302 if (g_netBuilder.isInit == false) {
2303 LNN_LOGE(LNN_BUILDER, "no init");
2304 return SOFTBUS_NO_INIT;
2305 }
2306 para = CreateJoinLnnMsgPara(addr, DEFAULT_PKG_NAME, isNeedConnect);
2307 if (para == NULL) {
2308 LNN_LOGE(LNN_BUILDER, "malloc discovery device message fail");
2309 return SOFTBUS_MALLOC_ERR;
2310 }
2311 if (PostMessageToHandler(MSG_TYPE_DISCOVERY_DEVICE, para) != SOFTBUS_OK) {
2312 LNN_LOGE(LNN_BUILDER, "post notify discovery device message failed");
2313 SoftBusFree(para);
2314 return SOFTBUS_ERR;
2315 }
2316 return SOFTBUS_OK;
2317 }
2318
LnnRequestLeaveInvalidConn(const char * oldNetworkId,ConnectionAddrType addrType,const char * newNetworkId)2319 int32_t LnnRequestLeaveInvalidConn(const char *oldNetworkId, ConnectionAddrType addrType, const char *newNetworkId)
2320 {
2321 LeaveInvalidConnMsgPara *para = NULL;
2322
2323 if (g_netBuilder.isInit == false) {
2324 LNN_LOGE(LNN_BUILDER, "no init");
2325 return SOFTBUS_NO_INIT;
2326 }
2327 para = (LeaveInvalidConnMsgPara *)SoftBusMalloc(sizeof(LeaveInvalidConnMsgPara));
2328 if (para == NULL) {
2329 LNN_LOGE(LNN_BUILDER, "prepare leave invalid connection message fail");
2330 return SOFTBUS_MALLOC_ERR;
2331 }
2332 if (strncpy_s(para->oldNetworkId, NETWORK_ID_BUF_LEN, oldNetworkId, strlen(oldNetworkId)) != EOK ||
2333 strncpy_s(para->newNetworkId, NETWORK_ID_BUF_LEN, newNetworkId, strlen(newNetworkId)) != EOK) {
2334 LNN_LOGE(LNN_BUILDER, "copy old networkId or new networkId fail");
2335 SoftBusFree(para);
2336 return SOFTBUS_MALLOC_ERR;
2337 }
2338 para->addrType = addrType;
2339 if (PostMessageToHandler(MSG_TYPE_LEAVE_INVALID_CONN, para) != SOFTBUS_OK) {
2340 LNN_LOGE(LNN_BUILDER, "post leave invalid connection message failed");
2341 SoftBusFree(para);
2342 return SOFTBUS_ERR;
2343 }
2344 return SOFTBUS_OK;
2345 }
2346
LnnRequestCleanConnFsm(uint16_t connFsmId)2347 int32_t LnnRequestCleanConnFsm(uint16_t connFsmId)
2348 {
2349 uint16_t *para = NULL;
2350
2351 if (g_netBuilder.isInit == false) {
2352 LNN_LOGE(LNN_BUILDER, "no init");
2353 return SOFTBUS_ERR;
2354 }
2355 para = (uint16_t *)SoftBusMalloc(sizeof(uint16_t));
2356 if (para == NULL) {
2357 LNN_LOGE(LNN_BUILDER, "malloc clean connection fsm msg failed");
2358 return SOFTBUS_MALLOC_ERR;
2359 }
2360 *para = connFsmId;
2361 if (PostMessageToHandler(MSG_TYPE_CLEAN_CONN_FSM, para) != SOFTBUS_OK) {
2362 LNN_LOGE(LNN_BUILDER, "post request clean connectionlnn message failed");
2363 SoftBusFree(para);
2364 return SOFTBUS_ERR;
2365 }
2366 return SOFTBUS_OK;
2367 }
2368
LnnSyncOfflineComplete(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len)2369 void LnnSyncOfflineComplete(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len)
2370 {
2371 char *para = NULL;
2372
2373 (void)type;
2374 (void)msg;
2375 (void)len;
2376 if (g_netBuilder.isInit == false) {
2377 LNN_LOGE(LNN_BUILDER, "no init");
2378 return;
2379 }
2380 para = CreateNetworkIdMsgPara(networkId);
2381 if (para == NULL) {
2382 LNN_LOGE(LNN_BUILDER, "prepare notify sync offline message fail");
2383 return;
2384 }
2385 if (PostMessageToHandler(MSG_TYPE_SYNC_OFFLINE_FINISH, para) != SOFTBUS_OK) {
2386 LNN_LOGE(LNN_BUILDER, "post sync offline finish message failed");
2387 SoftBusFree(para);
2388 }
2389 }
2390
LnnNotifyNodeStateChanged(const ConnectionAddr * addr)2391 int32_t LnnNotifyNodeStateChanged(const ConnectionAddr *addr)
2392 {
2393 ConnectionAddr *para = NULL;
2394
2395 if (g_netBuilder.isInit == false) {
2396 LNN_LOGE(LNN_BUILDER, "no init");
2397 return SOFTBUS_NO_INIT;
2398 }
2399 para = CreateConnectionAddrMsgPara(addr);
2400 if (para == NULL) {
2401 LNN_LOGE(LNN_BUILDER, "create node state changed msg failed");
2402 return SOFTBUS_MALLOC_ERR;
2403 }
2404 if (PostMessageToHandler(MSG_TYPE_NODE_STATE_CHANGED, para) != SOFTBUS_OK) {
2405 LNN_LOGE(LNN_BUILDER, "post node state changed message failed");
2406 SoftBusFree(para);
2407 return SOFTBUS_ERR;
2408 }
2409 return SOFTBUS_OK;
2410 }
2411
LnnNotifyMasterElect(const char * networkId,const char * masterUdid,int32_t masterWeight)2412 int32_t LnnNotifyMasterElect(const char *networkId, const char *masterUdid, int32_t masterWeight)
2413 {
2414 ElectMsgPara *para = NULL;
2415
2416 if (g_netBuilder.isInit == false) {
2417 LNN_LOGE(LNN_BUILDER, "no init");
2418 return SOFTBUS_NO_INIT;
2419 }
2420 if (networkId == NULL || masterUdid == NULL) {
2421 LNN_LOGE(LNN_BUILDER, "invalid elect msg para");
2422 return SOFTBUS_INVALID_PARAM;
2423 }
2424 para = (ElectMsgPara *)SoftBusMalloc(sizeof(ElectMsgPara));
2425 if (para == NULL) {
2426 LNN_LOGE(LNN_BUILDER, "malloc elect msg para failed");
2427 return SOFTBUS_MEM_ERR;
2428 }
2429 if (strncpy_s(para->networkId, NETWORK_ID_BUF_LEN, networkId, strlen(networkId)) != EOK ||
2430 strncpy_s(para->masterUdid, UDID_BUF_LEN, masterUdid, strlen(masterUdid)) != EOK) {
2431 LNN_LOGE(LNN_BUILDER, "copy udid and maser udid failed");
2432 SoftBusFree(para);
2433 return SOFTBUS_ERR;
2434 }
2435 para->masterWeight = masterWeight;
2436 if (PostMessageToHandler(MSG_TYPE_MASTER_ELECT, para) != SOFTBUS_OK) {
2437 LNN_LOGE(LNN_BUILDER, "post elect message failed");
2438 SoftBusFree(para);
2439 return SOFTBUS_ERR;
2440 }
2441 return SOFTBUS_OK;
2442 }
2443
2444 /* Note: must called in connection fsm. */
LnnNotifyAuthHandleLeaveLNN(int64_t authId)2445 int32_t LnnNotifyAuthHandleLeaveLNN(int64_t authId)
2446 {
2447 LnnConnectionFsm *item = NULL;
2448
2449 if (g_netBuilder.isInit == false) {
2450 LNN_LOGE(LNN_BUILDER, "no init");
2451 return SOFTBUS_NO_INIT;
2452 }
2453
2454 LIST_FOR_EACH_ENTRY(item, &g_netBuilder.fsmList, LnnConnectionFsm, node) {
2455 if (item->isDead) {
2456 continue;
2457 }
2458 if (item->connInfo.authId == authId) {
2459 LNN_LOGI(
2460 LNN_BUILDER, "connection fsm already use. fsmId=%{public}u, authId=%{public}" PRId64, item->id, authId);
2461 return SOFTBUS_OK;
2462 }
2463 }
2464 AuthHandleLeaveLNN(authId);
2465 return SOFTBUS_OK;
2466 }
2467
LnnRequestLeaveByAddrType(const bool * type,uint32_t typeLen)2468 int32_t LnnRequestLeaveByAddrType(const bool *type, uint32_t typeLen)
2469 {
2470 if (type == NULL) {
2471 LNN_LOGE(LNN_BUILDER, "para is null");
2472 return SOFTBUS_INVALID_PARAM;
2473 }
2474 bool *para = NULL;
2475 if (typeLen != CONNECTION_ADDR_MAX) {
2476 LNN_LOGE(LNN_BUILDER, "invalid typeLen");
2477 return SOFTBUS_ERR;
2478 }
2479 LNN_LOGD(LNN_BUILDER, "wlan=%{public}d, br=%{public}d, ble=%{public}d, eth=%{public}d", type[CONNECTION_ADDR_WLAN],
2480 type[CONNECTION_ADDR_BR], type[CONNECTION_ADDR_BLE], type[CONNECTION_ADDR_ETH]);
2481 if (g_netBuilder.isInit == false) {
2482 LNN_LOGE(LNN_BUILDER, "no init");
2483 return SOFTBUS_NO_INIT;
2484 }
2485 para = (bool *)SoftBusMalloc(sizeof(bool) * typeLen);
2486 if (para == NULL) {
2487 LNN_LOGE(LNN_BUILDER, "malloc leave by addr type msg para failed");
2488 return SOFTBUS_MALLOC_ERR;
2489 }
2490 if (memcpy_s(para, sizeof(bool) * typeLen, type, sizeof(bool) * typeLen) != EOK) {
2491 LNN_LOGE(LNN_BUILDER, "memcopy para fail");
2492 SoftBusFree(para);
2493 return SOFTBUS_MEM_ERR;
2494 }
2495 if (PostMessageToHandler(MSG_TYPE_LEAVE_BY_ADDR_TYPE, para) != SOFTBUS_OK) {
2496 LNN_LOGE(LNN_BUILDER, "post leave by addr type message failed");
2497 SoftBusFree(para);
2498 return SOFTBUS_ERR;
2499 }
2500 return SOFTBUS_OK;
2501 }
2502
LnnRequestLeaveSpecific(const char * networkId,ConnectionAddrType addrType)2503 int32_t LnnRequestLeaveSpecific(const char *networkId, ConnectionAddrType addrType)
2504 {
2505 SpecificLeaveMsgPara *para = NULL;
2506
2507 if (networkId == NULL) {
2508 return SOFTBUS_INVALID_PARAM;
2509 }
2510 if (g_netBuilder.isInit == false) {
2511 LNN_LOGE(LNN_BUILDER, "no init");
2512 return SOFTBUS_NO_INIT;
2513 }
2514 para = (SpecificLeaveMsgPara *)SoftBusCalloc(sizeof(SpecificLeaveMsgPara));
2515 if (para == NULL) {
2516 LNN_LOGE(LNN_BUILDER, "malloc specific msg fail");
2517 return SOFTBUS_MALLOC_ERR;
2518 }
2519 if (strcpy_s(para->networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
2520 LNN_LOGE(LNN_BUILDER, "copy networkId fail");
2521 SoftBusFree(para);
2522 return SOFTBUS_STRCPY_ERR;
2523 }
2524 para->addrType = addrType;
2525 if (PostMessageToHandler(MSG_TYPE_LEAVE_SPECIFIC, para) != SOFTBUS_OK) {
2526 LNN_LOGE(LNN_BUILDER, "post leave specific msg failed");
2527 SoftBusFree(para);
2528 return SOFTBUS_ERR;
2529 }
2530 return SOFTBUS_OK;
2531 }
2532
LnnRequestLeaveAllOnlineNodes(void)2533 void LnnRequestLeaveAllOnlineNodes(void)
2534 {
2535 int32_t onlineNum;
2536 NodeBasicInfo *info;
2537 char *para = NULL;
2538 if (LnnGetAllOnlineNodeInfo(&info, &onlineNum) != 0) {
2539 LNN_LOGE(LNN_BUILDER, "LnnGetAllOnlineNodeInfo failed");
2540 return;
2541 }
2542 if (info == NULL || onlineNum == 0) {
2543 LNN_LOGW(LNN_BUILDER, "none online node");
2544 return;
2545 }
2546 for (int32_t i = 0; i < onlineNum; i++) {
2547 para = CreateNetworkIdMsgPara(info[i].networkId);
2548 if (para == NULL) {
2549 LNN_LOGE(LNN_BUILDER, "prepare leave lnn message fail");
2550 break;
2551 }
2552 if (PostMessageToHandler(MSG_TYPE_LEAVE_LNN, para) != SOFTBUS_OK) {
2553 LNN_LOGE(LNN_BUILDER, "post leave lnn message failed");
2554 SoftBusFree(para);
2555 break;
2556 }
2557 }
2558 SoftBusFree(info);
2559 }