• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 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_sync_info_manager.h"
17 
18 #include <securec.h>
19 #include <string.h>
20 
21 #include "anonymizer.h"
22 #include "auth_manager.h"
23 #include "bus_center_event.h"
24 #include "bus_center_manager.h"
25 #include "common_list.h"
26 #include "lnn_async_callback_utils.h"
27 #include "lnn_distributed_net_ledger.h"
28 #include "lnn_feature_capability.h"
29 #include "lnn_net_builder.h"
30 #include "lnn_log.h"
31 #include "message_handler.h"
32 #include "softbus_adapter_json.h"
33 #include "softbus_adapter_mem.h"
34 #include "softbus_adapter_thread.h"
35 #include "softbus_adapter_timer.h"
36 #include "softbus_bus_center.h"
37 #include "softbus_conn_interface.h"
38 #include "softbus_def.h"
39 #include "softbus_error_code.h"
40 #include "softbus_transmission_interface.h"
41 
42 #define MSG_HEAD_LEN 4
43 #define MAX_SYNC_INFO_MSG_LEN 4096
44 #define UNUSED_CHANNEL_CLOSED_DELAY (60 * 1000)
45 #define TIME_CONVERSION_UNIT 1000
46 #define CHANNEL_NAME "com.huawei.hwddmp.service.DeviceInfoSynchronize"
47 #define WIFI_OFFLINE_CODE_LEN 4
48 #define NETWORK_SYNC_CONN_CAP "conn_cap_long"
49 #define NETWORK_SYNC_TYPE "networking_type"
50 #define NETWORK_SYNC_SEQ "auth_seq"
51 #define NETWORK_OFFLINE_PORT "offline_port"
52 #define NETWORK_OFFLINE_CODE "offline_code"
53 
54 typedef struct {
55     uint32_t dataLen;
56     LnnSyncInfoMsgComplete complete;
57     ListNode node;
58     uint8_t data[0];
59 } SyncInfoMsg;
60 
61 typedef struct {
62     char networkId[NETWORK_ID_BUF_LEN];
63     bool isClientOpened;
64     int32_t clientChannelId;
65     int32_t serverChannelId;
66     ListNode node;
67     ListNode syncMsgList;
68     SoftBusSysTime accessTime;
69 } SyncChannelInfo;
70 
71 typedef struct {
72     ListNode channelInfoList;
73     LnnSyncInfoMsgHandler handlers[LNN_INFO_TYPE_COUNT];
74     SoftBusMutex lock;
75 } SyncInfoManager;
76 
77 static SyncInfoManager g_syncInfoManager;
78 
ClearSyncInfoMsg(SyncChannelInfo * info,ListNode * list)79 static void ClearSyncInfoMsg(SyncChannelInfo *info, ListNode *list)
80 {
81     SyncInfoMsg *item = NULL;
82     SyncInfoMsg *next = NULL;
83 
84     LIST_FOR_EACH_ENTRY_SAFE(item, next, list, SyncInfoMsg, node) {
85         ListDelete(&item->node);
86         if (item->complete != NULL) {
87             item->complete((LnnSyncInfoType)(*(uint32_t *)item->data), info->networkId,
88                 &item->data[MSG_HEAD_LEN], item->dataLen - MSG_HEAD_LEN);
89         }
90         SoftBusFree(item);
91     }
92 }
93 
ClearSyncChannelInfo(void)94 static void ClearSyncChannelInfo(void)
95 {
96     SyncChannelInfo *item = NULL;
97     SyncChannelInfo *next = NULL;
98 
99     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_syncInfoManager.channelInfoList, SyncChannelInfo, node) {
100         ListDelete(&item->node);
101         ClearSyncInfoMsg(item, &item->syncMsgList);
102         SoftBusFree(item);
103     }
104 }
105 
FindSyncChannelInfoByNetworkId(const char * networkId)106 static SyncChannelInfo *FindSyncChannelInfoByNetworkId(const char *networkId)
107 {
108     SyncChannelInfo *item = NULL;
109     SyncChannelInfo *next = NULL;
110 
111     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_syncInfoManager.channelInfoList, SyncChannelInfo, node) {
112         if (strcmp(item->networkId, networkId) == 0) {
113             return item;
114         }
115     }
116     return NULL;
117 }
118 
FindSyncChannelInfoByChannelId(int32_t channelId)119 static SyncChannelInfo *FindSyncChannelInfoByChannelId(int32_t channelId)
120 {
121     SyncChannelInfo *item = NULL;
122     SyncChannelInfo *next = NULL;
123 
124     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_syncInfoManager.channelInfoList, SyncChannelInfo, node) {
125         if (item->clientChannelId == channelId || item->serverChannelId == channelId) {
126             return item;
127         }
128     }
129     return NULL;
130 }
131 
CreateSyncChannelInfo(const char * networkId)132 static SyncChannelInfo *CreateSyncChannelInfo(const char *networkId)
133 {
134     SyncChannelInfo *item = (SyncChannelInfo *)SoftBusMalloc(sizeof(SyncChannelInfo));
135     if (item == NULL) {
136         LNN_LOGE(LNN_BUILDER, "malloc sync channel info fail");
137         return NULL;
138     }
139     ListInit(&item->node);
140     ListInit(&item->syncMsgList);
141     if (strcpy_s(item->networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
142         LNN_LOGE(LNN_BUILDER, "copy network id to sync channel info fail");
143         SoftBusFree(item);
144         return NULL;
145     }
146     item->clientChannelId = INVALID_CHANNEL_ID;
147     item->serverChannelId = INVALID_CHANNEL_ID;
148     SoftBusGetTime(&item->accessTime);
149     item->isClientOpened = false;
150     return item;
151 }
152 
CreateSyncInfoMsg(LnnSyncInfoType type,const uint8_t * msg,uint32_t len,LnnSyncInfoMsgComplete complete)153 static SyncInfoMsg *CreateSyncInfoMsg(LnnSyncInfoType type, const uint8_t *msg,
154     uint32_t len, LnnSyncInfoMsgComplete complete)
155 {
156     uint32_t dataLen = len + MSG_HEAD_LEN;
157     SyncInfoMsg *syncMsg = NULL;
158 
159     if (dataLen > MAX_SYNC_INFO_MSG_LEN) {
160         LNN_LOGE(LNN_BUILDER, "sync info msg length too large. type=%{public}d, len=%{public}u",
161             type, dataLen);
162         return NULL;
163     }
164     syncMsg = (SyncInfoMsg *)SoftBusMalloc(sizeof(SyncInfoMsg) + dataLen);
165     if (syncMsg == NULL) {
166         LNN_LOGE(LNN_BUILDER, "malloc sync info msg fail. type=%{public}d, len=%{public}u",
167             type, dataLen);
168         return NULL;
169     }
170     *(int32_t *)syncMsg->data = type;
171     if (memcpy_s(syncMsg->data + MSG_HEAD_LEN, dataLen - MSG_HEAD_LEN, msg, len) != EOK) {
172         LNN_LOGE(LNN_BUILDER, "copy sync info msg fail. type=%{public}d, len=%{public}u",
173             type, dataLen);
174         SoftBusFree(syncMsg);
175         return NULL;
176     }
177     ListInit(&syncMsg->node);
178     syncMsg->complete = complete;
179     syncMsg->dataLen = dataLen;
180     return syncMsg;
181 }
182 
SendSyncInfoMsgOnly(const char * networkId,int32_t clientChannelId,SyncInfoMsg * msg)183 static void SendSyncInfoMsgOnly(const char *networkId, int32_t clientChannelId, SyncInfoMsg *msg)
184 {
185     LNN_LOGI(LNN_BUILDER, "only send sync info");
186     if (TransSendNetworkingMessage(clientChannelId, (char *)msg->data, msg->dataLen, CONN_HIGH) != SOFTBUS_OK) {
187         LNN_LOGE(LNN_BUILDER, "trans send data fail");
188     }
189     if (msg->complete != NULL) {
190         msg->complete((LnnSyncInfoType)(*(uint32_t *)msg->data), networkId,
191             &msg->data[MSG_HEAD_LEN], msg->dataLen - MSG_HEAD_LEN);
192     }
193     SoftBusFree(msg);
194 }
195 
SendSyncInfoMsg(SyncChannelInfo * info,SyncInfoMsg * msg)196 static void SendSyncInfoMsg(SyncChannelInfo *info, SyncInfoMsg *msg)
197 {
198     if (TransSendNetworkingMessage(info->clientChannelId, (char *)msg->data, msg->dataLen, CONN_HIGH) != SOFTBUS_OK) {
199         LNN_LOGE(LNN_BUILDER, "trans send data fail");
200     }
201     SoftBusGetTime(&info->accessTime);
202     ListDelete(&msg->node);
203     if (msg->complete != NULL) {
204         msg->complete((LnnSyncInfoType)(*(uint32_t *)msg->data), info->networkId,
205             &msg->data[MSG_HEAD_LEN], msg->dataLen - MSG_HEAD_LEN);
206     }
207     SoftBusFree(msg);
208 }
209 
CloseUnusedChannel(void * para)210 static void CloseUnusedChannel(void *para)
211 {
212     SyncChannelInfo *item = NULL;
213     SyncChannelInfo *itemNext = NULL;
214     SoftBusSysTime now;
215     int64_t diff;
216 
217     (void)para;
218     LNN_LOGD(LNN_BUILDER, "try close unused channel");
219     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
220         LNN_LOGE(LNN_BUILDER, "close unused channel lock fail");
221         return;
222     }
223     SoftBusGetTime(&now);
224     LIST_FOR_EACH_ENTRY_SAFE(item, itemNext, &g_syncInfoManager.channelInfoList, SyncChannelInfo, node) {
225         if (!IsListEmpty(&item->syncMsgList)) {
226             continue;
227         }
228         if (item->clientChannelId == INVALID_CHANNEL_ID) {
229             continue;
230         }
231         diff = (now.sec - item->accessTime.sec) * TIME_CONVERSION_UNIT +
232             (now.usec - item->accessTime.usec) / TIME_CONVERSION_UNIT;
233         if (diff <= UNUSED_CHANNEL_CLOSED_DELAY) {
234             continue;
235         }
236         (void)TransCloseNetWorkingChannel(item->clientChannelId);
237         item->clientChannelId = INVALID_CHANNEL_ID;
238         item->isClientOpened = false;
239         if (item->serverChannelId == INVALID_CHANNEL_ID) {
240             ListDelete(&item->node);
241             SoftBusFree(item);
242         }
243     }
244     if (!IsListEmpty(&g_syncInfoManager.channelInfoList)) {
245         (void)LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT),
246             CloseUnusedChannel, NULL, UNUSED_CHANNEL_CLOSED_DELAY);
247     }
248     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
249 }
250 
DestroySyncInfoMsgList(ListNode * list)251 static void DestroySyncInfoMsgList(ListNode *list)
252 {
253     SyncInfoMsg *item = NULL;
254     SyncInfoMsg *next = NULL;
255     LIST_FOR_EACH_ENTRY_SAFE(item, next, list, SyncInfoMsg, node) {
256         ListDelete(&item->node);
257         SoftBusFree(item);
258     }
259 }
260 
DumpMsgExcludeListNode(const SyncInfoMsg * msg)261 static SyncInfoMsg *DumpMsgExcludeListNode(const SyncInfoMsg *msg)
262 {
263     if (msg == NULL) {
264         LNN_LOGE(LNN_BUILDER, "invalid param");
265         return NULL;
266     }
267     SyncInfoMsg *newMsg = (SyncInfoMsg *)SoftBusCalloc(sizeof(SyncInfoMsg) + msg->dataLen);
268     if (newMsg == NULL) {
269         LNN_LOGE(LNN_BUILDER, "malloc err");
270         return NULL;
271     }
272     newMsg->complete = msg->complete;
273     newMsg->dataLen = msg->dataLen;
274     if (memcpy_s(newMsg->data, newMsg->dataLen, msg->data, msg->dataLen) != EOK) {
275         LNN_LOGE(LNN_BUILDER, "memcpy err");
276         SoftBusFree(newMsg);
277         return NULL;
278     }
279     return newMsg;
280 }
281 
DumpSyncInfoMsgList(const ListNode * srcList,ListNode * dstList)282 static int32_t DumpSyncInfoMsgList(const ListNode *srcList, ListNode *dstList)
283 {
284     if (srcList == NULL || dstList == NULL) {
285         LNN_LOGE(LNN_BUILDER, "invalid param");
286         return SOFTBUS_INVALID_PARAM;
287     }
288     SyncInfoMsg *item = NULL;
289     SyncInfoMsg *newItem = NULL;
290     LIST_FOR_EACH_ENTRY(item, srcList, SyncInfoMsg, node) {
291         newItem = DumpMsgExcludeListNode(item);
292         if (newItem == NULL) {
293             LNN_LOGE(LNN_BUILDER, "dump msg node fail");
294             return SOFTBUS_MALLOC_ERR;
295         }
296         LNN_LOGD(LNN_BUILDER, "add node");
297         ListInit(&newItem->node);
298         ListNodeInsert(dstList, &newItem->node);
299     }
300     return SOFTBUS_OK;
301 }
302 
DumpSyncChannelInfo(const SyncChannelInfo * info)303 static SyncChannelInfo *DumpSyncChannelInfo(const SyncChannelInfo *info)
304 {
305     SyncChannelInfo *newInfo = (SyncChannelInfo *)SoftBusCalloc(sizeof(SyncChannelInfo));
306     if (newInfo == NULL) {
307         LNN_LOGE(LNN_BUILDER, "malloc err");
308         return NULL;
309     }
310     ListInit(&newInfo->node);
311     ListInit(&newInfo->syncMsgList);
312     if (strcpy_s(newInfo->networkId, NETWORK_ID_BUF_LEN, info->networkId) != EOK) {
313         LNN_LOGE(LNN_BUILDER, "copy network id fail");
314         SoftBusFree(newInfo);
315         return NULL;
316     }
317     newInfo->clientChannelId = info->clientChannelId;
318     newInfo->serverChannelId = info->serverChannelId;
319     newInfo->accessTime = info->accessTime;
320     newInfo->isClientOpened = info->isClientOpened;
321 
322     if (DumpSyncInfoMsgList(&info->syncMsgList, &newInfo->syncMsgList) != SOFTBUS_OK) {
323         LNN_LOGE(LNN_BUILDER, "dump sync info msg list fail");
324         DestroySyncInfoMsgList(&newInfo->syncMsgList);
325         SoftBusFree(newInfo);
326         return NULL;
327     }
328     return newInfo;
329 }
330 
SendSyncInfoMsgFromList(SyncChannelInfo * info)331 static void SendSyncInfoMsgFromList(SyncChannelInfo *info)
332 {
333     SyncInfoMsg *msg = NULL;
334     SyncInfoMsg *msgNext = NULL;
335 
336     LIST_FOR_EACH_ENTRY_SAFE(msg, msgNext, &info->syncMsgList, SyncInfoMsg, node) {
337         SendSyncInfoMsg(info, msg);
338     }
339 }
340 
ResetOpenChannelInfo(int32_t channelId,unsigned char isServer,SyncChannelInfo * info,int32_t * oldChannelId)341 static void ResetOpenChannelInfo(int32_t channelId, unsigned char isServer,
342     SyncChannelInfo *info, int32_t *oldChannelId)
343 {
344     SoftBusGetTime(&info->accessTime);
345     if (isServer) {
346         if (info->serverChannelId != channelId && info->serverChannelId != INVALID_CHANNEL_ID) {
347             LNN_LOGD(LNN_BUILDER, "reset sync info server channel. serverChannelId=%{public}d, channelId=%{public}d",
348                 info->serverChannelId, channelId);
349             *oldChannelId = info->serverChannelId;
350         }
351         info->serverChannelId = channelId;
352     } else {
353         info->isClientOpened = true;
354         if (info->clientChannelId != channelId && info->clientChannelId != INVALID_CHANNEL_ID) {
355             LNN_LOGD(LNN_BUILDER, "reset sync info client channel. clientChannelId=%{public}d, channelId=%{public}d",
356                 info->clientChannelId, channelId);
357             *oldChannelId = info->clientChannelId;
358         }
359         info->clientChannelId = channelId;
360     }
361 }
362 
AddChannelInfoNode(const char * networkId,int32_t channelId,unsigned char isServer)363 static int32_t AddChannelInfoNode(const char *networkId, int32_t channelId, unsigned char isServer)
364 {
365     if (!isServer) {
366         LNN_LOGI(LNN_BUILDER, "unexpected client channel opened");
367         return SOFTBUS_INVALID_PARAM;
368     }
369     SyncChannelInfo *info = CreateSyncChannelInfo(networkId);
370     if (info == NULL) {
371         LNN_LOGE(LNN_BUILDER, "creat sync channel info fail");
372         return SOFTBUS_MALLOC_ERR;
373     }
374     if (IsListEmpty(&g_syncInfoManager.channelInfoList)) {
375         (void)LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT),
376             CloseUnusedChannel, NULL, UNUSED_CHANNEL_CLOSED_DELAY);
377     }
378     info->serverChannelId = channelId;
379     ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
380     return SOFTBUS_OK;
381 }
382 
OnChannelOpened(int32_t channelId,const char * peerUuid,unsigned char isServer)383 static int32_t OnChannelOpened(int32_t channelId, const char *peerUuid, unsigned char isServer)
384 {
385     char networkId[NETWORK_ID_BUF_LEN] = {0};
386     SyncChannelInfo *info = NULL;
387 
388     int32_t ret = LnnConvertDlId(peerUuid, CATEGORY_UUID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN);
389     if (ret != SOFTBUS_OK) {
390         LNN_LOGI(LNN_BUILDER, "peer device not online");
391         return ret;
392     }
393     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
394         LNN_LOGE(LNN_BUILDER, "sync channel opened lock fail");
395         return SOFTBUS_LOCK_ERR;
396     }
397     char *anonyNetworkId = NULL;
398     Anonymize(networkId, &anonyNetworkId);
399     LNN_LOGI(LNN_BUILDER,
400         "channelId=%{public}d, networkId=%{public}s, server=%{public}u",
401         channelId, AnonymizeWrapper(anonyNetworkId), isServer);
402     AnonymizeFree(anonyNetworkId);
403     info = FindSyncChannelInfoByNetworkId(networkId);
404     if (info == NULL) {
405         ret = AddChannelInfoNode((char *)networkId, channelId, isServer);
406         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
407         return ret;
408     }
409     int32_t oldChannelId = INVALID_CHANNEL_ID;
410     ResetOpenChannelInfo(channelId, isServer, info, &oldChannelId);
411     SyncChannelInfo *newInfo = NULL;
412     if (!isServer) {
413         newInfo = DumpSyncChannelInfo(info);
414         if (newInfo == NULL) {
415             LNN_LOGE(LNN_BUILDER, "client dump sync channel info fail");
416         }
417         DestroySyncInfoMsgList(&info->syncMsgList);
418     }
419     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
420     if (oldChannelId != INVALID_CHANNEL_ID) {
421         (void)TransCloseNetWorkingChannel(oldChannelId);
422     }
423     if (newInfo != NULL) {
424         if (!IsListEmpty(&newInfo->syncMsgList)) {
425             SendSyncInfoMsgFromList(newInfo);
426         }
427         SoftBusFree(newInfo);
428     }
429     return SOFTBUS_OK;
430 }
431 
OnChannelCloseCommon(SyncChannelInfo * info,int32_t channelId)432 static void OnChannelCloseCommon(SyncChannelInfo *info, int32_t channelId)
433 {
434     if (info->serverChannelId == channelId) {
435         info->serverChannelId = INVALID_CHANNEL_ID;
436     } else {
437         ClearSyncInfoMsg(info, &info->syncMsgList);
438         info->clientChannelId = INVALID_CHANNEL_ID;
439         info->isClientOpened = false;
440         if (info->serverChannelId == INVALID_CHANNEL_ID) {
441             LNN_LOGI(LNN_BUILDER, "free empty sync channel info");
442             ListDelete(&info->node);
443             SoftBusFree(info);
444         }
445     }
446 }
447 
OnChannelOpenFailed(int32_t channelId,const char * peerUuid)448 static void OnChannelOpenFailed(int32_t channelId, const char *peerUuid)
449 {
450     char networkId[NETWORK_ID_BUF_LEN] = {0};
451     SyncChannelInfo *info = NULL;
452 
453     if (LnnConvertDlId(peerUuid, CATEGORY_UUID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
454         LNN_LOGI(LNN_BUILDER, "peer device not online");
455         return;
456     }
457     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
458         LNN_LOGE(LNN_BUILDER, "sync channel opened failed lock fail");
459         return;
460     }
461     char *anonyNetworkId = NULL;
462     Anonymize(networkId, &anonyNetworkId);
463     LNN_LOGI(LNN_BUILDER,
464         "open channel fail. channelId=%{public}d, networkId=%{public}s",
465         channelId, AnonymizeWrapper(anonyNetworkId));
466     AnonymizeFree(anonyNetworkId);
467     info = FindSyncChannelInfoByNetworkId(networkId);
468     if (info == NULL || (info->clientChannelId != channelId && info->serverChannelId != channelId)) {
469         LNN_LOGE(LNN_BUILDER, "unexpected channel open fail event");
470         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
471         return;
472     }
473     OnChannelCloseCommon(info, channelId);
474     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
475 }
476 
OnChannelClosed(int32_t channelId)477 static void OnChannelClosed(int32_t channelId)
478 {
479     SyncChannelInfo *info = NULL;
480 
481     LNN_LOGI(LNN_BUILDER, "channel closed, channelId=%{public}d", channelId);
482     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
483         LNN_LOGE(LNN_BUILDER, "sync channel opened failed lock fail");
484         return;
485     }
486     info = FindSyncChannelInfoByChannelId(channelId);
487     if (info == NULL) {
488         LNN_LOGE(LNN_BUILDER, "unexpected channel closed event");
489         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
490         return;
491     }
492     OnChannelCloseCommon(info, channelId);
493     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
494 }
495 
OnMessageReceived(int32_t channelId,const char * data,uint32_t len)496 static void OnMessageReceived(int32_t channelId, const char *data, uint32_t len)
497 {
498     SyncChannelInfo *info = NULL;
499     LnnSyncInfoType type;
500     LnnSyncInfoMsgHandler handler;
501     char networkId[NETWORK_ID_BUF_LEN] = {0};
502 
503     if (data == NULL) {
504         LNN_LOGE(LNN_BUILDER, "recv NULL data, channelId=%{public}d", channelId);
505         return;
506     }
507     if (len <= MSG_HEAD_LEN || len > MAX_SYNC_INFO_MSG_LEN) {
508         LNN_LOGE(LNN_BUILDER, "invalid msg. len=%{public}d", len);
509         return;
510     }
511     LNN_LOGI(LNN_BUILDER, "recv sync info msg. type=%{public}d, channelId=%{public}d, len=%{public}d",
512         (LnnSyncInfoType)(*(int32_t *)data), channelId, len);
513     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
514         LNN_LOGE(LNN_BUILDER, "sync channel opened failed lock fail");
515         return;
516     }
517     info = FindSyncChannelInfoByChannelId(channelId);
518     if (info == NULL) {
519         LNN_LOGE(LNN_BUILDER, "unexpected channel data received event");
520         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
521         return;
522     }
523     type = (LnnSyncInfoType)(*(int32_t *)data);
524     if (type < 0 || type >= LNN_INFO_TYPE_COUNT) {
525         LNN_LOGE(LNN_BUILDER, "received data is exception");
526         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
527         return;
528     }
529     handler = g_syncInfoManager.handlers[type];
530     if (handler == NULL) {
531         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
532         return;
533     }
534     if (strcpy_s(networkId, NETWORK_ID_BUF_LEN, info->networkId) != EOK) {
535         LNN_LOGE(LNN_BUILDER, "copy networkId fail");
536         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
537         return;
538     }
539     SoftBusGetTime(&info->accessTime);
540     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
541     handler(type, networkId, (const uint8_t *)&data[MSG_HEAD_LEN], len - MSG_HEAD_LEN);
542 }
543 
544 static INetworkingListener g_networkListener = {
545     OnChannelOpened,
546     OnChannelOpenFailed,
547     OnChannelClosed,
548     OnMessageReceived,
549 };
550 
PackBleOfflineMsg(int64_t connCap,int32_t networkType,int64_t authSeq)551 static char *PackBleOfflineMsg(int64_t connCap, int32_t networkType, int64_t authSeq)
552 {
553     JsonObj *json = JSON_CreateObject();
554     if (json == NULL) {
555         LNN_LOGE(LNN_BUILDER, "create json object fail");
556         return NULL;
557     }
558     if (!JSON_AddInt64ToObject(json, NETWORK_SYNC_CONN_CAP, connCap) ||
559         !JSON_AddInt32ToObject(json, NETWORK_SYNC_TYPE, networkType) ||
560         !JSON_AddInt64ToObject(json, NETWORK_SYNC_SEQ, authSeq)) {
561         LNN_LOGE(LNN_BUILDER, "add p2p networking msg to json fail");
562         JSON_Delete(json);
563         return NULL;
564     }
565     char *msg = JSON_PrintUnformatted(json);
566     JSON_Delete(json);
567     return msg;
568 }
569 
PackWifiOfflineMsg(int32_t authPort,char * offlineCode)570 static char *PackWifiOfflineMsg(int32_t authPort, char *offlineCode)
571 {
572     JsonObj *json = JSON_CreateObject();
573     if (json == NULL) {
574         LNN_LOGE(LNN_BUILDER, "create json object fail");
575         return NULL;
576     }
577     if (!JSON_AddInt32ToObject(json, NETWORK_OFFLINE_PORT, authPort) ||
578         !JSON_AddInt32ToObject(json, NETWORK_SYNC_TYPE, DISCOVERY_TYPE_WIFI) ||
579         !JSON_AddStringToObject(json, NETWORK_OFFLINE_CODE, offlineCode)) {
580         LNN_LOGE(LNN_BUILDER, "add wifi offline msg to json fail");
581         JSON_Delete(json);
582         return NULL;
583     }
584     char *msg = JSON_PrintUnformatted(json);
585     JSON_Delete(json);
586     return msg;
587 }
588 
CheckPeerAuthSeq(const char * uuid,int64_t peerAuthSeq)589 static int32_t CheckPeerAuthSeq(const char *uuid, int64_t peerAuthSeq)
590 {
591     int64_t localAuthSeq[2] = {0};
592     uint64_t authVerifyTime[2] = {0};
593     char udid[UDID_BUF_LEN] = {0};
594 
595     int32_t ret = LnnConvertDlId(uuid, CATEGORY_UUID, CATEGORY_UDID, udid, UDID_BUF_LEN);
596     if (ret != SOFTBUS_OK) {
597         LNN_LOGE(LNN_BUILDER, "convert uuid fail");
598         return ret;
599     }
600     ret = AuthGetLatestAuthSeqListByType(udid, localAuthSeq, authVerifyTime, DISCOVERY_TYPE_BLE);
601     if (ret != SOFTBUS_OK) {
602         LNN_LOGE(LNN_BUILDER, "get authseq fail");
603         return ret;
604     }
605     char *anonyUdid = NULL;
606     Anonymize(udid, &anonyUdid);
607     if (peerAuthSeq == 0 || (peerAuthSeq != localAuthSeq[0] && peerAuthSeq != localAuthSeq[1])) {
608         LNN_LOGE(LNN_BUILDER, "authSeq is invalid, udid:%{public}s, local:%{public}" PRId64 ", %{public}"
609             PRId64 "peer:%{public}" PRId64 "", AnonymizeWrapper(anonyUdid),
610             localAuthSeq[0], localAuthSeq[1], peerAuthSeq);
611         AnonymizeFree(anonyUdid);
612         return SOFTBUS_INVALID_PARAM;
613     }
614     AnonymizeFree(anonyUdid);
615     return SOFTBUS_OK;
616 }
617 
BleOffLineProcess(const AuthTransData * data,AuthHandle authHandle)618 static void BleOffLineProcess(const AuthTransData *data, AuthHandle authHandle)
619 {
620     int64_t peerConnCap = 0;
621     int64_t peerAuthSeq = 0;
622     JsonObj *json = JSON_Parse((const char *)data->data, data->len);
623     if (json == NULL) {
624         LNN_LOGE(LNN_BUILDER, "json parse fail");
625         return;
626     }
627     if (!JSON_GetInt64FromOject(json, NETWORK_SYNC_CONN_CAP, &peerConnCap) ||
628         !JSON_GetInt64FromOject(json, NETWORK_SYNC_SEQ, &peerAuthSeq)) {
629         LNN_LOGE(LNN_BUILDER, "ble json parse object fail");
630         JSON_Delete(json);
631         return;
632     }
633     JSON_Delete(json);
634     if (LnnHasCapability((uint32_t)peerConnCap, BIT_BLE)) {
635         LNN_LOGE(LNN_BUILDER, "no need to offline, peerConnCap:%{public}u", (uint32_t)peerConnCap);
636         return;
637     }
638     char uuid[UUID_BUF_LEN] = {0};
639     char networkId[NETWORK_ID_BUF_LEN] = {0};
640     if (AuthGetDeviceUuid(authHandle.authId, uuid, UUID_BUF_LEN) != SOFTBUS_OK ||
641         CheckPeerAuthSeq(uuid, peerAuthSeq) != SOFTBUS_OK) {
642         char *anonyUuid = NULL;
643         Anonymize(uuid, &anonyUuid);
644         LNN_LOGW(LNN_BUILDER, "device has offline or get authId/authSeq fail, uuid:%{public}s",
645             AnonymizeWrapper(anonyUuid));
646         AnonymizeFree(anonyUuid);
647         return;
648     }
649     char *anonyNetworkId = NULL;
650     Anonymize(networkId, &anonyNetworkId);
651     (void)LnnConvertDlId(uuid, CATEGORY_UUID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN);
652     if (LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_BLE) != SOFTBUS_OK) {
653         LNN_LOGE(LNN_BUILDER, "request leave specific fail, networkId:%{public}s",
654             AnonymizeWrapper(anonyNetworkId));
655     } else {
656         LNN_LOGD(LNN_BUILDER, "offline ble by p2p succ, networkId:%{public}s",
657             AnonymizeWrapper(anonyNetworkId));
658     }
659     AnonymizeFree(anonyNetworkId);
660 }
661 
CheckWifiOfflineMsgResult(const char * networkId,int32_t authPort,const char * offlineCode)662 static bool CheckWifiOfflineMsgResult(const char *networkId, int32_t authPort, const char *offlineCode)
663 {
664     int32_t port = 0;
665     uint8_t remoteOfflineCode[WIFI_OFFLINE_CODE_LEN] = {0};
666     char convertOfflineCode[WIFI_OFFLINE_CODE_LEN * HEXIFY_UNIT_LEN + 1] = {0};
667     char *anonyNetworkId = NULL;
668     Anonymize(networkId, &anonyNetworkId);
669 
670     if (LnnGetRemoteNumInfoByIfnameIdx(networkId, NUM_KEY_AUTH_PORT, &port, WLAN_IF) != 0) {
671         LNN_LOGE(LNN_BUILDER, "get remote port fail, neteorkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
672         AnonymizeFree(anonyNetworkId);
673         return false;
674     }
675     if (LnnGetNodeKeyInfo(networkId, NODE_KEY_BLE_OFFLINE_CODE, remoteOfflineCode, WIFI_OFFLINE_CODE_LEN) != 0) {
676         LNN_LOGE(LNN_BUILDER, "get remote offlinecode fail, neteorkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
677         AnonymizeFree(anonyNetworkId);
678         return false;
679     }
680     if (ConvertBytesToHexString(convertOfflineCode, WIFI_OFFLINE_CODE_LEN * HEXIFY_UNIT_LEN + 1,
681         (unsigned char *)remoteOfflineCode, WIFI_OFFLINE_CODE_LEN) != SOFTBUS_OK) {
682         LNN_LOGE(LNN_BUILDER, "coonvert offlinecode fail, neteorkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
683         AnonymizeFree(anonyNetworkId);
684         return false;
685     }
686     if (strcmp(convertOfflineCode, offlineCode) != 0 || port != authPort) {
687         LNN_LOGE(LNN_BUILDER, "check offline msg info fail, neteorkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
688         AnonymizeFree(anonyNetworkId);
689         return false;
690     }
691     AnonymizeFree(anonyNetworkId);
692     return true;
693 }
694 
WlanOffLineProcess(const AuthTransData * data,AuthHandle authHandle)695 static void WlanOffLineProcess(const AuthTransData *data, AuthHandle authHandle)
696 {
697     char uuid[UUID_BUF_LEN] = {0};
698     char networkId[NETWORK_ID_BUF_LEN] = {0};
699     char *anonyNetworkId = NULL;
700     int32_t authPort = 0;
701     char convertOfflineCode[WIFI_OFFLINE_CODE_LEN * HEXIFY_UNIT_LEN + 1] = {0};
702     JsonObj *json = JSON_Parse((const char *)data->data, data->len);
703     if (json == NULL) {
704         LNN_LOGE(LNN_BUILDER, "json parse fail");
705         return;
706     }
707     if (!JSON_GetInt32FromOject(json, NETWORK_OFFLINE_PORT, &authPort) ||
708         !JSON_GetStringFromObject(json, NETWORK_OFFLINE_CODE, convertOfflineCode,
709             WIFI_OFFLINE_CODE_LEN * HEXIFY_UNIT_LEN + 1)) {
710         LNN_LOGE(LNN_BUILDER, "wifi json parse object fail");
711         JSON_Delete(json);
712         return;
713     }
714     JSON_Delete(json);
715     if (AuthGetDeviceUuid(authHandle.authId, uuid, UUID_BUF_LEN) != SOFTBUS_OK) {
716         char *anonyUuid = NULL;
717         Anonymize(uuid, &anonyUuid);
718         LNN_LOGW(LNN_BUILDER, "device has offline or get authId/authSeq fail, uuid:%{public}s",
719             AnonymizeWrapper(anonyUuid));
720         AnonymizeFree(anonyUuid);
721         return;
722     }
723     if (LnnConvertDlId(uuid, CATEGORY_UUID, CATEGORY_NETWORK_ID, networkId, NETWORK_ID_BUF_LEN) != SOFTBUS_OK) {
724         LNN_LOGE(LNN_BUILDER, "convert networkid fail");
725         return;
726     }
727     if (CheckWifiOfflineMsgResult(networkId, authPort, convertOfflineCode)) {
728         Anonymize(networkId, &anonyNetworkId);
729         if (LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_WLAN) != SOFTBUS_OK) {
730             LNN_LOGE(LNN_BUILDER, "wifi fast offline failed, networkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
731         } else {
732             LNN_LOGI(LNN_BUILDER, "wifi fast offline success networkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
733         }
734         AnonymizeFree(anonyNetworkId);
735     }
736 }
737 
OnP2pNetworkingDataRecv(AuthHandle authHandle,const AuthTransData * data)738 static void OnP2pNetworkingDataRecv(AuthHandle authHandle, const AuthTransData *data)
739 {
740     if (data == NULL || data->data == NULL || data->len ==0) {
741         LNN_LOGE(LNN_BUILDER, "invalid param");
742         return;
743     }
744     LNN_LOGI(LNN_BUILDER, "authId=%{public}" PRId64 ", module=%{public}d, seq=%{public}" PRId64 ", len=%{public}u.",
745         authHandle.authId, data->module, data->seq, data->len);
746     if (data->module != MODULE_P2P_NETWORKING_SYNC) {
747         LNN_LOGE(LNN_BUILDER, "data->module is not MODULE_P2P_NETWORKING_SYNC");
748         return;
749     }
750     JsonObj *json = JSON_Parse((const char *)data->data, data->len);
751     if (json == NULL) {
752         LNN_LOGE(LNN_BUILDER, "json parse fail");
753         return;
754     }
755     int32_t peerNetworkType = DISCOVERY_TYPE_UNKNOWN;
756     if (!JSON_GetInt32FromOject(json, NETWORK_SYNC_TYPE, &peerNetworkType)) {
757         LNN_LOGE(LNN_BUILDER, "json parse object fail");
758         JSON_Delete(json);
759         return;
760     }
761     JSON_Delete(json);
762     if (peerNetworkType == DISCOVERY_TYPE_BLE) {
763         BleOffLineProcess(data, authHandle);
764     } else if (peerNetworkType == DISCOVERY_TYPE_WIFI) {
765         WlanOffLineProcess(data, authHandle);
766     }
767 }
768 
LnnSyncManagerHandleOffline(const char * networkId)769 static void LnnSyncManagerHandleOffline(const char *networkId)
770 {
771     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
772         LNN_LOGE(LNN_BUILDER, "Lock fail");
773         return;
774     }
775     SyncChannelInfo *item = FindSyncChannelInfoByNetworkId(networkId);
776     if (item == NULL) {
777         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
778         return;
779     }
780     ListDelete(&item->node);
781     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
782     LNN_LOGI(LNN_BUILDER, "close sync channel. client=%{public}d, server=%{public}d", item->clientChannelId,
783         item->serverChannelId);
784     if (item->clientChannelId != INVALID_CHANNEL_ID) {
785         (void)TransCloseNetWorkingChannel(item->clientChannelId);
786     }
787     if (item->serverChannelId != INVALID_CHANNEL_ID) {
788         (void)TransCloseNetWorkingChannel(item->serverChannelId);
789     }
790     ClearSyncInfoMsg(item, &item->syncMsgList);
791     SoftBusFree(item);
792 }
793 
OnLnnOnlineStateChange(const LnnEventBasicInfo * info)794 static void OnLnnOnlineStateChange(const LnnEventBasicInfo *info)
795 {
796     if ((info == NULL) || (info->event != LNN_EVENT_NODE_ONLINE_STATE_CHANGED)) {
797         return;
798     }
799     LnnOnlineStateEventInfo *onlineStateInfo = (LnnOnlineStateEventInfo*)info;
800     if (!onlineStateInfo->isOnline) {
801         LnnSyncManagerHandleOffline(onlineStateInfo->networkId);
802     }
803 }
804 
OnWifiDirectSyncMsgRecv(AuthHandle authHandle,const AuthTransData * data)805 static void OnWifiDirectSyncMsgRecv(AuthHandle authHandle, const AuthTransData *data)
806 {
807     LnnSyncInfoType type;
808     LnnSyncInfoMsgHandler handler;
809     char networkId[NETWORK_ID_BUF_LEN] = {0};
810 
811     if (data == NULL) {
812         LNN_LOGE(LNN_BUILDER, "recv null data, authId=%{public}" PRId64, authHandle.authId);
813         return;
814     }
815     LNN_LOGI(LNN_BUILDER, "recv sync info msg. type=%{public}d, authId=%{public}" PRId64 ", len=%{public}u",
816         (LnnSyncInfoType)(*(int32_t *)data->data), authHandle.authId, data->len);
817     if (data->len <= MSG_HEAD_LEN || data->len > MAX_SYNC_INFO_MSG_LEN) {
818         LNN_LOGE(LNN_BUILDER, "invalid msg. len=%{public}u", data->len);
819         return;
820     }
821     AuthManager *auth = GetAuthManagerByAuthId(authHandle.authId);
822     if (auth == NULL) {
823         return;
824     }
825     char *anonyUdid = NULL;
826     Anonymize(auth->udid, &anonyUdid);
827     LNN_LOGI(LNN_BUILDER, "udid=%{public}s", AnonymizeWrapper(anonyUdid));
828     AnonymizeFree(anonyUdid);
829     if (LnnGetNetworkIdByUdid(auth->udid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
830         LNN_LOGE(LNN_BUILDER, "LnnGetNetworkIdByUdid fail");
831         DelDupAuthManager(auth);
832         return;
833     }
834     DelDupAuthManager(auth);
835     type = (LnnSyncInfoType)(*(int32_t *)data->data);
836     if (type < 0 || type >= LNN_INFO_TYPE_COUNT) {
837         LNN_LOGE(LNN_BUILDER, "received data is exception, type=%{public}d", type);
838         return;
839     }
840     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
841         LNN_LOGE(LNN_BUILDER, "sync info lock fail");
842         return;
843     }
844     handler = g_syncInfoManager.handlers[type];
845     if (handler == NULL) {
846         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
847         return;
848     }
849     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
850     handler(type, networkId, &data->data[MSG_HEAD_LEN], data->len - MSG_HEAD_LEN);
851 }
852 
OnWifiDirectSyncAuthClose(AuthHandle authHandle)853 static void OnWifiDirectSyncAuthClose(AuthHandle authHandle)
854 {
855     LNN_LOGW(LNN_BUILDER, "authId=%{public}" PRId64, authHandle.authId);
856 }
857 
LnnInitSyncInfoManager(void)858 int32_t LnnInitSyncInfoManager(void)
859 {
860     int32_t i;
861 
862     ListInit(&g_syncInfoManager.channelInfoList);
863     for (i = 0; i < LNN_INFO_TYPE_COUNT; ++i) {
864         g_syncInfoManager.handlers[i] = NULL;
865     }
866 
867     AuthTransListener wifiDirectSyncCb = {
868         .onDataReceived = OnWifiDirectSyncMsgRecv,
869         .onDisconnected = OnWifiDirectSyncAuthClose,
870         .onException = NULL,
871     };
872     int32_t ret = RegAuthTransListener(MODULE_AUTH_SYNC_INFO, &wifiDirectSyncCb);
873     if (ret != SOFTBUS_OK) {
874         LNN_LOGE(LNN_INIT, "reg auth lister fail");
875         return ret;
876     }
877     if (LnnRegisterEventHandler(LNN_EVENT_NODE_ONLINE_STATE_CHANGED, OnLnnOnlineStateChange) != SOFTBUS_OK) {
878         LNN_LOGE(LNN_INIT, "reg online lister fail");
879         return SOFTBUS_NETWORK_REG_EVENT_HANDLER_ERR;
880     }
881     if (TransRegisterNetworkingChannelListener(CHANNEL_NAME, &g_networkListener) != SOFTBUS_OK) {
882         LNN_LOGE(LNN_INIT, "reg proxy channel lister fail");
883         return SOFTBUS_TRANS_REGISTER_LISTENER_FAILED;
884     }
885     if (SoftBusMutexInit(&g_syncInfoManager.lock, NULL) != SOFTBUS_OK) {
886         LNN_LOGE(LNN_INIT, "sync info manager mutex init fail");
887         return SOFTBUS_LOCK_ERR;
888     }
889     AuthTransListener p2pNetworkingCb = {
890         .onDataReceived = OnP2pNetworkingDataRecv,
891         .onDisconnected = NULL,
892         .onException = NULL,
893     };
894     ret = RegAuthTransListener(MODULE_P2P_NETWORKING_SYNC, &p2pNetworkingCb);
895     if (ret != SOFTBUS_OK) {
896         LNN_LOGE(LNN_INIT, "p2p networking sync set cb fail");
897         return ret;
898     }
899     return SOFTBUS_OK;
900 }
901 
LnnDeinitSyncInfoManager(void)902 void LnnDeinitSyncInfoManager(void)
903 {
904     int32_t i;
905     for (i = 0; i < LNN_INFO_TYPE_COUNT; ++i) {
906         g_syncInfoManager.handlers[i] = NULL;
907     }
908     UnregAuthTransListener(MODULE_P2P_NETWORKING_SYNC);
909     LnnUnregisterEventHandler(LNN_EVENT_NODE_ONLINE_STATE_CHANGED, OnLnnOnlineStateChange);
910     UnregAuthTransListener(MODULE_AUTH_SYNC_INFO);
911     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
912         LNN_LOGE(LNN_BUILDER, "clear reg sync info lock fail");
913         return;
914     }
915     ClearSyncChannelInfo();
916     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
917     SoftBusMutexDestroy(&g_syncInfoManager.lock);
918 }
919 
LnnRegSyncInfoHandler(LnnSyncInfoType type,LnnSyncInfoMsgHandler handler)920 int32_t LnnRegSyncInfoHandler(LnnSyncInfoType type, LnnSyncInfoMsgHandler handler)
921 {
922     if (type >= LNN_INFO_TYPE_COUNT || handler == NULL) {
923         LNN_LOGE(LNN_BUILDER, "invalid sync info hander reg param. type=%{public}d", type);
924         return SOFTBUS_INVALID_PARAM;
925     }
926     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
927         LNN_LOGE(LNN_BUILDER, "reg sync info handler lock fail");
928         return SOFTBUS_LOCK_ERR;
929     }
930     if (g_syncInfoManager.handlers[type] != NULL) {
931         LNN_LOGE(LNN_BUILDER, "sync info already have handler. type=%{public}d", type);
932         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
933         return SOFTBUS_INVALID_PARAM;
934     }
935     g_syncInfoManager.handlers[type] = handler;
936     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
937     return SOFTBUS_OK;
938 }
939 
LnnUnregSyncInfoHandler(LnnSyncInfoType type,LnnSyncInfoMsgHandler handler)940 int32_t LnnUnregSyncInfoHandler(LnnSyncInfoType type, LnnSyncInfoMsgHandler handler)
941 {
942     if (type >= LNN_INFO_TYPE_COUNT || handler == NULL) {
943         LNN_LOGE(LNN_BUILDER, "invalid sync info hander unreg param. type=%{public}d", type);
944         return SOFTBUS_INVALID_PARAM;
945     }
946     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
947         LNN_LOGE(LNN_BUILDER, "unreg sync info handler lock fail");
948         return SOFTBUS_LOCK_ERR;
949     }
950     if (g_syncInfoManager.handlers[type] != handler) {
951         LNN_LOGE(LNN_BUILDER, "sync info handler not valid. type=%{public}d", type);
952         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
953         return SOFTBUS_INVALID_PARAM;
954     }
955     g_syncInfoManager.handlers[type] = NULL;
956     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
957     return SOFTBUS_OK;
958 }
959 
ResetSendSyncInfo(SyncChannelInfo * oldInfo,const SyncChannelInfo * newInfo,SyncInfoMsg * msg)960 static void ResetSendSyncInfo(SyncChannelInfo *oldInfo, const SyncChannelInfo *newInfo, SyncInfoMsg *msg)
961 {
962     if (oldInfo->clientChannelId == INVALID_CHANNEL_ID) {
963         oldInfo->clientChannelId = newInfo->clientChannelId;
964         oldInfo->accessTime = newInfo->accessTime;
965     } else {
966         if (oldInfo->clientChannelId != newInfo->clientChannelId && oldInfo->clientChannelId != INVALID_CHANNEL_ID) {
967             LNN_LOGD(LNN_BUILDER, "reset sync info send channel. clientChannelId:%{public}d->%{public}d",
968                 oldInfo->clientChannelId, newInfo->clientChannelId);
969             (void)TransCloseNetWorkingChannel(oldInfo->clientChannelId);
970             oldInfo->isClientOpened = false;
971             oldInfo->clientChannelId = newInfo->clientChannelId;
972         }
973         if (oldInfo->isClientOpened) {
974             SendSyncInfoMsg(oldInfo, msg);
975         } else {
976             LNN_LOGW(LNN_BUILDER, "send sync info client is not opened, channelId=%{public}d",
977                 oldInfo->clientChannelId);
978         }
979     }
980 }
981 
SendSyncInfoByNewChannel(const char * networkId,SyncInfoMsg * msg)982 static int32_t SendSyncInfoByNewChannel(const char *networkId, SyncInfoMsg *msg)
983 {
984     SyncChannelInfo *info = CreateSyncChannelInfo(networkId);
985     if (info == NULL) {
986         return SOFTBUS_MALLOC_ERR;
987     }
988     info->clientChannelId = TransOpenNetWorkingChannel(CHANNEL_NAME, networkId, NULL);
989     if (info->clientChannelId == INVALID_CHANNEL_ID) {
990         LNN_LOGE(LNN_BUILDER, "open sync info channel fail");
991         SoftBusFree(info);
992         return SOFTBUS_INVALID_PARAM;
993     }
994     char *anonyNetworkId = NULL;
995     Anonymize(networkId, &anonyNetworkId);
996     LNN_LOGI(LNN_BUILDER,
997         "open sync info. channelId=%{public}d, networkId=%{public}s",
998         info->clientChannelId, AnonymizeWrapper(anonyNetworkId));
999     AnonymizeFree(anonyNetworkId);
1000     SoftBusGetTime(&info->accessTime);
1001     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
1002         LNN_LOGE(LNN_BUILDER, "send sync info lock fail");
1003         SoftBusFree(info);
1004         return SOFTBUS_LOCK_ERR;
1005     }
1006     SyncChannelInfo *item = FindSyncChannelInfoByNetworkId(networkId);
1007     if (item == NULL) {
1008         ListTailInsert(&info->syncMsgList, &msg->node);
1009         if (IsListEmpty(&g_syncInfoManager.channelInfoList)) {
1010             (void)LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT),
1011                 CloseUnusedChannel, NULL, UNUSED_CHANNEL_CLOSED_DELAY);
1012         }
1013         ListNodeInsert(&g_syncInfoManager.channelInfoList, &info->node);
1014     } else {
1015         ListTailInsert(&item->syncMsgList, &msg->node);
1016         ResetSendSyncInfo(item, info, msg);
1017         SoftBusFree(info);
1018     }
1019     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
1020     return SOFTBUS_OK;
1021 }
1022 
TrySendSyncInfoMsg(const char * networkId,SyncInfoMsg * msg)1023 static int32_t TrySendSyncInfoMsg(const char *networkId, SyncInfoMsg *msg)
1024 {
1025     LNN_LOGI(LNN_BUILDER, "begin send sync info");
1026     SyncChannelInfo *info = NULL;
1027     if (SoftBusMutexLock(&g_syncInfoManager.lock) != 0) {
1028         LNN_LOGE(LNN_BUILDER, "send sync info lock fail");
1029         return SOFTBUS_LOCK_ERR;
1030     }
1031     info = FindSyncChannelInfoByNetworkId(networkId);
1032     if (info == NULL) {
1033         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
1034         return SendSyncInfoByNewChannel(networkId, msg);
1035     }
1036     if (info->clientChannelId == INVALID_CHANNEL_ID) {
1037         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
1038         return SendSyncInfoByNewChannel(networkId, msg);
1039     }
1040     char *anonyNetworkId = NULL;
1041     Anonymize(networkId, &anonyNetworkId);
1042     LNN_LOGI(LNN_BUILDER,
1043         "send sync info by alread exists channel. channelId=%{public}d, networkId=%{public}s",
1044         info->clientChannelId, AnonymizeWrapper(anonyNetworkId));
1045     AnonymizeFree(anonyNetworkId);
1046     ListTailInsert(&info->syncMsgList, &msg->node);
1047     if (info->isClientOpened) {
1048         SoftBusGetTime(&info->accessTime);
1049         ListDelete(&msg->node);
1050         int32_t id = info->clientChannelId;
1051         (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
1052         SendSyncInfoMsgOnly(networkId, id, msg);
1053         return SOFTBUS_OK;
1054     }
1055     (void)SoftBusMutexUnlock(&g_syncInfoManager.lock);
1056     return SOFTBUS_OK;
1057 }
1058 
GetWifiDirectAuthByNetworkId(const char * networkId,AuthHandle * authHandle)1059 static int32_t GetWifiDirectAuthByNetworkId(const char *networkId, AuthHandle *authHandle)
1060 {
1061     char uuid[UUID_BUF_LEN] = {0};
1062     char *anonyNetworkId = NULL;
1063     Anonymize(networkId, &anonyNetworkId);
1064     (void)LnnConvertDlId(networkId, CATEGORY_NETWORK_ID, CATEGORY_UUID, uuid, UUID_BUF_LEN);
1065     AuthDeviceGetLatestIdByUuid(uuid, AUTH_LINK_TYPE_ENHANCED_P2P, authHandle);
1066     if (authHandle->authId != AUTH_INVALID_ID) {
1067         LNN_LOGI(LNN_BUILDER, "find wifidirect authHandle, networkId=%{public}s",
1068             AnonymizeWrapper(anonyNetworkId));
1069         AnonymizeFree(anonyNetworkId);
1070         return SOFTBUS_OK;
1071     }
1072     AnonymizeFree(anonyNetworkId);
1073     return SOFTBUS_INVALID_PARAM;
1074 }
1075 
TrySendSyncInfoMsgByAuth(const char * networkId,SyncInfoMsg * msg)1076 static int32_t TrySendSyncInfoMsgByAuth(const char *networkId, SyncInfoMsg *msg)
1077 {
1078     char *anonyNetworkId = NULL;
1079     Anonymize(networkId, &anonyNetworkId);
1080     AuthHandle authHandle = {
1081         .authId = AUTH_INVALID_ID
1082     };
1083     if (GetWifiDirectAuthByNetworkId(networkId, &authHandle) != SOFTBUS_OK) {
1084         LNN_LOGE(LNN_BUILDER, "get authHandle fail, networkId=%{public}s", AnonymizeWrapper(anonyNetworkId));
1085         AnonymizeFree(anonyNetworkId);
1086         return SOFTBUS_INVALID_PARAM;
1087     }
1088     AnonymizeFree(anonyNetworkId);
1089     LNN_LOGI(LNN_BUILDER, "send sync info, authId=%{public}" PRId64 ", datalen=%{public}u",
1090         authHandle.authId, msg->dataLen);
1091     AuthTransData dataInfo = {
1092         .module = MODULE_AUTH_SYNC_INFO,
1093         .flag = 0,
1094         .seq = 0,
1095         .len = msg->dataLen,
1096         .data = msg->data,
1097     };
1098     int32_t ret = AuthPostTransData(authHandle, &dataInfo);
1099     if (ret != SOFTBUS_OK) {
1100         LNN_LOGE(LNN_BUILDER, "auth post data fail");
1101         return ret;
1102     }
1103     if (msg->complete != NULL) {
1104         msg->complete((LnnSyncInfoType)(*(uint32_t *)msg->data), networkId, &msg->data[MSG_HEAD_LEN],
1105             msg->dataLen - MSG_HEAD_LEN);
1106     }
1107     return SOFTBUS_OK;
1108 }
1109 
GetFeatureCap(const char * networkId,uint64_t * local,uint64_t * remote)1110 static int32_t GetFeatureCap(const char *networkId, uint64_t *local, uint64_t *remote)
1111 {
1112     int32_t ret = LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, local);
1113     if (ret != SOFTBUS_OK || *local == 0) {
1114         LNN_LOGE(LNN_BUILDER, "get local cap fail, ret=%{public}d, local=%{public}" PRIu64, ret, *local);
1115         return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
1116     }
1117     ret = LnnGetRemoteNumU64Info(networkId, NUM_KEY_FEATURE_CAPA, remote);
1118     if (ret != SOFTBUS_OK || *remote == 0) {
1119         LNN_LOGE(LNN_BUILDER, "get remote cap fail, ret=%{public}d, remote=%{public}" PRIu64, ret, *remote);
1120         return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
1121     }
1122     return SOFTBUS_OK;
1123 }
1124 
IsNeedSyncByAuth(const char * networkId)1125 static bool IsNeedSyncByAuth(const char *networkId)
1126 {
1127     uint32_t localCap;
1128     uint32_t remoteCap;
1129     if (LnnGetLocalNumU32Info(NUM_KEY_NET_CAP, &localCap) != SOFTBUS_OK ||
1130         LnnGetRemoteNumU32Info(networkId, NUM_KEY_NET_CAP, &remoteCap) != SOFTBUS_OK) {
1131         LNN_LOGE(LNN_BUILDER, "get cap fail");
1132         return false;
1133     }
1134     if (((localCap & (1 << BIT_WIFI_P2P)) == 0) || ((remoteCap & (1 << BIT_WIFI_P2P)) == 0)) {
1135         LNN_LOGI(LNN_BUILDER, "not support p2p");
1136         return false;
1137     }
1138     uint64_t local = 0;
1139     uint64_t remote = 0;
1140     if (GetFeatureCap(networkId, &local, &remote) != SOFTBUS_OK) {
1141         LNN_LOGE(LNN_BUILDER, "get feature fail");
1142         return false;
1143     }
1144     if ((local & (1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY)) == 0 ||
1145         (remote & (1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY)) == 0) {
1146         LNN_LOGI(LNN_BUILDER, "not support wifi direct");
1147         return false;
1148     }
1149     NodeInfo node;
1150     (void)memset_s(&node, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1151     if (LnnGetRemoteNodeInfoById(networkId, CATEGORY_NETWORK_ID, &node) != SOFTBUS_OK) {
1152         LNN_LOGE(LNN_BUILDER, "get remote node info fail");
1153         return false;
1154     }
1155     if (LnnHasDiscoveryType(&node, DISCOVERY_TYPE_WIFI) || LnnHasDiscoveryType(&node, DISCOVERY_TYPE_LSA)) {
1156         LNN_LOGI(LNN_BUILDER, "peer node is wifi online");
1157         return false;
1158     }
1159     if ((localCap & (1 << BIT_BR)) && (remoteCap & (1 << BIT_BR))) {
1160         LNN_LOGI(LNN_BUILDER, "both support br");
1161         return false;
1162     }
1163     LNN_LOGI(LNN_BUILDER, "need sync info by auth");
1164     return true;
1165 }
1166 
LnnSendSyncInfoMsg(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len,LnnSyncInfoMsgComplete complete)1167 int32_t LnnSendSyncInfoMsg(LnnSyncInfoType type, const char *networkId,
1168     const uint8_t *msg, uint32_t len, LnnSyncInfoMsgComplete complete)
1169 {
1170     SyncInfoMsg *syncMsg = NULL;
1171     int32_t rc;
1172 
1173     LNN_LOGI(LNN_BUILDER, "send sync info msg for type=%{public}d, len=%{public}d", type, len);
1174     if (type >= LNN_INFO_TYPE_COUNT || networkId == NULL || msg == NULL) {
1175         LNN_LOGE(LNN_BUILDER, "invalid sync info msg param");
1176         return SOFTBUS_INVALID_PARAM;
1177     }
1178     syncMsg = CreateSyncInfoMsg(type, msg, len, complete);
1179     if (syncMsg == NULL) {
1180         return SOFTBUS_MEM_ERR;
1181     }
1182     if (IsNeedSyncByAuth(networkId)) {
1183         rc = TrySendSyncInfoMsgByAuth(networkId, syncMsg);
1184         if (rc == SOFTBUS_OK) {
1185             SoftBusFree(syncMsg);
1186             return rc;
1187         }
1188     }
1189     rc = TrySendSyncInfoMsg(networkId, syncMsg);
1190     if (rc != SOFTBUS_OK) {
1191         SoftBusFree(syncMsg);
1192     }
1193     return rc;
1194 }
1195 
FillAuthdataInfo(AuthTransData * dataInfo,char * msg)1196 static void FillAuthdataInfo(AuthTransData *dataInfo, char *msg)
1197 {
1198     dataInfo->module = MODULE_P2P_NETWORKING_SYNC;
1199     dataInfo->flag = 0;
1200     dataInfo->seq = 0;
1201     dataInfo->len = strlen(msg) + 1;
1202     dataInfo->data = (const uint8_t *)msg;
1203 }
1204 
GetAuthHandleByNetworkId(const char * networkId,AuthHandle * authHandle)1205 static int32_t GetAuthHandleByNetworkId(const char *networkId, AuthHandle *authHandle)
1206 {
1207     char uuid[UUID_BUF_LEN] = {0};
1208     char *anonyNetworkId = NULL;
1209     Anonymize(networkId, &anonyNetworkId);
1210     (void)LnnConvertDlId(networkId, CATEGORY_NETWORK_ID, CATEGORY_UUID, uuid, UUID_BUF_LEN);
1211     AuthDeviceGetLatestIdByUuid(uuid, AUTH_LINK_TYPE_P2P, authHandle);
1212     if (authHandle->authId != AUTH_INVALID_ID) {
1213         LNN_LOGI(LNN_BUILDER, "find p2p authHandle, networkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
1214         AnonymizeFree(anonyNetworkId);
1215         return SOFTBUS_OK;
1216     }
1217     AuthDeviceGetLatestIdByUuid(uuid, AUTH_LINK_TYPE_ENHANCED_P2P, authHandle);
1218     if (authHandle->authId != AUTH_INVALID_ID) {
1219         LNN_LOGI(LNN_BUILDER, "find hml authHandle, networkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
1220         AnonymizeFree(anonyNetworkId);
1221         return SOFTBUS_OK;
1222     }
1223     AnonymizeFree(anonyNetworkId);
1224     return SOFTBUS_NOT_FIND;
1225 }
1226 
LnnSendP2pSyncInfoMsg(const char * networkId,uint32_t netCapability)1227 int32_t LnnSendP2pSyncInfoMsg(const char *networkId, uint32_t netCapability)
1228 {
1229     char *anonyNetworkId = NULL;
1230     if (networkId == NULL) {
1231         LNN_LOGE(LNN_BUILDER, "invalid param");
1232         return SOFTBUS_INVALID_PARAM;
1233     }
1234     Anonymize(networkId, &anonyNetworkId);
1235     AuthHandle authHandle = { .authId = AUTH_INVALID_ID };
1236     if (GetAuthHandleByNetworkId(networkId, &authHandle) != SOFTBUS_OK) {
1237         LNN_LOGE(LNN_BUILDER, "get authHandle fail, networkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
1238         AnonymizeFree(anonyNetworkId);
1239         return SOFTBUS_AUTH_NOT_FOUND;
1240     }
1241     int64_t authSeq[2] = {0};
1242     uint64_t authVerifyTime[2] = {0};
1243     char udid[UDID_BUF_LEN] = {0};
1244     (void)LnnConvertDlId(networkId, CATEGORY_NETWORK_ID, CATEGORY_UDID, udid, UDID_BUF_LEN);
1245     if (AuthGetLatestAuthSeqListByType(udid, authSeq, authVerifyTime, DISCOVERY_TYPE_BLE) != SOFTBUS_OK ||
1246         (authSeq[0] == 0 && authSeq[1] == 0)) {
1247         LNN_LOGE(LNN_BUILDER, "seqErr, ble authSeq:%{public}" PRId64 ", %{public}" PRId64 "", authSeq[0], authSeq[1]);
1248         AnonymizeFree(anonyNetworkId);
1249         return SOFTBUS_AUTH_NOT_FOUND;
1250     }
1251     char *msg = PackBleOfflineMsg((int64_t)netCapability, DISCOVERY_TYPE_BLE,
1252         authVerifyTime[0] > authVerifyTime[1] ? authSeq[0] : authSeq[1]);
1253     if (msg == NULL) {
1254         LNN_LOGE(LNN_BUILDER, "pack p2p networking msg fail, networkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
1255         AnonymizeFree(anonyNetworkId);
1256         return SOFTBUS_NETWORK_PACK_DATA_FAILED;
1257     }
1258     AuthTransData dataInfo = {0};
1259     FillAuthdataInfo(&dataInfo, msg);
1260     if (SoftBusGenerateRandomArray((uint8_t *)&dataInfo.seq, sizeof(int64_t)) != SOFTBUS_OK) {
1261         LNN_LOGE(LNN_BUILDER, "generate seq fail");
1262         AnonymizeFree(anonyNetworkId);
1263         cJSON_free(msg);
1264         return SOFTBUS_GENERATE_RANDOM_ARRAY_FAIL;
1265     }
1266     if (AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_OK) {
1267         LNN_LOGI(LNN_BUILDER, "send p2p sync info msg to networkId:%{public}s, netCap:%{public}u, seq:%{public}"
1268             PRId64 ", [%{public}" PRId64 "/%{public}" PRId64 ", %{public}" PRIu64 "/%{public}" PRId64 "]",
1269             AnonymizeWrapper(anonyNetworkId), netCapability, dataInfo.seq,
1270             authVerifyTime[0], authSeq[0], authVerifyTime[1], authSeq[1]);
1271     } else {
1272         LNN_LOGE(LNN_BUILDER, "post trans data fail, networkId:%{public}s", AnonymizeWrapper(anonyNetworkId));
1273     }
1274     AnonymizeFree(anonyNetworkId);
1275     cJSON_free(msg);
1276     return SOFTBUS_OK;
1277 }
1278 
LnnSendWifiOfflineInfoMsg(void)1279 int32_t LnnSendWifiOfflineInfoMsg(void)
1280 {
1281     int32_t authPort = 0;
1282     char localOfflineCode[WIFI_OFFLINE_CODE_LEN] = {0};
1283     if (LnnGetLocalNumInfoByIfnameIdx(NUM_KEY_AUTH_PORT, &authPort, WLAN_IF) != SOFTBUS_OK) {
1284         LNN_LOGE(LNN_BUILDER, "get local authPort fail");
1285         return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
1286     }
1287     if (LnnGetLocalStrInfo(STRING_KEY_OFFLINE_CODE, localOfflineCode, WIFI_OFFLINE_CODE_LEN) != SOFTBUS_OK) {
1288         LNN_LOGE(LNN_BUILDER, "get local offlinecode fail");
1289         return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
1290     }
1291     char convertOfflineCode[WIFI_OFFLINE_CODE_LEN * HEXIFY_UNIT_LEN + 1] = {0};
1292     if (ConvertBytesToHexString(convertOfflineCode, WIFI_OFFLINE_CODE_LEN * HEXIFY_UNIT_LEN + 1,
1293         (unsigned char *)localOfflineCode, WIFI_OFFLINE_CODE_LEN) != SOFTBUS_OK) {
1294         LNN_LOGE(LNN_BUILDER, "convert offlinecode fail");
1295         return SOFTBUS_BYTE_CONVERT_FAIL;
1296     }
1297     char *msg = PackWifiOfflineMsg(authPort, convertOfflineCode);
1298     if (msg == NULL) {
1299         LNN_LOGE(LNN_BUILDER, "pack p2p networking msg fail");
1300         return SOFTBUS_NETWORK_PACK_DATA_FAILED;
1301     }
1302     AuthTransData dataInfo = {0};
1303     FillAuthdataInfo(&dataInfo, msg);
1304     AuthHandle *authHandle = NULL;
1305     int32_t num = 0;
1306     if (GetHmlOrP2pAuthHandle(&authHandle, &num) != SOFTBUS_OK) {
1307         LNN_LOGE(LNN_BUILDER, "get authHandle fail");
1308         cJSON_free(msg);
1309         return SOFTBUS_AUTH_NOT_FOUND;
1310     }
1311     char *anonyOfflineCode = NULL;
1312     Anonymize(convertOfflineCode, &anonyOfflineCode);
1313     for (int32_t i = 0; i < num; i++) {
1314         if (AuthPostTransData(authHandle[i], &dataInfo) == SOFTBUS_OK) {
1315             LNN_LOGI(LNN_BUILDER, "send wifi offline msg sucess, authPort:%{public}d, offlineCode:%{public}s,"
1316                 "authId:%{public}" PRId64, authPort, AnonymizeWrapper(anonyOfflineCode), authHandle->authId);
1317         } else {
1318             LNN_LOGE(LNN_BUILDER, "post trans data fail, authId:%{public}" PRId64, authHandle->authId);
1319         }
1320     }
1321     cJSON_free(msg);
1322     SoftBusFree(authHandle);
1323     AnonymizeFree(anonyOfflineCode);
1324     return SOFTBUS_OK;
1325 }
1326 
LnnSendAsyncInfoMsg(void * param)1327 void LnnSendAsyncInfoMsg(void *param)
1328 {
1329     SendSyncInfoParam *data = (SendSyncInfoParam *)param;
1330     if (data == NULL) {
1331         LNN_LOGE(LNN_BUILDER, "invalid para");
1332         return;
1333     }
1334     if (data->msg == NULL) {
1335         LNN_LOGE(LNN_BUILDER, "invalid para");
1336         SoftBusFree(data);
1337         return;
1338     }
1339     int32_t ret =
1340         LnnSendSyncInfoMsg(data->type, data->networkId, data->msg, data->len, data->complete);
1341     if (ret != SOFTBUS_OK) {
1342         LNN_LOGE(LNN_BUILDER, "send info msg type=%{public}d fail, ret:%{public}d", data->type, ret);
1343     }
1344     SoftBusFree(data->msg);
1345     SoftBusFree(data);
1346 }
1347 
CreateSyncInfoParam(LnnSyncInfoType type,const char * networkId,const uint8_t * msg,uint32_t len,LnnSyncInfoMsgComplete complete)1348 SendSyncInfoParam *CreateSyncInfoParam(
1349     LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t len, LnnSyncInfoMsgComplete complete)
1350 {
1351     SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
1352     if (data == NULL) {
1353         LNN_LOGE(LNN_BUILDER, "malloc SendSyncInfoParam fail");
1354         return NULL;
1355     }
1356 
1357     data->msg = (uint8_t *)SoftBusCalloc(len);
1358     if (data->msg == NULL) {
1359         SoftBusFree(data);
1360         LNN_LOGE(LNN_BUILDER, "malloc SendSyncInfoParam fail");
1361         return NULL;
1362     }
1363 
1364     if (strcpy_s(data->networkId, strlen(networkId) + 1, networkId) != SOFTBUS_OK ||
1365         memcpy_s(data->msg, len, (uint8_t *)msg, len) != SOFTBUS_OK) {
1366         SoftBusFree(data->msg);
1367         SoftBusFree(data);
1368         return NULL;
1369     }
1370     data->type = type;
1371     data->len = len;
1372     data->complete = complete;
1373     return data;
1374 }
1375