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 "bus_center_event.h"
17 
18 #include <securec.h>
19 #include <stdlib.h>
20 
21 #include "anonymizer.h"
22 #include "bus_center_decision_center.h"
23 #include "bus_center_event.h"
24 #include "bus_center_manager.h"
25 #include "lnn_bus_center_ipc.h"
26 #include "lnn_cipherkey_manager.h"
27 #include "lnn_device_info_recovery.h"
28 #include "lnn_distributed_net_ledger.h"
29 #include "lnn_log.h"
30 #include "lnn_network_id.h"
31 #include "lnn_p2p_info.h"
32 #include "lnn_connection_addr_utils.h"
33 #include "message_handler.h"
34 #include "softbus_adapter_crypto.h"
35 #include "softbus_adapter_mem.h"
36 #include "softbus_adapter_thread.h"
37 #include "softbus_def.h"
38 #include "softbus_errcode.h"
39 #include "softbus_qos.h"
40 
41 typedef struct {
42     ListNode node;
43     LnnEventHandler handler;
44 } LnnEventHandlerItem;
45 
46 typedef struct {
47     ListNode handlers[LNN_EVENT_TYPE_MAX];
48     uint32_t regCnt[LNN_EVENT_TYPE_MAX];
49     SoftBusMutex lock;
50 } BusCenterEventCtrl;
51 
52 typedef enum {
53     NOTIFY_ONLINE_STATE_CHANGED = 0,
54     NOTIFY_NODE_BASIC_INFO_CHANGED,
55     NOTIFY_NODE_STATUS_CHANGED,
56     NOTIFY_NETWORKID_UPDATE,
57     NOTIFY_LOCAL_NETWORKID_UPDATE,
58 } NotifyType;
59 
60 #define NETWORK_ID_UPDATE_DELAY_TIME (60 * 60 * 1000 * 24) // 24 hour
61 #define NETWORK_ID_MAX_TTL (7 * 60 * 60 * 1000 * 24) // 7 * 24 hour
62 #define NETWORK_ID_MIN_UPDATE_DELAY_TIME (5 * 60 * 1000) // 5min
63 
64 static BusCenterEventCtrl g_eventCtrl;
65 static SoftBusHandler g_notifyHandler = {"NotifyHandler", NULL, NULL};
66 
PostMessageToHandlerDelay(SoftBusMessage * msg,uint64_t delayMillis)67 static int32_t PostMessageToHandlerDelay(SoftBusMessage *msg, uint64_t delayMillis)
68 {
69     if (g_notifyHandler.looper == NULL) {
70         LNN_LOGE(LNN_EVENT, "NotifyHandler not initialized");
71         FreeMessage(msg);
72         return SOFTBUS_NO_INIT;
73     }
74     if (g_notifyHandler.looper->PostMessage == NULL || g_notifyHandler.looper->PostMessageDelay == NULL) {
75         LNN_LOGE(LNN_EVENT, "invalid looper");
76         FreeMessage(msg);
77         return SOFTBUS_INVALID_PARAM;
78     }
79     if (delayMillis == 0) {
80         g_notifyHandler.looper->PostMessage(g_notifyHandler.looper, msg);
81     } else {
82         g_notifyHandler.looper->PostMessageDelay(g_notifyHandler.looper, msg, delayMillis);
83     }
84     return SOFTBUS_OK;
85 }
86 
RemoveNotifyMessage(int32_t what)87 static void RemoveNotifyMessage(int32_t what)
88 {
89     if (g_notifyHandler.looper == NULL) {
90         LNN_LOGE(LNN_EVENT, "looper not initialized, can't remove message");
91         return;
92     }
93     if (g_notifyHandler.looper->RemoveMessage == NULL) {
94         LNN_LOGE(LNN_EVENT, "removeMessage is null");
95         return;
96     }
97     g_notifyHandler.looper->RemoveMessage(g_notifyHandler.looper, &g_notifyHandler, what);
98 }
99 
HandleOnlineStateChangedMessage(SoftBusMessage * msg)100 static void HandleOnlineStateChangedMessage(SoftBusMessage *msg)
101 {
102     if (msg->obj == NULL) {
103         LNN_LOGE(LNN_EVENT, "invalid online state message");
104         return;
105     }
106     bool isOnline = (bool)msg->arg1;
107     LnnIpcNotifyOnlineState(isOnline, msg->obj, sizeof(NodeBasicInfo));
108     LnnDCProcessOnlineState(isOnline, (NodeBasicInfo *)msg->obj);
109 }
110 
HandleNodeBasicInfoChangedMessage(SoftBusMessage * msg)111 static void HandleNodeBasicInfoChangedMessage(SoftBusMessage *msg)
112 {
113     if (msg->obj == NULL) {
114         LNN_LOGE(LNN_EVENT, "invalid node basic info message");
115         return;
116     }
117     int32_t type = (int32_t)msg->arg1;
118     LnnIpcNotifyBasicInfoChanged(msg->obj, sizeof(NodeBasicInfo), type);
119 }
120 
HandleNodeStatusChangedMessage(SoftBusMessage * msg)121 static void HandleNodeStatusChangedMessage(SoftBusMessage *msg)
122 {
123     if (msg->obj == NULL) {
124         LNN_LOGE(LNN_EVENT, "invalid node status message");
125         return;
126     }
127     int32_t type = (int32_t)msg->arg1;
128     LnnIpcNotifyNodeStatusChanged(msg->obj, sizeof(NodeStatus), type);
129 }
130 
HandleLocalNetworkIdChangedMessage(void)131 static void HandleLocalNetworkIdChangedMessage(void)
132 {
133     LnnIpcLocalNetworkIdChanged();
134 }
135 
HandleNetworkUpdateMessage(SoftBusMessage * msg)136 static void HandleNetworkUpdateMessage(SoftBusMessage *msg)
137 {
138     (void)msg;
139     char networkId[NETWORK_ID_BUF_LEN] = {0};
140     if (LnnGenLocalNetworkId(networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
141         LNN_LOGE(LNN_EVENT, "generate networkid fail");
142         return;
143     }
144     LnnSetLocalStrInfo(STRING_KEY_NETWORKID, networkId);
145     LnnNotifyNetworkIdChangeEvent(networkId);
146     LnnNotifyLocalNetworkIdChanged();
147     LnnUpdateAuthExchangeUdid();
148     LNN_LOGD(LNN_EVENT, "offline exceted 5min, process networkId update event");
149 }
150 
HandleNotifyMessage(SoftBusMessage * msg)151 static void HandleNotifyMessage(SoftBusMessage *msg)
152 {
153     if (msg == NULL) {
154         LNN_LOGE(LNN_EVENT, "invalid notify message");
155         return;
156     }
157     LNN_LOGI(LNN_EVENT, "handle notify msgType=%{public}d", msg->what);
158     switch (msg->what) {
159         case NOTIFY_ONLINE_STATE_CHANGED:
160             HandleOnlineStateChangedMessage(msg);
161             break;
162         case NOTIFY_NODE_BASIC_INFO_CHANGED:
163             HandleNodeBasicInfoChangedMessage(msg);
164             break;
165         case NOTIFY_NODE_STATUS_CHANGED:
166             HandleNodeStatusChangedMessage(msg);
167             break;
168         case NOTIFY_LOCAL_NETWORKID_UPDATE:
169             HandleLocalNetworkIdChangedMessage();
170             break;
171         case NOTIFY_NETWORKID_UPDATE:
172             HandleNetworkUpdateMessage(msg);
173             break;
174         default:
175             LNN_LOGE(LNN_EVENT, "unknown notify msgType=%{public}d", msg->what);
176             break;
177     }
178 }
179 
FreeNotifyMessage(SoftBusMessage * msg)180 static void FreeNotifyMessage(SoftBusMessage *msg)
181 {
182     if (msg == NULL) {
183         return;
184     }
185     if (msg->obj != NULL) {
186         SoftBusFree(msg->obj);
187         msg->obj = NULL;
188     }
189     SoftBusFree(msg);
190 }
191 
DupNodeBasicInfo(const NodeBasicInfo * info)192 static NodeBasicInfo *DupNodeBasicInfo(const NodeBasicInfo *info)
193 {
194     if (info == NULL) {
195         LNN_LOGW(LNN_EVENT, "info is null");
196         return NULL;
197     }
198     NodeBasicInfo *dupInfo = SoftBusMalloc(sizeof(NodeBasicInfo));
199     if (dupInfo == NULL) {
200         LNN_LOGE(LNN_EVENT, "malloc NodeBasicInfo err");
201         return NULL;
202     }
203     if (memcpy_s(dupInfo, sizeof(NodeBasicInfo), info, sizeof(NodeBasicInfo)) != EOK) {
204         LNN_LOGE(LNN_EVENT, "copy NodeBasicInfo fail");
205         SoftBusFree(dupInfo);
206         return NULL;
207     }
208     return dupInfo;
209 }
210 
DupNodeStatus(const NodeStatus * nodeStatus)211 static NodeStatus *DupNodeStatus(const NodeStatus *nodeStatus)
212 {
213     if (nodeStatus == NULL) {
214         LNN_LOGW(LNN_EVENT, "nodeStatus is null");
215         return NULL;
216     }
217     NodeStatus *dupInfo = SoftBusCalloc(sizeof(NodeStatus));
218     if (dupInfo == NULL) {
219         LNN_LOGE(LNN_EVENT, "malloc NodeStatus err");
220         return NULL;
221     }
222     if (memcpy_s(dupInfo, sizeof(NodeStatus), nodeStatus, sizeof(NodeStatus)) != EOK) {
223         LNN_LOGE(LNN_EVENT, "copy NodeStatus fail");
224         SoftBusFree(dupInfo);
225         return NULL;
226     }
227     return dupInfo;
228 }
229 
PostNotifyMessage(int32_t what,uint64_t arg,const NodeBasicInfo * info)230 static int32_t PostNotifyMessage(int32_t what, uint64_t arg, const NodeBasicInfo *info)
231 {
232     SoftBusMessage *msg = SoftBusCalloc(sizeof(SoftBusMessage));
233     if (msg == NULL) {
234         LNN_LOGE(LNN_EVENT, "malloc msg err");
235         return SOFTBUS_MALLOC_ERR;
236     }
237     msg->what = what;
238     msg->arg1 = arg;
239     msg->obj = DupNodeBasicInfo(info);
240     if (msg->obj == NULL) {
241         LNN_LOGE(LNN_EVENT, "dup NodeBasicInfo err");
242         SoftBusFree(msg);
243         return SOFTBUS_MEM_ERR;
244     }
245     msg->handler = &g_notifyHandler;
246     msg->FreeMessage = FreeNotifyMessage;
247     return PostMessageToHandlerDelay(msg, 0);
248 }
249 
PostNotifyNodeStatusMessage(int32_t what,uint64_t arg,const NodeStatus * info)250 static int32_t PostNotifyNodeStatusMessage(int32_t what, uint64_t arg, const NodeStatus *info)
251 {
252     SoftBusMessage *msg = SoftBusCalloc(sizeof(SoftBusMessage));
253     if (msg == NULL) {
254         LNN_LOGE(LNN_EVENT, "malloc msg err");
255         return SOFTBUS_MALLOC_ERR;
256     }
257     msg->what = what;
258     msg->arg1 = arg;
259     msg->obj = DupNodeStatus(info);
260     if (msg->obj == NULL) {
261         LNN_LOGE(LNN_EVENT, "dup NodeStatus err");
262         SoftBusFree(msg);
263         return SOFTBUS_MEM_ERR;
264     }
265     msg->handler = &g_notifyHandler;
266     msg->FreeMessage = FreeNotifyMessage;
267     return PostMessageToHandlerDelay(msg, 0);
268 }
269 
PostNotifyMessageDelay(int32_t what,uint64_t delayMillis)270 static int32_t PostNotifyMessageDelay(int32_t what, uint64_t delayMillis)
271 {
272     SoftBusMessage *msg = SoftBusCalloc(sizeof(SoftBusMessage));
273     if (msg == NULL) {
274         LNN_LOGE(LNN_EVENT, "malloc msg fail");
275         return SOFTBUS_MALLOC_ERR;
276     }
277     msg->what = what;
278     msg->handler = &g_notifyHandler;
279     msg->FreeMessage = FreeNotifyMessage;
280     return PostMessageToHandlerDelay(msg, delayMillis);
281 }
282 
IsRepeatEventHandler(LnnEventType event,LnnEventHandler handler)283 static bool IsRepeatEventHandler(LnnEventType event, LnnEventHandler handler)
284 {
285     LnnEventHandlerItem *item = NULL;
286 
287     LIST_FOR_EACH_ENTRY(item, &g_eventCtrl.handlers[event], LnnEventHandlerItem, node) {
288         if (item->handler == handler) {
289             return true;
290         }
291     }
292     return false;
293 }
294 
CreateEventHandlerItem(LnnEventHandler handler)295 static LnnEventHandlerItem *CreateEventHandlerItem(LnnEventHandler handler)
296 {
297     LnnEventHandlerItem *item = SoftBusMalloc(sizeof(LnnEventHandlerItem));
298 
299     if (item == NULL) {
300         return NULL;
301     }
302     ListInit(&item->node);
303     item->handler = handler;
304     return item;
305 }
306 
NotifyEvent(const LnnEventBasicInfo * info)307 static void NotifyEvent(const LnnEventBasicInfo *info)
308 {
309     LnnEventHandlerItem *item = NULL;
310     uint32_t i = 0;
311 
312     if (SoftBusMutexLock(&g_eventCtrl.lock) != 0) {
313         LNN_LOGE(LNN_EVENT, "lock failed in notify event");
314         return;
315     }
316     uint32_t count = g_eventCtrl.regCnt[info->event];
317     LnnEventHandler *handlesArray = (LnnEventHandler *)SoftBusCalloc(sizeof(LnnEventHandlerItem) * count);
318     if (handlesArray == NULL) {
319         LNN_LOGE(LNN_EVENT, "malloc failed");
320         (void)SoftBusMutexUnlock(&g_eventCtrl.lock);
321         return;
322     }
323     LIST_FOR_EACH_ENTRY(item, &g_eventCtrl.handlers[info->event], LnnEventHandlerItem, node) {
324         handlesArray[i] = item->handler;
325         i++;
326     }
327     (void)SoftBusMutexUnlock(&g_eventCtrl.lock);
328 
329     /* process handles out of lock */
330     for (i = 0; i < count; i++) {
331         if (handlesArray[i] != NULL) {
332             handlesArray[i](info);
333         }
334     }
335     SoftBusFree(handlesArray);
336 }
337 
LnnNotifyDeviceVerified(const char * udid)338 void LnnNotifyDeviceVerified(const char *udid)
339 {
340     (void)udid;
341     LNN_LOGI(LNN_EVENT, "exist device joining LNN, remove networkId update event");
342     RemoveNotifyMessage(NOTIFY_NETWORKID_UPDATE);
343 }
344 
GetNetworkIdUpdateTime()345 static uint64_t GetNetworkIdUpdateTime()
346 {
347     int64_t networkIdTimestamp = 0;
348     int64_t nowTime = 0;
349     uint64_t delayTime = 0;
350     nowTime = (int64_t)SoftBusGetSysTimeMs();
351     if (LnnGetLocalNum64Info(NUM_KEY_NETWORK_ID_TIMESTAMP, &networkIdTimestamp) != SOFTBUS_OK) {
352         LNN_LOGE(LNN_EVENT, "get local networkIdTimestamp fail");
353         return NETWORK_ID_UPDATE_DELAY_TIME;
354     }
355     int64_t diff = networkIdTimestamp + NETWORK_ID_MAX_TTL - nowTime;
356     if (diff <= NETWORK_ID_MIN_UPDATE_DELAY_TIME) {
357         delayTime = NETWORK_ID_MIN_UPDATE_DELAY_TIME;
358     } else if (diff <= NETWORK_ID_UPDATE_DELAY_TIME) {
359         delayTime = (uint64_t)diff;
360     } else {
361         delayTime = NETWORK_ID_UPDATE_DELAY_TIME;
362     }
363     LNN_LOGI(LNN_EVENT, "networkId update delayTime=%{public}" PRId64 ", nowTime=%{public}" PRId64
364         ", networkIdTimestamp=%{public}" PRId64, delayTime, nowTime, networkIdTimestamp);
365     return delayTime;
366 }
367 
LnnNotifyOnlineState(bool isOnline,NodeBasicInfo * info)368 void LnnNotifyOnlineState(bool isOnline, NodeBasicInfo *info)
369 {
370     LnnOnlineStateEventInfo eventInfo;
371 
372     if (info == NULL) {
373         LNN_LOGW(LNN_EVENT, "info = null");
374         return;
375     }
376     char *anonyNetworkId = NULL;
377     Anonymize(info->networkId, &anonyNetworkId);
378     char *anonyDeviceName = NULL;
379     Anonymize(info->deviceName, &anonyDeviceName);
380     LNN_LOGI(LNN_EVENT, "notify node deviceName=%{public}s, isOnline=%{public}s, networkId=%{public}s",
381         anonyDeviceName, (isOnline == true) ? "online" : "offline", anonyNetworkId);
382     AnonymizeFree(anonyNetworkId);
383     AnonymizeFree(anonyDeviceName);
384     SetDefaultQdisc();
385     (void)PostNotifyMessage(NOTIFY_ONLINE_STATE_CHANGED, (uint64_t)isOnline, info);
386     eventInfo.basic.event = LNN_EVENT_NODE_ONLINE_STATE_CHANGED;
387     eventInfo.isOnline = isOnline;
388     eventInfo.networkId = info->networkId;
389     eventInfo.uuid = "";
390     eventInfo.udid = "";
391     NotifyEvent((LnnEventBasicInfo *)&eventInfo);
392     int32_t onlineNodeNum = 0;
393     if (LnnGetAllOnlineNodeNum(&onlineNodeNum) != SOFTBUS_OK) {
394         LNN_LOGE(LNN_EVENT, "get online nodeNum fail");
395         return;
396     }
397     if (!isOnline && onlineNodeNum == 0) {
398         LNN_LOGI(LNN_EVENT, "no online devices, post networkId update event");
399         RemoveNotifyMessage(NOTIFY_NETWORKID_UPDATE);
400         (void)PostNotifyMessageDelay(NOTIFY_NETWORKID_UPDATE, GetNetworkIdUpdateTime());
401     }
402     if (isOnline) {
403         LNN_LOGI(LNN_EVENT, "online process, remove networkId update event");
404         RemoveNotifyMessage(NOTIFY_NETWORKID_UPDATE);
405     }
406 }
407 
LnnNotifyMigrate(bool isOnline,NodeBasicInfo * info)408 void LnnNotifyMigrate(bool isOnline, NodeBasicInfo *info)
409 {
410     LnnOnlineStateEventInfo eventInfo;
411 
412     if (info == NULL) {
413         LNN_LOGW(LNN_EVENT, "info = null");
414         return;
415     }
416     eventInfo.basic.event = LNN_EVENT_NODE_MIGRATE;
417     eventInfo.isOnline = isOnline;
418     eventInfo.networkId = info->networkId;
419     NotifyEvent((LnnEventBasicInfo *)&eventInfo);
420 }
421 
LnnNotifyBasicInfoChanged(NodeBasicInfo * info,NodeBasicInfoType type)422 void LnnNotifyBasicInfoChanged(NodeBasicInfo *info, NodeBasicInfoType type)
423 {
424     if (info == NULL) {
425         LNN_LOGW(LNN_EVENT, "info = null");
426         return;
427     }
428     if (type == TYPE_DEVICE_NAME) {
429         char *anonyDeviceName = NULL;
430         Anonymize(info->deviceName, &anonyDeviceName);
431         LNN_LOGI(LNN_EVENT, "notify peer device name changed. deviceName=%{public}s", anonyDeviceName);
432         AnonymizeFree(anonyDeviceName);
433     }
434     (void)PostNotifyMessage(NOTIFY_NODE_BASIC_INFO_CHANGED, (uint64_t)type, info);
435 }
436 
LnnNotifyNodeStatusChanged(NodeStatus * info,NodeStatusType type)437 void LnnNotifyNodeStatusChanged(NodeStatus *info, NodeStatusType type)
438 {
439     if (info == NULL) {
440         LNN_LOGW(LNN_EVENT, "info = null");
441         return;
442     }
443     (void)PostNotifyNodeStatusMessage(NOTIFY_NODE_STATUS_CHANGED, (uint64_t)type, info);
444 }
445 
LnnNotifyLocalNetworkIdChanged(void)446 void LnnNotifyLocalNetworkIdChanged(void)
447 {
448     (void)PostNotifyMessageDelay(NOTIFY_LOCAL_NETWORKID_UPDATE, 0);
449 }
450 
LnnNotifyDeviceNotTrusted(const char * msg)451 void LnnNotifyDeviceNotTrusted(const char *msg)
452 {
453     if (msg == NULL) {
454         LNN_LOGE(LNN_EVENT, "msg is null");
455         return;
456     }
457     (void)LnnIpcNotifyDeviceNotTrusted(msg);
458 }
459 
LnnNotifyHichainProofException(const char * proofInfo,uint32_t proofLen,uint16_t deviceTypeId,int32_t errCode)460 void LnnNotifyHichainProofException(
461     const char *proofInfo, uint32_t proofLen, uint16_t deviceTypeId, int32_t errCode)
462 {
463     (void)LnnIpcNotifyHichainProofException(proofInfo, proofLen, deviceTypeId, errCode);
464 }
465 
LnnNotifyJoinResult(ConnectionAddr * addr,const char * networkId,int32_t retCode)466 void LnnNotifyJoinResult(ConnectionAddr *addr, const char *networkId, int32_t retCode)
467 {
468     if (addr == NULL) {
469         LNN_LOGW(LNN_EVENT, "addr or networkId = null!");
470         return;
471     }
472     LNN_LOGI(LNN_EVENT, "notify join LNN result=%{public}d", retCode);
473     LnnIpcNotifyJoinResult(addr, sizeof(ConnectionAddr), networkId, retCode);
474 }
475 
LnnNotifyLeaveResult(const char * networkId,int32_t retCode)476 void LnnNotifyLeaveResult(const char *networkId, int32_t retCode)
477 {
478     if (networkId == NULL) {
479         LNN_LOGW(LNN_EVENT, "networkId = null");
480         return;
481     }
482     LNN_LOGI(LNN_EVENT, "notify leave LNN result. retCode=%{public}d", retCode);
483     LnnIpcNotifyLeaveResult(networkId, retCode);
484 }
485 
LnnNotifyLnnRelationChanged(const char * udid,ConnectionAddrType type,uint8_t relation,bool isJoin)486 void LnnNotifyLnnRelationChanged(const char *udid, ConnectionAddrType type, uint8_t relation,
487     bool isJoin)
488 {
489     LnnRelationChanedEventInfo info;
490 
491     info.basic.event = LNN_EVENT_RELATION_CHANGED;
492     info.type = type;
493     info.relation = relation;
494     info.isJoin = isJoin;
495     info.udid = udid;
496     NotifyEvent((LnnEventBasicInfo *)&info);
497 }
498 
LnnNotifyTimeSyncResult(const char * pkgName,int32_t pid,const TimeSyncResultInfo * info,int32_t retCode)499 void LnnNotifyTimeSyncResult(const char *pkgName, int32_t pid, const TimeSyncResultInfo *info,
500     int32_t retCode)
501 {
502     if (pkgName == NULL || info == NULL) {
503         LNN_LOGW(LNN_EVENT, "invalid paramters");
504         return;
505     }
506     LNN_LOGI(LNN_EVENT, "notify time Sync result. retCode=%{public}d", retCode);
507     LnnIpcNotifyTimeSyncResult(pkgName, pid, info, sizeof(TimeSyncResultInfo), retCode);
508 }
509 
LnnNotifyWlanStateChangeEvent(void * state)510 void LnnNotifyWlanStateChangeEvent(void *state)
511 {
512     if (state == NULL) {
513         LNN_LOGE(LNN_EVENT, "state is empty");
514         return;
515     }
516     SoftBusWifiState *wifiState = (SoftBusWifiState *)state;
517     if (*wifiState < SOFTBUS_WIFI_CONNECTED || *wifiState > SOFTBUS_WIFI_UNKNOWN) {
518         LNN_LOGE(LNN_EVENT, "bad wifiState=%{public}d", *wifiState);
519         SoftBusFree(wifiState);
520         return;
521     }
522     LnnMonitorWlanStateChangedEvent event = {.basic.event = LNN_EVENT_WIFI_STATE_CHANGED,
523         .status = (uint8_t)(*wifiState)};
524     NotifyEvent((const LnnEventBasicInfo *)&event);
525     SoftBusFree(wifiState);
526 }
527 
LnnNotifyScreenStateChangeEvent(SoftBusScreenState state)528 void LnnNotifyScreenStateChangeEvent(SoftBusScreenState state)
529 {
530     if (state < SOFTBUS_SCREEN_ON || state >= SOFTBUS_SCREEN_UNKNOWN) {
531         LNN_LOGE(LNN_EVENT, "bad state=%{public}d", state);
532         return;
533     }
534     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_SCREEN_STATE_CHANGED, .status = state};
535     NotifyEvent((const LnnEventBasicInfo *)&event);
536 }
537 
LnnNotifyBtStateChangeEvent(void * state)538 void LnnNotifyBtStateChangeEvent(void *state)
539 {
540     SoftBusBtState *btState = (SoftBusBtState *)state;
541     if (*btState < SOFTBUS_BLE_TURN_ON || *btState >= SOFTBUS_BT_UNKNOWN) {
542         LNN_LOGE(LNN_EVENT, "bad btState=%{public}d", *btState);
543         SoftBusFree(btState);
544         return;
545     }
546     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_BT_STATE_CHANGED, .status = (uint8_t)(*btState)};
547     NotifyEvent((const LnnEventBasicInfo *)&event);
548     SoftBusFree(btState);
549 }
550 
LnnNotifyVapInfoChangeEvent(int32_t preferChannel)551 void LnnNotifyVapInfoChangeEvent(int32_t preferChannel)
552 {
553     LnnLaneVapChangeEvent event = {.basic.event = LNN_EVENT_LANE_VAP_CHANGE, .vapPreferChannel = preferChannel};
554     NotifyEvent((const LnnEventBasicInfo *)&event);
555 }
556 
LnnNotifyScreenLockStateChangeEvent(SoftBusScreenLockState state)557 void LnnNotifyScreenLockStateChangeEvent(SoftBusScreenLockState state)
558 {
559     if (state < SOFTBUS_SCREEN_LOCK || state >= SOFTBUS_SCREEN_LOCK_UNKNOWN) {
560         LNN_LOGE(LNN_EVENT, "bad lockState=%{public}d", state);
561         return;
562     }
563     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_SCREEN_LOCK_CHANGED, .status = state};
564     NotifyEvent((const LnnEventBasicInfo *)&event);
565 }
566 
LnnNotifyAccountStateChangeEvent(SoftBusAccountState state)567 void LnnNotifyAccountStateChangeEvent(SoftBusAccountState state)
568 {
569     if (state < SOFTBUS_ACCOUNT_LOG_IN || state >= SOFTBUS_ACCOUNT_UNKNOWN) {
570         LNN_LOGE(LNN_EVENT, "bad accountState=%{public}d", state);
571         return;
572     }
573     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_ACCOUNT_CHANGED,
574         .status = (uint8_t)state};
575     NotifyEvent((const LnnEventBasicInfo *)&event);
576 }
577 
LnnNotifyUserSwitchEvent(SoftBusUserSwitchState state)578 void LnnNotifyUserSwitchEvent(SoftBusUserSwitchState state)
579 {
580     if (state < SOFTBUS_USER_SWITCHED || state >= SOFTBUS_USER_SWITCH_UNKNOWN) {
581         LNN_LOGE(LNN_EVENT, "bad userSwitchState=%{public}d", state);
582         return;
583     }
584     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_USER_SWITCHED,
585         .status = (uint8_t)state};
586     NotifyEvent((const LnnEventBasicInfo *)&event);
587 }
588 
LnnNotifyDifferentAccountChangeEvent(void * state)589 void LnnNotifyDifferentAccountChangeEvent(void *state)
590 {
591     SoftBusDifferentAccountState *difAccountState = (SoftBusDifferentAccountState *)state;
592     if (*difAccountState < SOFTBUS_DIF_ACCOUNT_DEV_CHANGE || *difAccountState >= SOFTBUS_DIF_ACCOUNT_UNKNOWN) {
593         LNN_LOGE(LNN_EVENT, "bad difAccountState=%{public}d", *difAccountState);
594         SoftBusFree(difAccountState);
595         return;
596     }
597     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_DIF_ACCOUNT_DEV_CHANGED,
598         .status = (uint8_t)(*difAccountState)};
599     NotifyEvent((const LnnEventBasicInfo *)&event);
600     SoftBusFree(difAccountState);
601 }
602 
LnnNotifyUserStateChangeEvent(SoftBusUserState state)603 void LnnNotifyUserStateChangeEvent(SoftBusUserState state)
604 {
605     if (state < SOFTBUS_USER_FOREGROUND || state >= SOFTBUS_USER_UNKNOWN) {
606         LNN_LOGE(LNN_EVENT, "bad backgroundtState=%{public}d", state);
607         return;
608     }
609     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_USER_STATE_CHANGED, .status = state};
610     NotifyEvent((const LnnEventBasicInfo *)&event);
611 }
612 
LnnNotifyNightModeStateChangeEvent(void * state)613 void LnnNotifyNightModeStateChangeEvent(void *state)
614 {
615     SoftBusNightModeState *nightModeState = (SoftBusNightModeState *)state;
616     if (*nightModeState < SOFTBUS_NIGHT_MODE_ON || *nightModeState >= SOFTBUS_NIGHT_MODE_UNKNOWN) {
617         LNN_LOGE(LNN_EVENT, "bad nightModeState=%{public}d", *nightModeState);
618         SoftBusFree(nightModeState);
619         return;
620     }
621     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_NIGHT_MODE_CHANGED,
622         .status = (uint8_t)(*nightModeState)};
623     NotifyEvent((const LnnEventBasicInfo *)&event);
624     SoftBusFree(nightModeState);
625 }
626 
LnnNotifyHomeGroupChangeEvent(SoftBusHomeGroupState state)627 void LnnNotifyHomeGroupChangeEvent(SoftBusHomeGroupState state)
628 {
629     LNN_LOGI(LNN_EVENT, "notify home group change");
630     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_HOME_GROUP_CHANGED, .status = (uint8_t)state};
631     NotifyEvent((const LnnEventBasicInfo *)&event);
632 }
633 
LnnNotifyOOBEStateChangeEvent(SoftBusOOBEState state)634 void LnnNotifyOOBEStateChangeEvent(SoftBusOOBEState state)
635 {
636     LNN_LOGI(LNN_EVENT, "notify OOBE state change");
637     if (state < SOFTBUS_OOBE_RUNNING || state >= SOFTBUS_OOBE_UNKNOWN) {
638         LNN_LOGW(LNN_EVENT, "bad OOBEState=%{public}d", state);
639         return;
640     }
641     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_OOBE_STATE_CHANGED, .status = state};
642     NotifyEvent((const LnnEventBasicInfo *)&event);
643 }
644 
LnnNotifyBtAclStateChangeEvent(const char * btMac,SoftBusBtAclState state)645 void LnnNotifyBtAclStateChangeEvent(const char *btMac, SoftBusBtAclState state)
646 {
647     if (btMac == NULL) {
648         LNN_LOGW(LNN_EVENT, "invalid btMac, state=%{public}d", state);
649         return;
650     }
651     char *anonyMac = NULL;
652     Anonymize(btMac, &anonyMac);
653     LNN_LOGI(LNN_EVENT, "notify bt acl state changed: state=%{public}d, btMac=%{public}s.", state, anonyMac);
654     AnonymizeFree(anonyMac);
655     LnnMonitorBtAclStateChangedEvent event = {.basic.event = LNN_EVENT_BT_ACL_STATE_CHANGED, .status = state};
656     if (strcpy_s(event.btMac, sizeof(event.btMac), btMac) != EOK) {
657         LNN_LOGE(LNN_EVENT, "copy bt mac fail");
658         return;
659     }
660     NotifyEvent((const LnnEventBasicInfo *)&event);
661 }
662 
LnnNotifyAddressChangedEvent(const char * ifName)663 void LnnNotifyAddressChangedEvent(const char *ifName)
664 {
665     LnnMonitorAddressChangedEvent event = {.basic.event = LNN_EVENT_IP_ADDR_CHANGED, .ifName = {0}};
666     if (ifName != NULL) {
667         int32_t ret = strcpy_s(event.ifName, sizeof(event.ifName), ifName);
668         if (ret != EOK) {
669             LNN_LOGE(LNN_EVENT, "copy ifName failed! ret=%{public}d", ret);
670             return;
671         }
672     }
673     NotifyEvent((const LnnEventBasicInfo *)&event);
674 }
675 
LnnNotifyMasterNodeChanged(bool isMaster,const char * masterNodeUdid,int32_t weight)676 void LnnNotifyMasterNodeChanged(bool isMaster, const char *masterNodeUdid, int32_t weight)
677 {
678     LnnMasterNodeChangedEvent event = {.basic.event = LNN_EVENT_NODE_MASTER_STATE_CHANGED,
679         .isMasterNode = isMaster,
680         .masterNodeUDID = masterNodeUdid,
681         .weight = weight};
682 
683     NotifyEvent((const LnnEventBasicInfo *)&event);
684 }
685 
LnnNotifyNodeAddressChanged(const char * addr,const char * networkId,bool isLocal)686 void LnnNotifyNodeAddressChanged(const char *addr, const char *networkId, bool isLocal)
687 {
688     if (addr == NULL) {
689         return;
690     }
691 
692     LnnNodeAddrChangedEvent eventInfo;
693     (void)memset_s(&eventInfo, sizeof(eventInfo), 0, sizeof(eventInfo));
694     eventInfo.basic.event = LNN_EVENT_NODE_ADDR_CHANGED;
695     if (strcpy_s(eventInfo.addr, sizeof(eventInfo.addr), addr) != EOK ||
696         strcpy_s(eventInfo.networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
697         return;
698     }
699     if (strcmp(addr, NODE_ADDR_LOOPBACK) == 0) {
700         eventInfo.delFlag = true;
701     } else {
702         eventInfo.delFlag = false;
703     }
704     eventInfo.isLocal = isLocal;
705     NotifyEvent((LnnEventBasicInfo *)&eventInfo);
706 }
707 
LnnNotifyHBRepeat(void)708 void LnnNotifyHBRepeat(void)
709 {
710     LnnEventBasicInfo event;
711     event.event = LNN_EVENT_NODE_HB_REPEAT_CYCLE;
712 
713     NotifyEvent(&event);
714 }
715 
LnnNotifyNetworkStateChanged(SoftBusNetworkState state)716 void LnnNotifyNetworkStateChanged(SoftBusNetworkState state)
717 {
718     if (state < SOFTBUS_WIFI_NETWORKD_ENABLE || state >= SOFTBUS_NETWORKD_UNKNOWN) {
719         LNN_LOGW(LNN_EVENT, "bad network state=%{public}d", state);
720         return;
721     }
722     LnnMonitorHbStateChangedEvent event = {.basic.event = LNN_EVENT_NETWORK_STATE_CHANGED, .status = state};
723     NotifyEvent((const LnnEventBasicInfo *)&event);
724 }
725 
LnnNotifySingleOffLineEvent(const ConnectionAddr * addr,NodeBasicInfo * basicInfo)726 void LnnNotifySingleOffLineEvent(const ConnectionAddr *addr, NodeBasicInfo *basicInfo)
727 {
728     if (addr == NULL || basicInfo == NULL) {
729         LNN_LOGW(LNN_EVENT, "addr or basicInfo is null");
730         return;
731     }
732     NodeInfo info;
733     (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
734     if (LnnGetRemoteNodeInfoById(basicInfo->networkId, CATEGORY_NETWORK_ID, &info) == SOFTBUS_OK) {
735         if ((LnnHasDiscoveryType(&info, DISCOVERY_TYPE_WIFI) &&
736             LnnConvAddrTypeToDiscType(addr->type) == DISCOVERY_TYPE_WIFI)) {
737             LNN_LOGI(LNN_EVENT, "Two-way WIFI LNN not completely offline, not need to report offline");
738             return;
739         }
740     }
741     LnnSingleNetworkOffLineEvent event = {.basic.event = LNN_EVENT_SINGLE_NETWORK_OFFLINE, .type = addr->type};
742     event.basic.event = LNN_EVENT_SINGLE_NETWORK_OFFLINE;
743     event.type = addr->type;
744     event.udid = "";
745     event.uuid = "";
746     event.networkId = basicInfo->networkId;
747     NotifyEvent((const LnnEventBasicInfo *)&event);
748 }
749 
LnnNotifyLpReportEvent(SoftBusLpEventType type)750 void LnnNotifyLpReportEvent(SoftBusLpEventType type)
751 {
752     if (type < SOFTBUS_MSDP_MOVEMENT_AND_STATIONARY || type >= SOFTBUS_LP_EVENT_UNKNOWN) {
753         LNN_LOGW(LNN_EVENT, "bad lp event type=%{public}d", type);
754         return;
755     }
756     LnnLpReportEvent event = {.basic.event = LNN_EVENT_LP_EVENT_REPORT, .type = type};
757     NotifyEvent((const LnnEventBasicInfo *) &event);
758 }
759 
LnnNotifyNetworkIdChangeEvent(const char * networkId)760 void LnnNotifyNetworkIdChangeEvent(const char *networkId)
761 {
762     if (networkId == NULL) {
763         LNN_LOGW(LNN_EVENT, "networkId is null");
764         return;
765     }
766     LnnNetworkIdChangedEvent eventInfo;
767     (void)memset_s(&eventInfo, sizeof(eventInfo), 0, sizeof(eventInfo));
768     eventInfo.basic.event = LNN_EVENT_NETWORKID_CHANGED;
769     if (strcpy_s(eventInfo.networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
770         return;
771     }
772     NotifyEvent((LnnEventBasicInfo *)&eventInfo);
773 }
774 
LnnInitBusCenterEvent(void)775 int32_t LnnInitBusCenterEvent(void)
776 {
777     int32_t i;
778     SoftBusLooper *looper = CreateNewLooper("Notify_Lp");
779     if (looper == NULL) {
780         LNN_LOGE(LNN_EVENT, "create notify looper fail");
781         return SOFTBUS_ERR;
782     }
783     g_notifyHandler.looper = looper;
784     g_notifyHandler.HandleMessage = HandleNotifyMessage;
785 
786     SoftBusMutexAttr mutexAttr;
787     mutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
788     SoftBusMutexInit(&g_eventCtrl.lock, &mutexAttr);
789     for (i = 0; i < LNN_EVENT_TYPE_MAX; ++i) {
790         ListInit(&g_eventCtrl.handlers[i]);
791         g_eventCtrl.regCnt[i] = 0;
792     }
793     return SOFTBUS_OK;
794 }
795 
LnnDeinitBusCenterEvent(void)796 void LnnDeinitBusCenterEvent(void)
797 {
798     if (g_notifyHandler.looper != NULL) {
799         DestroyLooper(g_notifyHandler.looper);
800         g_notifyHandler.looper = NULL;
801         g_notifyHandler.HandleMessage = NULL;
802     }
803     SoftBusMutexDestroy(&g_eventCtrl.lock);
804 }
805 
LnnRegisterEventHandler(LnnEventType event,LnnEventHandler handler)806 int32_t LnnRegisterEventHandler(LnnEventType event, LnnEventHandler handler)
807 {
808     LnnEventHandlerItem *item = NULL;
809 
810     if (event == LNN_EVENT_TYPE_MAX || handler == NULL) {
811         LNN_LOGW(LNN_EVENT, "invalid event handler params");
812         return SOFTBUS_INVALID_PARAM;
813     }
814     if (SoftBusMutexLock(&g_eventCtrl.lock) != 0) {
815         LNN_LOGE(LNN_EVENT, "lock failed in register event handler");
816         return SOFTBUS_LOCK_ERR;
817     }
818     if (IsRepeatEventHandler(event, handler)) {
819         LNN_LOGE(LNN_EVENT, "handler is already exist. event=%{public}u", event);
820         (void)SoftBusMutexUnlock(&g_eventCtrl.lock);
821         return SOFTBUS_INVALID_PARAM;
822     }
823     item = CreateEventHandlerItem(handler);
824     if (item == NULL) {
825         LNN_LOGE(LNN_EVENT, "create event handler item failed");
826         (void)SoftBusMutexUnlock(&g_eventCtrl.lock);
827         return SOFTBUS_MEM_ERR;
828     }
829     ListAdd(&g_eventCtrl.handlers[event], &item->node);
830     g_eventCtrl.regCnt[event]++;
831     (void)SoftBusMutexUnlock(&g_eventCtrl.lock);
832     return SOFTBUS_OK;
833 }
834 
LnnUnregisterEventHandler(LnnEventType event,LnnEventHandler handler)835 void LnnUnregisterEventHandler(LnnEventType event, LnnEventHandler handler)
836 {
837     LnnEventHandlerItem *item = NULL;
838     LnnEventHandlerItem *next = NULL;
839 
840     if (event == LNN_EVENT_TYPE_MAX || handler == NULL) {
841         LNN_LOGW(LNN_EVENT, "invalid event handler params");
842         return;
843     }
844     if (SoftBusMutexLock(&g_eventCtrl.lock) != 0) {
845         LNN_LOGE(LNN_EVENT, "hold lock failed in unregister event handler");
846         return;
847     }
848     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_eventCtrl.handlers[event], LnnEventHandlerItem, node) {
849         if (item->handler == handler) {
850             ListDelete(&item->node);
851             SoftBusFree(item);
852             if (g_eventCtrl.regCnt[event] > 0) {
853                 g_eventCtrl.regCnt[event]--;
854             }
855             break;
856         }
857     }
858     (void)SoftBusMutexUnlock(&g_eventCtrl.lock);
859 }
860