1 /*
2 * Copyright (c) 2021-2024 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 "disc_ble.h"
17
18 #include <stdlib.h>
19 #include <stdio.h>
20
21 #include "anonymizer.h"
22 #include "broadcast_scheduler.h"
23 #include "common_list.h"
24 #include "disc_ble_constant.h"
25 #include "disc_ble_utils.h"
26 #include "disc_event.h"
27 #include "disc_log.h"
28 #include "disc_manager.h"
29 #include "lnn_device_info.h"
30 #include "lnn_ohos_account.h"
31 #include "message_handler.h"
32 #include "securec.h"
33 #include "softbus_adapter_bt_common.h"
34 #include "softbus_adapter_crypto.h"
35 #include "softbus_adapter_mem.h"
36 #include "softbus_adapter_range.h"
37 #include "softbus_bitmap.h"
38 #include "softbus_errcode.h"
39 #include "softbus_hidumper_disc.h"
40 #include "softbus_hisysevt_discreporter.h"
41 #include "softbus_json_utils.h"
42 #include "softbus_utils.h"
43
44 #define BLE_PUBLISH 0x0
45 #define BLE_SUBSCRIBE 0x2
46 #define BLE_ACTIVE 0x0
47 #define BLE_PASSIVE 0x1
48 #define BLE_INFO_COUNT 4
49
50 #define BLE_CHANNLE_MAP 0x0
51
52 #define BLE_ADV_TX_POWER_DEFAULT (-6)
53 #define BLE_ADV_TX_POWER_MAX (-2)
54
55 #define CON_ADV_ID 0x0
56 #define NON_ADV_ID 0x1
57 #define NUM_ADVERTISER 2
58 #define ADV_INTERNAL 48
59
60 #define BLE_MSG_TIME_OUT 6000
61
62 // Defination of boardcast
63 #define BLE_VERSION 4
64 #define DISTRIBUTE_BUSINESS 0x5
65 #define DEVICE_NAME_MAX_LEN 15
66
67 #define BIT_WAKE_UP 0x01
68 #define BIT_CUST_DATA_TYPE 0x10
69 #define BIT_HEART_BIT 0x20
70 #define BIT_CONNECT_BIT 0x40
71 #define BIT_CON 0x80
72 #define BIT_CON_POS 7
73
74 #define BLE_INFO_MANAGER "bleInfoManager"
75 #define BlE_ADVERTISER "bleAdvertiser"
76 #define RECV_MESSAGE_INFO "recvMessageInfo"
77
78 typedef enum {
79 CON_FILTER_TYPE = 1,
80 NON_FILTER_TYPE = 2,
81 MAX_FILTER_TYPE,
82 } DicsBleFilterType;
83
84 typedef enum {
85 PUBLISH_ACTIVE_SERVICE,
86 PUBLISH_PASSIVE_SERVICE,
87 UNPUBLISH_SERVICE,
88 START_ACTIVE_DISCOVERY,
89 START_PASSIVE_DISCOVERY,
90 STOP_DISCOVERY,
91 REPLY_PASSIVE_NON_BROADCAST,
92 PROCESS_TIME_OUT,
93 RECOVERY,
94 TURN_OFF,
95 BR_STATE_CHANGED,
96 } DiscBleMessage;
97
98 typedef struct {
99 int32_t channel;
100 bool isAdvertising;
101 DeviceInfo deviceInfo;
102 int32_t (*GetDeviceInfo)(DeviceInfo *info);
103 } DiscBleAdvertiser;
104
105 typedef struct {
106 bool needUpdate;
107 bool needUpdateCap;
108 uint32_t capBitMap[CAPABILITY_NUM];
109 int16_t capCount[CAPABILITY_MAX_BITNUM];
110 uint8_t *capabilityData[CAPABILITY_MAX_BITNUM];
111 uint32_t capDataLen[CAPABILITY_MAX_BITNUM];
112 bool isSameAccount[CAPABILITY_MAX_BITNUM];
113 bool isWakeRemote[CAPABILITY_MAX_BITNUM];
114 int32_t freq[CAPABILITY_MAX_BITNUM];
115 int32_t rangingRefCnt;
116 } DiscBleInfo;
117
118 typedef struct {
119 PublishOption *publishOption;
120 SubscribeOption *subscribeOption;
121 } DiscBleOption;
122
123 typedef struct {
124 int32_t scanWindow;
125 int32_t scanInterval;
126 } ScanSetting;
127
128 typedef struct {
129 ListNode node;
130 uint32_t capBitMap[CAPABILITY_NUM];
131 char key[SHA_HASH_LEN];
132 bool needBrMac;
133 } RecvMessage;
134
135 typedef struct {
136 uint32_t numNeedBrMac;
137 uint32_t numNeedResp;
138 ListNode node;
139 SoftBusMutex lock;
140 } RecvMessageInfo;
141
142 typedef struct {
143 int32_t stateListenerId;
144 int32_t scanListenerId;
145 } DiscBleListener;
146
147 typedef struct {
148 uint32_t optionCapBitMap[CAPABILITY_NUM];
149 uint8_t *custData;
150 uint32_t custDataLen;
151 uint32_t freq;
152 bool isSameAccount;
153 bool isWakeRemote;
154 bool ranging;
155 } BleOption;
156
157 static ScanSetting g_scanTable[FREQ_BUTT] = {
158 {SOFTBUS_BC_SCAN_WINDOW_P2, SOFTBUS_BC_SCAN_INTERVAL_P2},
159 {SOFTBUS_BC_SCAN_WINDOW_P10, SOFTBUS_BC_SCAN_INTERVAL_P10},
160 {SOFTBUS_BC_SCAN_WINDOW_P25, SOFTBUS_BC_SCAN_INTERVAL_P25},
161 {SOFTBUS_BC_SCAN_WINDOW_P75, SOFTBUS_BC_SCAN_INTERVAL_P75},
162 {SOFTBUS_BC_SCAN_WINDOW_P100, SOFTBUS_BC_SCAN_INTERVAL_P100}
163 };
164
165 static DiscInnerCallback *g_discBleInnerCb = NULL;
166 static DiscBleInfo g_bleInfoManager[BLE_INFO_COUNT];
167 static SoftBusMutex g_bleInfoLock = {0};
168 static DiscBleAdvertiser g_bleAdvertiser[NUM_ADVERTISER];
169 static bool g_isScanning = false;
170 static SoftBusHandler g_discBleHandler = {};
171 static RecvMessageInfo g_recvMessageInfo = {};
172 static DiscBleListener g_bleListener = {
173 .stateListenerId = -1,
174 .scanListenerId = -1
175 };
176
177 // g_conncernCapabilityMask support capability of this ble discovery
178 static uint32_t g_concernCapabilityMask =
179 1 << CASTPLUS_CAPABILITY_BITMAP |
180 1 << DVKIT_CAPABILITY_BITMAP |
181 1 << OSD_CAPABILITY_BITMAP;
182
183 static const int g_bleTransCapabilityMap[CAPABILITY_MAX_BITNUM] = {
184 -1,
185 CASTPLUS_CAPABILITY_BITMAP,
186 DVKIT_CAPABILITY_BITMAP,
187 -1,
188 OSD_CAPABILITY_BITMAP,
189 -1,
190 -1,
191 -1,
192 -1,
193 -1,
194 -1,
195 -1,
196 -1,
197 -1,
198 -1,
199 -1,
200 };
201
202 static SoftBusMessage *CreateBleHandlerMsg(int32_t what, uint64_t arg1, uint64_t arg2, void *obj);
203 static int32_t AddRecvMessage(const char *key, const uint32_t *capBitMap, bool needBrMac);
204 static int32_t MatchRecvMessage(const uint32_t *publishInfoMap, uint32_t *capBitMap, uint32_t len);
205 static RecvMessage *GetRecvMessage(const char *key);
206 static int32_t StartAdvertiser(int32_t adv);
207 static int32_t StopAdvertiser(int32_t adv);
208 static int32_t UpdateAdvertiser(int32_t adv);
209 static int32_t ReplyPassiveNonBroadcast(void);
210 static void ClearRecvMessage(void);
211 static int32_t StopScaner(void);
212 static void AssembleNonOptionalTlv(DeviceInfo *info, BroadcastData *broadcastData);
213 static int32_t BleInfoDump(int fd);
214 static int32_t BleAdvertiserDump(int fd);
215 static int32_t RecvMessageInfoDump(int fd);
216 static void DiscBleSetScanFilter(int32_t listenerId, int32_t type);
217
218 // This function is used to compatibled with mobile phone, will remove later
ConvertCapBitMap(int oldCap)219 static int ConvertCapBitMap(int oldCap)
220 {
221 switch (oldCap) {
222 case 1 << OSD_CAPABILITY_BITMAP: // osdCapability
223 return 0x10;
224 case 1 << CASTPLUS_CAPABILITY_BITMAP: // castPlus
225 return 0x02;
226 case 1 << DVKIT_CAPABILITY_BITMAP: // dvkit
227 return 0x04;
228 default:
229 return oldCap;
230 }
231 }
232
DeConvertBitMap(unsigned int * dstCap,unsigned int * srcCap,int nums)233 static void DeConvertBitMap(unsigned int *dstCap, unsigned int *srcCap, int nums)
234 {
235 (void)nums;
236 for (int32_t i = 0; i < CAPABILITY_MAX_BITNUM; i++) {
237 if (!SoftbusIsBitmapSet(srcCap, i)) {
238 continue;
239 }
240 int bleCapability = g_bleTransCapabilityMap[i];
241 if (bleCapability >= 0) {
242 SoftbusBitmapSet(dstCap, bleCapability);
243 }
244 }
245 DISC_LOGD(DISC_BLE, "old=%{public}u, new=%{public}u", *srcCap, *dstCap);
246 }
247
UpdateInfoManager(int adv,bool needUpdate)248 static void UpdateInfoManager(int adv, bool needUpdate)
249 {
250 DISC_LOGI(DISC_CONTROL, "enter");
251 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_bleInfoLock) == SOFTBUS_OK, DISC_BLE, "lock failed");
252 if (adv == NON_ADV_ID) {
253 g_bleInfoManager[BLE_PUBLISH | BLE_ACTIVE].needUpdate = needUpdate;
254 g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].needUpdate = needUpdate;
255 } else {
256 g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].needUpdate = needUpdate;
257 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].needUpdate = needUpdate;
258 }
259 SoftBusMutexUnlock(&g_bleInfoLock);
260 }
261
GetNeedUpdateAdvertiser(int32_t adv)262 static int32_t GetNeedUpdateAdvertiser(int32_t adv)
263 {
264 if (adv == NON_ADV_ID) {
265 return g_bleInfoManager[BLE_PUBLISH | BLE_ACTIVE].needUpdate ||
266 g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].needUpdate;
267 } else {
268 return g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].needUpdate ||
269 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].needUpdate;
270 }
271 }
272
UpdateScannerInfoManager(int32_t type,bool needUpdate)273 static void UpdateScannerInfoManager(int32_t type, bool needUpdate)
274 {
275 DISC_LOGD(DISC_BLE, "enter");
276 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_bleInfoLock) == SOFTBUS_OK, DISC_BLE, "lock failed");
277 if (type == CON_FILTER_TYPE) {
278 g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].needUpdateCap = needUpdate;
279 } else if (type == NON_FILTER_TYPE) {
280 g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].needUpdateCap = needUpdate;
281 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].needUpdateCap = needUpdate;
282 } else if (type == (CON_FILTER_TYPE | NON_FILTER_TYPE)) {
283 g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].needUpdateCap = needUpdate;
284 g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].needUpdateCap = needUpdate;
285 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].needUpdateCap = needUpdate;
286 }
287 SoftBusMutexUnlock(&g_bleInfoLock);
288 }
289
GetNeedUpdateScanner(int32_t type)290 static bool GetNeedUpdateScanner(int32_t type)
291 {
292 if (type == CON_FILTER_TYPE) {
293 return g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].needUpdateCap;
294 } else if (type == NON_FILTER_TYPE) {
295 return g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].needUpdateCap ||
296 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].needUpdateCap;
297 } else if (type == (CON_FILTER_TYPE | NON_FILTER_TYPE)) {
298 return g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].needUpdateCap ||
299 g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].needUpdateCap ||
300 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].needUpdateCap;
301 }
302 return false;
303 }
304
BleAdvEnableCallback(int channel,int status)305 static void BleAdvEnableCallback(int channel, int status)
306 {
307 if (status == SOFTBUS_BT_STATUS_SUCCESS) {
308 for (int32_t i = 0; i < NUM_ADVERTISER; i++) {
309 if (g_bleAdvertiser[i].channel == channel) {
310 g_bleAdvertiser[i].isAdvertising = true;
311 DISC_LOGI(DISC_BLE, "enable ble advertiser adv=%{public}d", i);
312 }
313 }
314 }
315 }
316
BleAdvDisableCallback(int channel,int status)317 static void BleAdvDisableCallback(int channel, int status)
318 {
319 if (status == SOFTBUS_BT_STATUS_SUCCESS) {
320 for (int32_t i = 0; i < NUM_ADVERTISER; i++) {
321 if (g_bleAdvertiser[i].channel == channel) {
322 g_bleAdvertiser[i].isAdvertising = false;
323 DISC_LOGI(DISC_BLE, "disable ble advertiser adv=%{public}d", i);
324 }
325 }
326 }
327 }
328
BleAdvDataCallback(int channel,int status)329 static void BleAdvDataCallback(int channel, int status)
330 {
331 DISC_LOGI(DISC_BLE, "channel=%{public}d, status=%{public}d", channel, status);
332 }
333
BleAdvUpdateCallback(int channel,int status)334 static void BleAdvUpdateCallback(int channel, int status)
335 {
336 DISC_LOGI(DISC_BLE, "channel=%{public}d, status=%{public}d", channel, status);
337 }
338
GetScannerFilterType(void)339 static int32_t GetScannerFilterType(void)
340 {
341 int32_t type = 0;
342 DISC_CHECK_AND_RETURN_RET_LOGE(
343 SoftBusMutexLock(&g_bleInfoLock) == SOFTBUS_OK, SOFTBUS_LOCK_ERR, DISC_BLE, "lock failed");
344 uint32_t conScanCapBit = g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].capBitMap[0];
345 uint32_t nonScanCapBit = g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].capBitMap[0] |
346 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].capBitMap[0];
347 (void)SoftBusMutexUnlock(&g_bleInfoLock);
348
349 if (conScanCapBit != 0 && nonScanCapBit != 0) {
350 type = (CON_FILTER_TYPE | NON_FILTER_TYPE);
351 } else if (conScanCapBit != 0 && nonScanCapBit == 0) {
352 type = CON_FILTER_TYPE;
353 } else if (conScanCapBit == 0 && nonScanCapBit != 0) {
354 type = NON_FILTER_TYPE;
355 }
356 return type;
357 }
358
CheckScanner(void)359 static bool CheckScanner(void)
360 {
361 DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_bleInfoLock) == SOFTBUS_OK,
362 false, DISC_BLE, "lock failed");
363 uint32_t scanCapBit = g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].capBitMap[0] |
364 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].capBitMap[0] |
365 g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].capBitMap[0];
366 (void)SoftBusMutexUnlock(&g_bleInfoLock);
367 return scanCapBit != 0;
368 }
369
ScanFilter(const BroadcastReportInfo * reportInfo)370 static int32_t ScanFilter(const BroadcastReportInfo *reportInfo)
371 {
372 uint32_t advLen = reportInfo->packet.bcData.payloadLen;
373 uint8_t *advData = reportInfo->packet.bcData.payload;
374
375 DISC_CHECK_AND_RETURN_RET_LOGE(reportInfo->dataStatus == SOFTBUS_BC_DATA_COMPLETE,
376 SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL, DISC_BLE,
377 "dataStatus is invalid. dataStatus=%{public}u", reportInfo->dataStatus);
378 DISC_CHECK_AND_RETURN_RET_LOGE(advData != NULL, SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL, DISC_BLE,
379 "advData is null");
380 DISC_CHECK_AND_RETURN_RET_LOGE(advLen >= POS_TLV, SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL, DISC_BLE,
381 "advLen is too short, less than adv header length. advLen=%{public}u", advLen);
382
383 DISC_CHECK_AND_RETURN_RET_LOGE(reportInfo->packet.bcData.type == BC_DATA_TYPE_SERVICE,
384 SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL, DISC_BLE,
385 "type is invalid. type=%{public}u", reportInfo->packet.bcData.type);
386 DISC_CHECK_AND_RETURN_RET_LOGE(reportInfo->packet.bcData.id == SERVICE_UUID,
387 SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL, DISC_BLE,
388 "uuid is invalid. id=%{public}u", reportInfo->packet.bcData.id);
389 DISC_CHECK_AND_RETURN_RET_LOGE(advData[POS_VERSION] == BLE_VERSION, SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL,
390 DISC_BLE, "adv version is invalid. advVersion=%{public}hhu", advData[POS_VERSION]);
391 if (reportInfo->packet.rspData.payload != NULL && reportInfo->packet.rspData.payloadLen != 0) {
392 DISC_CHECK_AND_RETURN_RET_LOGE(reportInfo->packet.rspData.type == BC_DATA_TYPE_MANUFACTURER,
393 SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL, DISC_BLE,
394 "type is invalid. type=%{public}u", reportInfo->packet.rspData.type);
395 DISC_CHECK_AND_RETURN_RET_LOGE(reportInfo->packet.rspData.id == MANU_COMPANY_ID,
396 SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL, DISC_BLE,
397 "companyId is invalid. companyId=%{public}u", reportInfo->packet.rspData.id);
398 }
399
400 if (!CheckScanner()) {
401 DISC_LOGI(DISC_BLE, "no need to scan");
402 (void)StopScaner();
403 return SOFTBUS_DISCOVER_BLE_REPORT_FILTER_FAIL;
404 }
405 return SOFTBUS_OK;
406 }
407
ProcessDisConPacket(const BroadcastReportInfo * reportInfo,DeviceInfo * foundInfo)408 static void ProcessDisConPacket(const BroadcastReportInfo *reportInfo, DeviceInfo *foundInfo)
409 {
410 static uint32_t callCount = 0;
411 DeviceWrapper device = {
412 .info = foundInfo,
413 .power = SOFTBUS_ILLEGAL_BLE_POWER
414 };
415 int32_t ret = GetDeviceInfoFromDisAdvData(&device, (uint8_t *)reportInfo, sizeof(BroadcastReportInfo));
416 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE, "GetDeviceInfoFromDisAdvData failed, ret=%{public}d", ret);
417 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_bleInfoLock) == SOFTBUS_OK, DISC_BLE, "lock failed");
418 if ((foundInfo->capabilityBitmap[0] & g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].capBitMap[0]) == 0x0) {
419 DISC_LOGD(DISC_BLE, "don't match passive publish capBitMap, callCount=%{public}u", callCount++);
420 (void)SoftBusMutexUnlock(&g_bleInfoLock);
421 return;
422 }
423 (void)SoftBusMutexUnlock(&g_bleInfoLock);
424 char key[SHA_HASH_LEN];
425 ret = SoftBusGenerateStrHash(reportInfo->packet.bcData.payload,
426 reportInfo->packet.bcData.payloadLen, (uint8_t *)key);
427 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE, "GenerateStrHash failed, ret=%{public}d", ret);
428 if (AddRecvMessage(key, foundInfo->capabilityBitmap, true) == SOFTBUS_OK) {
429 ReplyPassiveNonBroadcast();
430 }
431 }
432
ProcessHashAccount(DeviceInfo * foundInfo)433 static bool ProcessHashAccount(DeviceInfo *foundInfo)
434 {
435 int32_t ret;
436 for (uint32_t pos = 0; pos < CAPABILITY_MAX_BITNUM; pos++) {
437 if (!CheckCapBitMapExist(CAPABILITY_NUM, foundInfo->capabilityBitmap, pos)) {
438 continue;
439 }
440 if (!(g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].isSameAccount[pos] ||
441 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].isSameAccount[pos])) {
442 return true;
443 }
444 uint8_t accountIdHash[SHORT_USER_ID_HASH_LEN] = {0};
445 ret = DiscBleGetShortUserIdHash(accountIdHash, SHORT_USER_ID_HASH_LEN);
446 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, false,
447 DISC_BLE, "DiscBleGetShortUserIdHash error, ret=%{public}d", ret);
448 DISC_CHECK_AND_RETURN_RET_LOGE(!LnnIsDefaultOhosAccount(), false,
449 DISC_BLE, "LnnIsDefaultOhosAccount, not the same account.");
450 if (memcmp(accountIdHash, foundInfo->accountHash, SHORT_USER_ID_HASH_LEN) == 0) {
451 return true;
452 }
453 DISC_LOGE(DISC_BLE, "err: not the same account.");
454 return false;
455 }
456 return false;
457 }
458
ConvertBleAddr(DeviceInfo * foundInfo)459 static int32_t ConvertBleAddr(DeviceInfo *foundInfo)
460 {
461 // convert ble bin mac to string mac before report
462 char bleMac[BT_MAC_LEN] = {0};
463 int32_t ret = ConvertBtMacToStr(bleMac, BT_MAC_LEN, (uint8_t *)foundInfo->addr[0].info.ble.bleMac, BT_ADDR_LEN);
464 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BLE, "convert ble mac to string failed");
465 errno_t retMem = memset_s(foundInfo->addr[0].info.ble.bleMac, BT_MAC_LEN, 0, BT_MAC_LEN);
466 DISC_CHECK_AND_RETURN_RET_LOGE(retMem == EOK, SOFTBUS_MEM_ERR, DISC_BLE, "memset ble mac failed");
467 retMem = memcpy_s(foundInfo->addr[0].info.ble.bleMac, BT_MAC_LEN, bleMac, BT_MAC_LEN);
468 DISC_CHECK_AND_RETURN_RET_LOGE(retMem == EOK, SOFTBUS_MEM_ERR, DISC_BLE, "memcopy ble mac failed");
469 return SOFTBUS_OK;
470 }
471
RangeDevice(DeviceInfo * device,char rssi,int8_t power)472 static int32_t RangeDevice(DeviceInfo *device, char rssi, int8_t power)
473 {
474 int32_t range = -1;
475 if (power != SOFTBUS_ILLEGAL_BLE_POWER) {
476 SoftBusRangeParam param = {
477 .rssi = *(signed char *)(&rssi),
478 .power = power,
479 .identity = {0}
480 };
481 errno_t retMem = memcpy_s(param.identity, SOFTBUS_DEV_IDENTITY_LEN,
482 device->addr[0].info.ble.bleMac, BT_MAC_LEN);
483 DISC_CHECK_AND_RETURN_RET_LOGE(retMem == EOK, SOFTBUS_MEM_ERR, DISC_BLE, "memcpy failed");
484
485 int ret = SoftBusBleRange(¶m, &range);
486 if (ret != SOFTBUS_OK) {
487 DISC_LOGE(DISC_BLE, "range device failed, ret=%{public}d", ret);
488 range = -1;
489 // range failed should report device continually
490 }
491 }
492 device->range = range;
493 return SOFTBUS_OK;
494 }
495
ProcessDisNonPacket(const BroadcastReportInfo * reportInfo,char rssi,DeviceInfo * foundInfo)496 static void ProcessDisNonPacket(const BroadcastReportInfo *reportInfo, char rssi, DeviceInfo *foundInfo)
497 {
498 static uint32_t callCount = 0;
499 DeviceWrapper device = {
500 .info = foundInfo,
501 .power = SOFTBUS_ILLEGAL_BLE_POWER
502 };
503 int32_t ret = GetDeviceInfoFromDisAdvData(&device, (uint8_t *)reportInfo, sizeof(BroadcastReportInfo));
504 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE, "GetDeviceInfoFromDisAdvData failed, ret=%{public}d", ret);
505 (void)SoftBusMutexLock(&g_bleInfoLock);
506 uint32_t subscribeCap = g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].capBitMap[0] |
507 g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE].capBitMap[0];
508 if (subscribeCap & (uint32_t)(foundInfo->capabilityBitmap[0] == 0x0)) {
509 DISC_LOGE(DISC_BLE, "capbitmap mismatch");
510 (void)SoftBusMutexUnlock(&g_bleInfoLock);
511 return;
512 }
513 foundInfo->capabilityBitmap[0] = subscribeCap & foundInfo->capabilityBitmap[0];
514 (void)SoftBusMutexUnlock(&g_bleInfoLock);
515 ret = ConvertBleAddr(foundInfo);
516 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE, "convert ble address failed, ret=%{public}d", ret);
517 ret = RangeDevice(foundInfo, rssi, device.power);
518 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE, "range device failed, ret=%{public}d", ret);
519
520 InnerDeviceInfoAddtions add;
521 add.medium = BLE;
522
523 if (ProcessHashAccount(foundInfo)) {
524 DISC_LOGI(DISC_BLE, "start report found device, addrNum=%{public}u, addr[0].type=%{public}u,"
525 "capabilityBitmap=%{public}u, callCount=%{public}u", foundInfo->addrNum, foundInfo->addr[0].type,
526 foundInfo->capabilityBitmap[0], callCount++);
527 uint32_t tempCap = 0;
528 DeConvertBitMap(&tempCap, foundInfo->capabilityBitmap, foundInfo->capabilityBitmapNum);
529 DISC_CHECK_AND_RETURN_LOGE(tempCap != 0, DISC_BLE, "unsupported ble capability. capabilityBitmap=%{public}d",
530 foundInfo->capabilityBitmap[0]);
531 foundInfo->capabilityBitmap[0] = tempCap;
532 foundInfo->capabilityBitmapNum = 1;
533 g_discBleInnerCb->OnDeviceFound(foundInfo, &add);
534 SoftbusRecordDiscBleRssi(*(signed char *)(&rssi));
535 }
536 }
537
ProcessDistributePacket(const BroadcastReportInfo * reportInfo)538 static void ProcessDistributePacket(const BroadcastReportInfo *reportInfo)
539 {
540 uint32_t advLen = reportInfo->packet.bcData.payloadLen;
541 uint8_t *advData = reportInfo->packet.bcData.payload;
542 DeviceInfo foundInfo;
543
544 DISC_CHECK_AND_RETURN_LOGE(advData != NULL && advLen > POS_BUSINESS_EXTENSION,
545 DISC_BLE, "scan report data null, len=%{public}d", advLen);
546 (void)memset_s(&foundInfo, sizeof(foundInfo), 0, sizeof(foundInfo));
547 foundInfo.addrNum = 1;
548 foundInfo.addr[0].type = CONNECTION_ADDR_BLE;
549 errno_t retMem = memcpy_s(foundInfo.addr[0].info.ble.bleMac, BT_ADDR_LEN, reportInfo->addr.addr, BC_ADDR_MAC_LEN);
550 DISC_CHECK_AND_RETURN_LOGE(retMem == EOK, DISC_BLE, "memcpy_s failed");
551 if ((advData[POS_BUSINESS_EXTENSION] & BIT_HEART_BIT) != 0) {
552 return;
553 }
554 if ((advData[POS_BUSINESS_EXTENSION] & BIT_CON) != 0) {
555 ProcessDisConPacket(reportInfo, &foundInfo);
556 } else {
557 ProcessDisNonPacket(reportInfo, reportInfo->rssi, &foundInfo);
558 }
559 }
560
BleScanResultCallback(int listenerId,const BroadcastReportInfo * reportInfo)561 static void BleScanResultCallback(int listenerId, const BroadcastReportInfo *reportInfo)
562 {
563 (void)listenerId;
564 DISC_CHECK_AND_RETURN_LOGE(listenerId == g_bleListener.scanListenerId, DISC_BLE, "listenerId not match");
565 DISC_CHECK_AND_RETURN_LOGE(reportInfo != NULL, DISC_BLE, "scan result is null");
566 DISC_CHECK_AND_RETURN_LOGD(ScanFilter(reportInfo) == SOFTBUS_OK, DISC_BLE, "scan filter failed");
567
568 uint8_t *advData = reportInfo->packet.bcData.payload;
569 if ((reportInfo->packet.bcData.id == SERVICE_UUID) && (advData[POS_BUSINESS] == DISTRIBUTE_BUSINESS)) {
570 SignalingMsgPrint("ble adv rcv", advData, reportInfo->packet.bcData.payloadLen, DISC_BLE);
571 ProcessDistributePacket(reportInfo);
572 } else {
573 DISC_LOGI(DISC_BLE, "ignore other business");
574 }
575 }
576
BleOnScanStart(int listenerId,int status)577 static void BleOnScanStart(int listenerId, int status)
578 {
579 (void)listenerId;
580 (void)status;
581 DISC_LOGD(DISC_BLE, "BleOnScanStart");
582 g_isScanning = true;
583 }
584
BleOnScanStop(int listenerId,int status)585 static void BleOnScanStop(int listenerId, int status)
586 {
587 (void)listenerId;
588 (void)status;
589 DISC_LOGD(DISC_BLE, "BleOnScanStop");
590 g_isScanning = false;
591 }
592
BtOnStateChanged(int32_t listenerId,int32_t state)593 static void BtOnStateChanged(int32_t listenerId, int32_t state)
594 {
595 DiscEventExtra extra = { 0 };
596 DiscEventExtraInit(&extra);
597 extra.bleTurnState = state;
598 DISC_EVENT(EVENT_SCENE_BLE, EVENT_STAGE_STATE_TURN, extra);
599 (void)listenerId;
600 SoftBusMessage *msg = NULL;
601 switch (state) {
602 case SOFTBUS_BLE_STATE_TURN_ON:
603 DISC_LOGI(DISC_CONTROL, "ble turn on");
604 msg = CreateBleHandlerMsg(RECOVERY, 0, 0, NULL);
605 break;
606 case SOFTBUS_BLE_STATE_TURN_OFF:
607 DISC_LOGI(DISC_CONTROL, "ble turn off");
608 msg = CreateBleHandlerMsg(TURN_OFF, 0, 0, NULL);
609 break;
610 case SOFTBUS_BR_STATE_TURN_ON:
611 DISC_LOGI(DISC_CONTROL, "br turn on");
612 msg = CreateBleHandlerMsg(BR_STATE_CHANGED, SOFTBUS_BR_STATE_TURN_ON, 0, NULL);
613 break;
614 case SOFTBUS_BR_STATE_TURN_OFF:
615 DISC_LOGI(DISC_CONTROL, "br turn off");
616 msg = CreateBleHandlerMsg(BR_STATE_CHANGED, SOFTBUS_BR_STATE_TURN_OFF, 0, NULL);
617 break;
618 default:
619 return;
620 }
621 DISC_CHECK_AND_RETURN_LOGE(msg != NULL, DISC_CONTROL, "create msg failed");
622 g_discBleHandler.looper->PostMessage(g_discBleHandler.looper, msg);
623 }
624
625 static BroadcastCallback g_advCallback = {
626 .OnStartBroadcastingCallback = BleAdvEnableCallback,
627 .OnStopBroadcastingCallback = BleAdvDisableCallback,
628 .OnSetBroadcastingCallback = BleAdvDataCallback,
629 .OnUpdateBroadcastingCallback = BleAdvUpdateCallback,
630 };
631
632 static ScanCallback g_scanListener = {
633 .OnStartScanCallback = BleOnScanStart,
634 .OnStopScanCallback = BleOnScanStop,
635 .OnReportScanDataCallback = BleScanResultCallback,
636 };
637
638 static SoftBusBtStateListener g_stateChangedListener = {
639 .OnBtStateChanged = BtOnStateChanged,
640 .OnBtAclStateChanged = NULL,
641 };
642
GetMaxExchangeFreq(void)643 static int32_t GetMaxExchangeFreq(void)
644 {
645 int32_t maxFreq = 0;
646 for (uint32_t pos = 0; pos < CAPABILITY_MAX_BITNUM; pos++) {
647 for (uint32_t index = 0; index < BLE_INFO_COUNT; index++) {
648 maxFreq = (maxFreq > g_bleInfoManager[index].freq[pos]) ? maxFreq : g_bleInfoManager[index].freq[pos];
649 }
650 }
651 return maxFreq;
652 }
653
GetWakeRemote(void)654 static bool GetWakeRemote(void)
655 {
656 for (uint32_t index = 0; index < CAPABILITY_MAX_BITNUM; index++) {
657 if (g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE].isWakeRemote[index]) {
658 return true;
659 }
660 }
661 return false;
662 }
663
DiscBleGetCustData(DeviceInfo * info)664 static int32_t DiscBleGetCustData(DeviceInfo *info)
665 {
666 uint32_t infoIndex = BLE_PUBLISH | BLE_PASSIVE;
667 uint32_t pos = 0;
668 for (pos = 0; pos < CAPABILITY_MAX_BITNUM; pos++) {
669 if (CheckCapBitMapExist(CAPABILITY_NUM, g_bleInfoManager[infoIndex].capBitMap, pos)) {
670 break;
671 }
672 }
673 DISC_CHECK_AND_RETURN_RET_LOGD(
674 pos < CAPABILITY_MAX_BITNUM, SOFTBUS_DISCOVER_BLE_GET_DEVICE_INFO_FAIL, DISC_BLE, "not find capBitMap");
675 cJSON *json = cJSON_ParseWithLength((const char *)g_bleInfoManager[infoIndex].capabilityData[pos],
676 g_bleInfoManager[infoIndex].capDataLen[pos]);
677 DISC_CHECK_AND_RETURN_RET_LOGE(json != NULL, SOFTBUS_PARSE_JSON_ERR, DISC_BLE, "parse cJSON failed");
678
679 char custData[DISC_MAX_CUST_DATA_LEN] = {0};
680 if (!GetJsonObjectStringItem(json, g_capabilityMap[CASTPLUS_CAPABILITY_BITMAP].capability, custData,
681 DISC_MAX_CUST_DATA_LEN)) {
682 DISC_LOGE(DISC_BLE, "GetJsonObjectStringItem custData failed, custData=%{public}s", custData);
683 cJSON_Delete(json);
684 return SOFTBUS_PARSE_JSON_ERR;
685 }
686 if (strcpy_s(info->custData, DISC_MAX_CUST_DATA_LEN, custData) != EOK) {
687 DISC_LOGE(DISC_BLE, "strcpy_s custData failed");
688 cJSON_Delete(json);
689 return SOFTBUS_STRCPY_ERR;
690 }
691 cJSON_Delete(json);
692 return SOFTBUS_OK;
693 }
694
GetConDeviceInfo(DeviceInfo * info)695 static int32_t GetConDeviceInfo(DeviceInfo *info)
696 {
697 (void)memset_s(info, sizeof(DeviceInfo), 0x0, sizeof(DeviceInfo));
698 uint32_t infoIndex = BLE_SUBSCRIBE | BLE_ACTIVE;
699 DISC_CHECK_AND_RETURN_RET_LOGE(!CheckBitMapEmpty(CAPABILITY_NUM, g_bleInfoManager[infoIndex].capBitMap),
700 SOFTBUS_DISCOVER_BLE_GET_DEVICE_INFO_FAIL, DISC_BLE, "all capbit is zero");
701 if (DiscBleGetDeviceIdHash((uint8_t *)info->devId, DISC_MAX_DEVICE_ID_LEN) != SOFTBUS_OK) {
702 DISC_LOGE(DISC_BLE, "get deviceId failed");
703 }
704 if (DiscBleGetDeviceName(info->devName, sizeof(info->devName)) != SOFTBUS_OK) {
705 DISC_LOGE(DISC_BLE, "get deviceName failed");
706 }
707 info->devType = (DeviceType)DiscBleGetDeviceType();
708 bool isSameAccount = false;
709 bool isWakeRemote = false;
710 for (uint32_t pos = 0; pos < CAPABILITY_MAX_BITNUM; pos++) {
711 isSameAccount = isSameAccount ? isSameAccount : g_bleInfoManager[infoIndex].isSameAccount[pos];
712 isWakeRemote = isWakeRemote ? isWakeRemote : g_bleInfoManager[infoIndex].isWakeRemote[pos];
713 }
714 (void)memset_s(info->accountHash, MAX_ACCOUNT_HASH_LEN, 0x0, MAX_ACCOUNT_HASH_LEN);
715 if (isSameAccount) {
716 if (!LnnIsDefaultOhosAccount()) {
717 DiscBleGetShortUserIdHash((uint8_t *)info->accountHash, SHORT_USER_ID_HASH_LEN);
718 } else {
719 DISC_LOGW(DISC_BLE, "Account not logged in during same account check");
720 }
721 }
722 for (uint32_t pos = 0; pos < CAPABILITY_NUM; pos++) {
723 info->capabilityBitmap[pos] = g_bleInfoManager[infoIndex].capBitMap[pos];
724 }
725 return SOFTBUS_OK;
726 }
727
GetNonDeviceInfo(DeviceInfo * info)728 static int32_t GetNonDeviceInfo(DeviceInfo *info)
729 {
730 (void)memset_s(info, sizeof(DeviceInfo), 0x0, sizeof(DeviceInfo));
731 if (DiscBleGetDeviceIdHash((uint8_t *)info->devId, DISC_MAX_DEVICE_ID_LEN) != SOFTBUS_OK) {
732 DISC_LOGE(DISC_BLE, "get deviceId failed");
733 }
734
735 if (DiscBleGetDeviceName(info->devName, sizeof(info->devName)) != SOFTBUS_OK) {
736 DISC_LOGE(DISC_BLE, "get deviceName failed");
737 }
738 info->devType = (DeviceType)DiscBleGetDeviceType();
739 uint32_t passiveCapBitMap[CAPABILITY_NUM] = {0};
740 int32_t ret = MatchRecvMessage(g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].capBitMap,
741 passiveCapBitMap, CAPABILITY_NUM);
742 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_DISCOVER_BLE_GET_DEVICE_INFO_FAIL,
743 DISC_BLE, "MatchRecvMessage failed");
744 for (uint32_t pos = 0; pos < CAPABILITY_NUM; pos++) {
745 info->capabilityBitmap[pos] =
746 g_bleInfoManager[BLE_PUBLISH | BLE_ACTIVE].capBitMap[pos] | passiveCapBitMap[pos];
747 }
748 if (DiscBleGetCustData(info) != SOFTBUS_OK) {
749 DISC_LOGW(DISC_BLE, "get custData failed");
750 }
751
752 int32_t activeCnt = g_bleInfoManager[BLE_PUBLISH | BLE_ACTIVE].rangingRefCnt;
753 int32_t passiveCnt = g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE].rangingRefCnt;
754 info->range = activeCnt + passiveCnt;
755
756 DISC_CHECK_AND_RETURN_RET_LOGE(!CheckBitMapEmpty(CAPABILITY_NUM, info->capabilityBitmap),
757 SOFTBUS_DISCOVER_BLE_GET_DEVICE_INFO_FAIL, DISC_BLE, "all capbit is zero");
758 return SOFTBUS_OK;
759 }
760
DestroyBleConfigAdvData(BroadcastPacket * packet)761 static void DestroyBleConfigAdvData(BroadcastPacket *packet)
762 {
763 SoftBusFree(packet->bcData.payload);
764 SoftBusFree(packet->rspData.payload);
765 packet->bcData.payload = NULL;
766 packet->rspData.payload = NULL;
767 }
768
BuildBleConfigAdvData(BroadcastPacket * packet,const BroadcastData * broadcastData)769 static int32_t BuildBleConfigAdvData(BroadcastPacket *packet, const BroadcastData *broadcastData)
770 {
771 if (packet->bcData.payload != NULL || packet->rspData.payload != NULL) {
772 DestroyBleConfigAdvData(packet);
773 }
774 packet->bcData.payload = (uint8_t *)SoftBusCalloc(ADV_DATA_MAX_LEN);
775 DISC_CHECK_AND_RETURN_RET_LOGE(packet->bcData.payload != NULL, SOFTBUS_MALLOC_ERR,
776 DISC_BLE, "malloc serviceData failed");
777
778 packet->isSupportFlag = true;
779 packet->flag = FLAG_AD_DATA;
780 packet->bcData.type = BC_DATA_TYPE_SERVICE;
781 packet->bcData.id = SERVICE_UUID;
782 packet->bcData.payloadLen = (broadcastData->dataLen > ADV_DATA_MAX_LEN) ? ADV_DATA_MAX_LEN :
783 broadcastData->dataLen;
784 if (memcpy_s(&packet->bcData.payload[0], ADV_DATA_MAX_LEN, broadcastData->data.advData,
785 packet->bcData.payloadLen) != EOK) {
786 DISC_LOGE(DISC_BLE, "memcpy err");
787 SoftBusFree(packet->bcData.payload);
788 packet->bcData.payload = NULL;
789 return SOFTBUS_MEM_ERR;
790 }
791
792 packet->rspData.payloadLen = broadcastData->dataLen - packet->bcData.payloadLen;
793 if (packet->rspData.payloadLen == 0) {
794 packet->rspData.payload = NULL;
795 return SOFTBUS_OK;
796 }
797
798 packet->rspData.payload = (uint8_t *)SoftBusCalloc(RESP_DATA_MAX_LEN);
799 if (packet->rspData.payload == NULL) {
800 DISC_LOGE(DISC_BLE, "malloc failed");
801 SoftBusFree(packet->bcData.payload);
802 packet->bcData.payload = NULL;
803 return SOFTBUS_MALLOC_ERR;
804 }
805 packet->rspData.type = BC_DATA_TYPE_MANUFACTURER;
806 packet->rspData.id = MANU_COMPANY_ID;
807 if (memcpy_s(&packet->rspData.payload[0], RESP_DATA_MAX_LEN, broadcastData->data.rspData,
808 packet->rspData.payloadLen) != EOK) {
809 DISC_LOGE(DISC_BLE, "memcpy err");
810 DestroyBleConfigAdvData(packet);
811 return SOFTBUS_MEM_ERR;
812 }
813
814 DISC_LOGI(DISC_BLE, "packet->rspData.payloadLen=%{public}d", packet->rspData.payloadLen);
815 return SOFTBUS_OK;
816 }
817
AssembleCustData(DeviceInfo * info,BroadcastData * broadcastData)818 static void AssembleCustData(DeviceInfo *info, BroadcastData *broadcastData)
819 {
820 if ((info->capabilityBitmap[0] & 0x02) == 0) { // CastPlus
821 return;
822 }
823 uint8_t custData[CUST_CAPABILITY_TYPE_LEN + CUST_CAPABILITY_LEN] = {0};
824 custData[0] = CAST_PLUS;
825 int32_t ret = ConvertHexStringToBytes(&custData[1], CUST_CAPABILITY_LEN, (const char *)info->custData,
826 strlen(info->custData));
827 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE,
828 "ConvertHexStringToBytes custData failed, ret=%{public}d", ret);
829 (void)AssembleTLV(broadcastData, TLV_TYPE_CUST, (const void *)custData,
830 CUST_CAPABILITY_LEN + CUST_CAPABILITY_TYPE_LEN);
831 }
832
AssembleNonOptionalTlv(DeviceInfo * info,BroadcastData * broadcastData)833 static void AssembleNonOptionalTlv(DeviceInfo *info, BroadcastData *broadcastData)
834 {
835 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_recvMessageInfo.lock) == SOFTBUS_OK, DISC_BLE, "lock failed");
836 if (g_recvMessageInfo.numNeedBrMac > 0) {
837 SoftBusBtAddr addr;
838 if (SoftBusGetBrState() == BR_ENABLE && SoftBusGetBtMacAddr(&addr) == SOFTBUS_OK) {
839 (void)AssembleTLV(broadcastData, TLV_TYPE_BR_MAC, (const void *)&addr.addr, BT_ADDR_LEN);
840 }
841 }
842 (void)SoftBusMutexUnlock(&g_recvMessageInfo.lock);
843 #ifdef DISC_COMMUNITY
844 if (info->range > 0) {
845 int8_t power = 0;
846 if (SoftBusGetBlePower(&power) == SOFTBUS_OK) {
847 (void)AssembleTLV(broadcastData, TLV_TYPE_RANGE_POWER, (const void *)&power, RANGE_POWER_TYPE_LEN);
848 }
849 }
850 #endif /* DISC_COMMUNITY */
851 if (info->custData[0] != 0) {
852 AssembleCustData(info, broadcastData);
853 }
854 }
855
AssembleBroadcastData(DeviceInfo * info,int32_t advId,BroadcastData * broadcastData)856 static int32_t AssembleBroadcastData(DeviceInfo *info, int32_t advId, BroadcastData *broadcastData)
857 {
858 bool isWakeRemote = GetWakeRemote();
859 errno_t retMem = memset_s(broadcastData->data.data, BROADCAST_MAX_LEN, 0x0, BROADCAST_MAX_LEN);
860 DISC_CHECK_AND_RETURN_RET_LOGE(retMem == EOK, SOFTBUS_MEM_ERR, DISC_BLE, "memset failed");
861 broadcastData->data.data[POS_VERSION] = BLE_VERSION & BYTE_MASK;
862 broadcastData->data.data[POS_BUSINESS] = DISTRIBUTE_BUSINESS & BYTE_MASK;
863 broadcastData->data.data[POS_BUSINESS_EXTENSION] = BIT_CUST_DATA_TYPE;
864 if (advId == CON_ADV_ID) {
865 broadcastData->data.data[POS_BUSINESS_EXTENSION] |= BIT_CON;
866 if (isWakeRemote) {
867 broadcastData->data.data[POS_BUSINESS_EXTENSION] |= BIT_WAKE_UP;
868 }
869 retMem = memcpy_s(&broadcastData->data.data[POS_USER_ID_HASH], SHORT_USER_ID_HASH_LEN,
870 info->accountHash, SHORT_USER_ID_HASH_LEN);
871 DISC_CHECK_AND_RETURN_RET_LOGE(retMem == EOK, SOFTBUS_MEM_ERR, DISC_BLE, "memcpy failed");
872 } else {
873 DiscBleGetShortUserIdHash(&broadcastData->data.data[POS_USER_ID_HASH], SHORT_USER_ID_HASH_LEN);
874 }
875 broadcastData->data.data[POS_CAPABLITY] = info->capabilityBitmap[0] & BYTE_MASK;
876 broadcastData->data.data[POS_CAPABLITY_EXTENSION] = 0x0;
877 broadcastData->dataLen = POS_TLV;
878 return SOFTBUS_OK;
879 }
880
GetBroadcastData(DeviceInfo * info,int32_t advId,BroadcastData * broadcastData)881 static int32_t GetBroadcastData(DeviceInfo *info, int32_t advId, BroadcastData *broadcastData)
882 {
883 int32_t ret = AssembleBroadcastData(info, advId, broadcastData);
884 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK,
885 ret, DISC_BLE, "assemble broadcast failed, ret=%{public}d", ret);
886 char deviceIdHash[SHORT_DEVICE_ID_HASH_LENGTH + 1] = {0};
887 if (DiscBleGetDeviceIdHash((uint8_t *)deviceIdHash, SHORT_DEVICE_ID_HASH_LENGTH + 1) != SOFTBUS_OK) {
888 DISC_LOGE(DISC_BLE, "get deviceId Hash failed");
889 }
890 (void)AssembleTLV(broadcastData, TLV_TYPE_DEVICE_ID_HASH, (const void *)deviceIdHash,
891 SHORT_DEVICE_ID_HASH_LENGTH);
892 uint16_t devType = info->devType;
893 uint8_t sendDevType[DEVICE_TYPE_LEN] = {0};
894 uint32_t devTypeLen = 1;
895 sendDevType[0] = devType & DEVICE_TYPE_MASK;
896 if (devType >= (1 << ONE_BYTE_LENGTH)) {
897 sendDevType[1] = (devType >> ONE_BYTE_LENGTH) & DEVICE_TYPE_MASK;
898 devTypeLen++;
899 }
900 (void)AssembleTLV(broadcastData, TLV_TYPE_DEVICE_TYPE, (const void *)sendDevType, devTypeLen);
901 if (advId == NON_ADV_ID) {
902 AssembleNonOptionalTlv(info, broadcastData);
903 }
904 uint32_t remainLen = BROADCAST_MAX_LEN - broadcastData->dataLen - 1;
905 uint32_t validLen = (strlen(info->devName) + 1 > remainLen) ? remainLen : strlen(info->devName) + 1;
906 char deviceName[DISC_MAX_DEVICE_NAME_LEN] = {0};
907 if (DiscBleGetDeviceName(deviceName, validLen) != SOFTBUS_OK) {
908 DISC_LOGE(DISC_BLE, "get deviceName failed");
909 }
910 (void)AssembleTLV(broadcastData, TLV_TYPE_DEVICE_NAME, (const void *)deviceName, strlen(deviceName) + 1);
911
912 DISC_LOGD(DISC_BLE, "broadcastData->dataLen=%{public}d", broadcastData->dataLen);
913 return SOFTBUS_OK;
914 }
915
BuildAdvParam(BroadcastParam * advParam)916 static void BuildAdvParam(BroadcastParam *advParam)
917 {
918 advParam->minInterval = ADV_INTERNAL;
919 advParam->maxInterval = ADV_INTERNAL;
920 advParam->advType = SOFTBUS_BC_ADV_IND;
921 advParam->ownAddrType = SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
922 advParam->peerAddrType = SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
923 advParam->channelMap = BLE_CHANNLE_MAP;
924 advParam->txPower = BLE_ADV_TX_POWER_DEFAULT;
925 (void)memset_s(advParam->localAddr.addr, BC_ADDR_MAC_LEN, 0, BC_ADDR_MAC_LEN);
926 }
927
DfxRecordAdevertiserEnd(int32_t adv,int32_t reason)928 static void DfxRecordAdevertiserEnd(int32_t adv, int32_t reason)
929 {
930 DiscEventExtra extra = { 0 };
931 DiscEventExtraInit(&extra);
932 extra.discType = BLE + 1;
933 extra.broadcastType = adv + 1;
934 extra.errcode = reason;
935 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
936 DISC_EVENT(EVENT_SCENE_BLE, EVENT_STAGE_BROADCAST, extra);
937 }
938
StartAdvertiser(int32_t adv)939 static int32_t StartAdvertiser(int32_t adv)
940 {
941 DISC_LOGD(DISC_BLE, "enter");
942 DiscBleAdvertiser *advertiser = &g_bleAdvertiser[adv];
943 if (advertiser->isAdvertising) {
944 if (GetNeedUpdateAdvertiser(adv)) {
945 DISC_LOGI(DISC_BLE, "advertising need update");
946 return UpdateAdvertiser(adv);
947 } else {
948 DISC_LOGI(DISC_BLE, "advertising no need update");
949 return SOFTBUS_OK;
950 }
951 }
952 int32_t ret = advertiser->GetDeviceInfo(&advertiser->deviceInfo);
953 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, StopAdvertiser(adv),
954 DISC_BLE, "advertiser GetConDeviceInfo failed. adv=%{public}d", adv);
955 BroadcastData broadcastData;
956 (void)memset_s(&broadcastData, sizeof(BroadcastData), 0, sizeof(BroadcastData));
957 ret = GetBroadcastData(&advertiser->deviceInfo, adv, &broadcastData);
958 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_DISCOVER_BLE_GET_BROADCAST_DATA_FAIL,
959 DISC_BLE, "get broadcast data failed");
960 BroadcastPacket packet = {};
961 ret = BuildBleConfigAdvData(&packet, &broadcastData);
962 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_DISCOVER_BLE_BUILD_CONFIG_ADV_DATA_FAIL,
963 DISC_BLE, "BuildBleConfigAdvData failed, ret=%{public}d", ret);
964 BroadcastParam advParam = {};
965 BuildAdvParam(&advParam);
966
967 SignalingMsgPrint("ble adv send", (uint8_t *)packet.bcData.payload, (uint8_t)packet.bcData.payloadLen,
968 DISC_BLE);
969 BroadcastContentType contentType = (adv == CON_ADV_ID) ? BC_TYPE_DISTRIB_CON : BC_TYPE_DISTRIB_NON;
970 ret = SchedulerStartBroadcast(advertiser->channel, contentType, &advParam, &packet);
971 if (ret != SOFTBUS_OK) {
972 DfxRecordAdevertiserEnd(adv, ret);
973 DestroyBleConfigAdvData(&packet);
974 DISC_LOGE(DISC_BLE, "start adv failed, adv=%{public}d", adv);
975 return SOFTBUS_DISCOVER_BLE_START_BROADCAST_FAIL;
976 }
977 DfxRecordAdevertiserEnd(adv, SOFTBUS_OK);
978 UpdateInfoManager(adv, false);
979 DestroyBleConfigAdvData(&packet);
980 return SOFTBUS_OK;
981 }
982
StopAdvertiser(int32_t adv)983 static int32_t StopAdvertiser(int32_t adv)
984 {
985 DiscBleAdvertiser *advertiser = &g_bleAdvertiser[adv];
986 if (!advertiser->isAdvertising) {
987 DISC_LOGI(DISC_BLE, "advertiser adv is already stopped. adv=%{public}d", adv);
988 return SOFTBUS_OK;
989 }
990 int32_t ret = SchedulerStopBroadcast(advertiser->channel);
991 if (ret != SOFTBUS_OK) {
992 DISC_LOGE(DISC_BLE, "stop advertiser failed. advId=%{public}d, ret=%{public}d", adv, ret);
993 }
994 if (adv == NON_ADV_ID) {
995 DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_recvMessageInfo.lock) == SOFTBUS_OK,
996 SOFTBUS_LOCK_ERR, DISC_BLE, "Lock failed");
997 ClearRecvMessage();
998 (void)SoftBusMutexUnlock(&g_recvMessageInfo.lock);
999 }
1000 return SOFTBUS_OK;
1001 }
1002
UpdateAdvertiser(int32_t adv)1003 static int32_t UpdateAdvertiser(int32_t adv)
1004 {
1005 DiscBleAdvertiser *advertiser = &g_bleAdvertiser[adv];
1006 int32_t ret = advertiser->GetDeviceInfo(&advertiser->deviceInfo);
1007 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, StopAdvertiser(adv),
1008 DISC_BLE, "advertiser adv GetConDeviceInfo failed. adv=%{public}d", adv);
1009 BroadcastData broadcastData = {};
1010 ret = GetBroadcastData(&advertiser->deviceInfo, adv, &broadcastData);
1011 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_DISCOVER_BLE_GET_BROADCAST_DATA_FAIL,
1012 DISC_BLE, "GetBroadcastData failed, ret=%{public}d", ret);
1013 BroadcastPacket packet = {};
1014 ret = BuildBleConfigAdvData(&packet, &broadcastData);
1015 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, SOFTBUS_DISCOVER_BLE_BUILD_CONFIG_ADV_DATA_FAIL,
1016 DISC_BLE, "BuildBleConfigAdvData failed, ret=%{public}d", ret);
1017 BroadcastParam advParam = {0};
1018 BuildAdvParam(&advParam);
1019 ret = SchedulerUpdateBroadcast(advertiser->channel, &advParam, &packet);
1020 if (ret != SOFTBUS_OK) {
1021 DestroyBleConfigAdvData(&packet);
1022 DISC_LOGE(DISC_BLE, "UpdateAdv failed, ret=%{public}d", ret);
1023 return SOFTBUS_DISCOVER_BLE_START_BROADCAST_FAIL;
1024 }
1025 UpdateInfoManager(adv, false);
1026 DestroyBleConfigAdvData(&packet);
1027 return SOFTBUS_OK;
1028 }
1029
InitScanner(void)1030 static void InitScanner(void)
1031 {
1032 g_isScanning = false;
1033 }
1034
GetScannerParam(int32_t freq,BcScanParams * scanParam)1035 static int32_t GetScannerParam(int32_t freq, BcScanParams *scanParam)
1036 {
1037 scanParam->scanInterval = (uint16_t)g_scanTable[freq].scanInterval;
1038 scanParam->scanWindow = (uint16_t)g_scanTable[freq].scanWindow;
1039 scanParam->scanType = SOFTBUS_BC_SCAN_TYPE_ACTIVE;
1040 scanParam->scanPhy = SOFTBUS_BC_SCAN_PHY_1M;
1041 scanParam->scanFilterPolicy = SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL;
1042 return SOFTBUS_OK;
1043 }
1044
DfxRecordScanEnd(int32_t reason)1045 static void DfxRecordScanEnd(int32_t reason)
1046 {
1047 DiscEventExtra extra = { 0 };
1048 DiscEventExtraInit(&extra);
1049 extra.scanType = BLE + 1;
1050 extra.errcode = reason;
1051 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
1052 DISC_EVENT(EVENT_SCENE_BLE, EVENT_STAGE_SCAN, extra);
1053 }
1054
UpdateScannerFilter(bool isStopScan)1055 static void UpdateScannerFilter(bool isStopScan)
1056 {
1057 if (isStopScan) {
1058 int32_t ret = SchedulerStopScan(g_bleListener.scanListenerId);
1059 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE, "StopScaner failed, ret=%{public}d", ret);
1060 }
1061 int32_t type = GetScannerFilterType();
1062 DISC_LOGI(DISC_BLE, "Set filter type=%{public}d", type);
1063 DiscBleSetScanFilter(g_bleListener.scanListenerId, type);
1064 }
1065
StartScaner(int32_t type)1066 static void StartScaner(int32_t type)
1067 {
1068 DISC_CHECK_AND_RETURN_LOGE(type > 0 && type <= (CON_FILTER_TYPE | NON_FILTER_TYPE),
1069 DISC_BLE, "start scanner type invaild");
1070 if (!CheckScanner()) {
1071 DISC_LOGI(DISC_BLE, "no need to start scanner");
1072 (void)StopScaner();
1073 return;
1074 }
1075
1076 if (g_isScanning) {
1077 if (GetNeedUpdateScanner(type)) {
1078 UpdateScannerFilter(true);
1079 } else {
1080 DISC_LOGI(DISC_BLE, "scanner already start, no need start again");
1081 return;
1082 }
1083 } else {
1084 if (GetNeedUpdateScanner(type)) {
1085 UpdateScannerFilter(false);
1086 } else {
1087 DISC_LOGI(DISC_BLE, "no need update filter, start scan"); // when bt turn on or off
1088 }
1089 }
1090
1091 BcScanParams scanParam;
1092 int32_t maxFreq = GetMaxExchangeFreq();
1093 int32_t ret = GetScannerParam(maxFreq, &scanParam);
1094 DISC_CHECK_AND_RETURN_LOGE(ret == SOFTBUS_OK, DISC_BLE, "GetScannerParam failed");
1095 ret = SchedulerStartScan(g_bleListener.scanListenerId, &scanParam);
1096 if (ret != SOFTBUS_OK) {
1097 DfxRecordScanEnd(ret);
1098 DISC_LOGE(DISC_BLE, "start scan failed");
1099 return;
1100 }
1101 UpdateScannerInfoManager(type, true);
1102 DfxRecordScanEnd(SOFTBUS_OK);
1103 DISC_LOGD(DISC_BLE, "StartScanner success");
1104 }
1105
StopScaner(void)1106 static int32_t StopScaner(void)
1107 {
1108 if (!g_isScanning) {
1109 DISC_LOGI(DISC_BLE, "already stop scanning");
1110 return SOFTBUS_OK;
1111 }
1112 int32_t ret = SchedulerStopScan(g_bleListener.scanListenerId);
1113 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK,
1114 SOFTBUS_DISCOVER_BLE_END_SCAN_FAIL, DISC_BLE, "StopScaner failed, ret=%{public}d", ret);
1115 DISC_LOGD(DISC_BLE, "success");
1116 return SOFTBUS_OK;
1117 }
1118
GetBleOption(BleOption * bleOption,const DiscBleOption * option)1119 static void GetBleOption(BleOption *bleOption, const DiscBleOption *option)
1120 {
1121 if (option->publishOption != NULL) {
1122 bleOption->optionCapBitMap[0] = (uint32_t)ConvertCapBitMap(option->publishOption->capabilityBitmap[0]);
1123 bleOption->custDataLen = option->publishOption->dataLen;
1124 bleOption->custData = option->publishOption->capabilityData;
1125 bleOption->isSameAccount = false;
1126 bleOption->isWakeRemote = false;
1127 bleOption->freq = (uint32_t)(option->publishOption->freq);
1128 bleOption->ranging = option->publishOption->ranging;
1129 } else {
1130 bleOption->optionCapBitMap[0] = (uint32_t)ConvertCapBitMap(option->subscribeOption->capabilityBitmap[0]);
1131 bleOption->custDataLen = option->subscribeOption->dataLen;
1132 bleOption->custData = option->subscribeOption->capabilityData;
1133 bleOption->isSameAccount = option->subscribeOption->isSameAccount;
1134 bleOption->isWakeRemote = option->subscribeOption->isWakeRemote;
1135 bleOption->freq = (uint32_t)(option->subscribeOption->freq);
1136 bleOption->ranging = false;
1137 }
1138 }
1139
RegisterCapability(DiscBleInfo * info,const DiscBleOption * option)1140 static int32_t RegisterCapability(DiscBleInfo *info, const DiscBleOption *option)
1141 {
1142 BleOption bleOption;
1143 (void)memset_s(&bleOption, sizeof(BleOption), 0, sizeof(BleOption));
1144 GetBleOption(&bleOption, option);
1145 uint32_t *optionCapBitMap = bleOption.optionCapBitMap;
1146 uint32_t custDataLen = bleOption.custDataLen;
1147 uint32_t freq = bleOption.freq;
1148 uint8_t *custData = bleOption.custData;
1149 bool isSameAccount = bleOption.isSameAccount;
1150 bool isWakeRemote = bleOption.isWakeRemote;
1151 for (uint32_t pos = 0; pos < CAPABILITY_MAX_BITNUM; pos++) {
1152 if (!CheckCapBitMapExist(CAPABILITY_NUM, optionCapBitMap, pos)) {
1153 continue;
1154 }
1155 if (!CheckCapBitMapExist(CAPABILITY_NUM, info->capBitMap, pos)) {
1156 SetCapBitMapPos(CAPABILITY_NUM, info->capBitMap, pos);
1157 info->needUpdate = true;
1158 }
1159 info->capCount[pos] += 1;
1160 info->isSameAccount[pos] = isSameAccount;
1161 info->isWakeRemote[pos] = isWakeRemote;
1162 info->freq[pos] = (int32_t)freq;
1163 info->capDataLen[pos] = 0;
1164 if (custData == NULL) {
1165 continue;
1166 }
1167 if (info->capabilityData[pos] == NULL) {
1168 info->capabilityData[pos] = (uint8_t *)SoftBusCalloc(MAX_CAPABILITYDATA_LEN);
1169 if (info->capabilityData[pos] == NULL) {
1170 return SOFTBUS_MALLOC_ERR;
1171 }
1172 }
1173 if (memcpy_s(info->capabilityData[pos], MAX_CAPABILITYDATA_LEN, custData, custDataLen) != EOK) {
1174 SoftBusFree(info->capabilityData[pos]);
1175 info->capabilityData[pos] = NULL;
1176 return SOFTBUS_MEM_ERR;
1177 }
1178 info->capDataLen[pos] = custDataLen;
1179 }
1180
1181 if (bleOption.ranging) {
1182 info->rangingRefCnt += 1;
1183 info->needUpdate = true;
1184 }
1185
1186 return SOFTBUS_OK;
1187 }
1188
UnregisterCapability(DiscBleInfo * info,DiscBleOption * option)1189 static void UnregisterCapability(DiscBleInfo *info, DiscBleOption *option)
1190 {
1191 uint32_t *optionCapBitMap = NULL;
1192 bool isSameAccount = false;
1193 bool isWakeRemote = false;
1194 bool ranging = false;
1195 if (option->publishOption != NULL) {
1196 optionCapBitMap = option->publishOption->capabilityBitmap;
1197 optionCapBitMap[0] = (uint32_t)ConvertCapBitMap(optionCapBitMap[0]);
1198 ranging = option->publishOption->ranging;
1199 } else {
1200 optionCapBitMap = option->subscribeOption->capabilityBitmap;
1201 optionCapBitMap[0] = (uint32_t)ConvertCapBitMap(optionCapBitMap[0]);
1202 isSameAccount = option->subscribeOption->isSameAccount;
1203 isWakeRemote = option->subscribeOption->isWakeRemote;
1204 ranging = false;
1205 }
1206 for (uint32_t pos = 0; pos < CAPABILITY_MAX_BITNUM; pos++) {
1207 if (!CheckCapBitMapExist(CAPABILITY_NUM, optionCapBitMap, pos) ||
1208 !CheckCapBitMapExist(CAPABILITY_NUM, info->capBitMap, pos)) {
1209 continue;
1210 }
1211 info->capCount[pos] -= 1;
1212 if (info->capCount[pos] == 0) {
1213 UnsetCapBitMapPos(CAPABILITY_NUM, info->capBitMap, pos);
1214 SoftBusFree(info->capabilityData[pos]);
1215 info->capabilityData[pos] = NULL;
1216 info->capDataLen[pos] = 0;
1217 info->needUpdate = true;
1218 }
1219 info->isSameAccount[pos] = isSameAccount;
1220 info->isWakeRemote[pos] = isWakeRemote;
1221 info->freq[pos] = -1;
1222 }
1223 if (ranging && info->rangingRefCnt > 0) {
1224 info->rangingRefCnt -= 1;
1225 info->needUpdate = true;
1226 }
1227 }
1228
ProcessBleInfoManager(bool isStart,uint8_t publishFlags,uint8_t activeFlags,const void * option)1229 static int32_t ProcessBleInfoManager(bool isStart, uint8_t publishFlags, uint8_t activeFlags, const void *option)
1230 {
1231 DISC_CHECK_AND_RETURN_RET_LOGE(option != NULL, SOFTBUS_INVALID_PARAM, DISC_BLE, "option is null");
1232 DiscBleOption regOption;
1233 if (publishFlags == BLE_PUBLISH) {
1234 regOption.publishOption = (PublishOption *)option;
1235 regOption.subscribeOption = NULL;
1236 } else {
1237 regOption.publishOption = NULL;
1238 regOption.subscribeOption = (SubscribeOption *)option;
1239 }
1240 uint8_t index = publishFlags | activeFlags;
1241 DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_bleInfoLock) == SOFTBUS_OK,
1242 SOFTBUS_LOCK_ERR, DISC_BLE, "lock failed.");
1243 uint32_t oldCap = g_bleInfoManager[index].capBitMap[0];
1244 int32_t oldRangingRefCount = g_bleInfoManager[index].rangingRefCnt;
1245 if (isStart) {
1246 int32_t status = RegisterCapability(&g_bleInfoManager[index], ®Option);
1247 if (status != SOFTBUS_OK) {
1248 DISC_LOGE(DISC_BLE, "RegisterCapability failed, err=%{public}d", status);
1249 SoftBusMutexUnlock(&g_bleInfoLock);
1250 return SOFTBUS_DISCOVER_BLE_REGISTER_CAP_FAIL;
1251 }
1252 } else {
1253 UnregisterCapability(&g_bleInfoManager[index], ®Option);
1254 }
1255
1256 uint32_t newCap = g_bleInfoManager[index].capBitMap[0];
1257 if ((index != (BLE_PUBLISH | BLE_ACTIVE)) && newCap != oldCap) {
1258 g_bleInfoManager[index].needUpdateCap = true;
1259 }
1260 int32_t newRangingRefCount = g_bleInfoManager[index].rangingRefCnt;
1261 DISC_LOGI(DISC_BLE, "ble discovery request summary, action: isStart=%{public}d, publishFlags=%{public}d, "
1262 "activeFlags=%{public}d, oldCap=%{public}d, newCap=%{public}d, "
1263 "oldRangingRefCount=%{public}d, newRangingRefCount=%{public}d, needUpdateCap=%{public}d",
1264 isStart, publishFlags, activeFlags, oldCap, newCap, oldRangingRefCount, newRangingRefCount,
1265 g_bleInfoManager[index].needUpdateCap);
1266
1267 SoftBusMutexUnlock(&g_bleInfoLock);
1268 return SOFTBUS_OK;
1269 }
1270
CreateBleHandlerMsg(int32_t what,uint64_t arg1,uint64_t arg2,void * obj)1271 static SoftBusMessage *CreateBleHandlerMsg(int32_t what, uint64_t arg1, uint64_t arg2, void *obj)
1272 {
1273 SoftBusMessage *msg = (SoftBusMessage *)SoftBusCalloc(sizeof(SoftBusMessage));
1274 DISC_CHECK_AND_RETURN_RET_LOGE(msg != NULL, NULL, DISC_BLE, "ble create handler msg failed");
1275 msg->what = what;
1276 msg->arg1 = arg1;
1277 msg->arg2 = arg2;
1278 msg->handler = &g_discBleHandler;
1279 msg->FreeMessage = NULL;
1280 msg->obj = obj;
1281 return msg;
1282 }
1283
DfxRecordBleProcessEnd(uint8_t publishFlag,uint8_t activeFlag,int32_t funcCode,const void * option,int32_t reason)1284 static void DfxRecordBleProcessEnd(uint8_t publishFlag, uint8_t activeFlag, int32_t funcCode,
1285 const void *option, int32_t reason)
1286 {
1287 DiscEventExtra extra = { 0 };
1288 DiscEventExtraInit(&extra);
1289 extra.errcode = reason;
1290 extra.discType = BLE + 1;
1291 extra.interFuncType = funcCode + 1;
1292 extra.discMode = (activeFlag == BLE_ACTIVE) ? DISCOVER_MODE_ACTIVE : DISCOVER_MODE_PASSIVE;
1293 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
1294
1295 const char *capabilityData = NULL;
1296 uint32_t dataLen = MAX_CAPABILITYDATA_LEN - 1;
1297 if (publishFlag == BLE_PUBLISH && option != NULL) {
1298 PublishOption *publishOption = (PublishOption *)option;
1299 extra.capabilityBit = (int32_t)publishOption->capabilityBitmap[0];
1300 capabilityData = (const char *)publishOption->capabilityData;
1301 dataLen = publishOption->dataLen < dataLen ? publishOption->dataLen : dataLen;
1302 } else if (publishFlag == BLE_SUBSCRIBE && option != NULL) {
1303 SubscribeOption *subscribeOption = (SubscribeOption *)option;
1304 extra.capabilityBit = (int32_t)subscribeOption->capabilityBitmap[0];
1305 capabilityData = (const char *)subscribeOption->capabilityData;
1306 dataLen = subscribeOption->dataLen < dataLen ? subscribeOption->dataLen : dataLen;
1307 }
1308
1309 char data[MAX_CAPABILITYDATA_LEN] = { 0 };
1310 if (capabilityData != NULL && strncpy_s(data, MAX_CAPABILITYDATA_LEN, capabilityData, dataLen) == EOK) {
1311 extra.capabilityData = data;
1312 }
1313 DISC_EVENT(EVENT_SCENE_BLE, EVENT_STAGE_BLE_PROCESS, extra);
1314 }
1315
ProcessBleDiscFunc(bool isStart,uint8_t publishFlags,uint8_t activeFlags,int32_t funcCode,const void * option)1316 static int32_t ProcessBleDiscFunc(bool isStart, uint8_t publishFlags, uint8_t activeFlags,
1317 int32_t funcCode, const void *option)
1318 {
1319 if (isStart && SoftBusGetBtState() != BLE_ENABLE) {
1320 DfxRecordBleProcessEnd(publishFlags, activeFlags, funcCode, option, SOFTBUS_BLUETOOTH_OFF);
1321 DISC_LOGE(DISC_BLE, "get bt state failed.");
1322 return SOFTBUS_BLUETOOTH_OFF;
1323 }
1324 int32_t ret = ProcessBleInfoManager(isStart, publishFlags, activeFlags, option);
1325 if (ret != SOFTBUS_OK) {
1326 DfxRecordBleProcessEnd(publishFlags, activeFlags, funcCode, option, ret);
1327 DISC_LOGE(DISC_BLE, "process ble info manager failed");
1328 return ret;
1329 }
1330 SoftBusMessage *msg = CreateBleHandlerMsg(funcCode, 0, 0, NULL);
1331 if (msg == NULL) {
1332 DfxRecordBleProcessEnd(publishFlags, activeFlags, funcCode, option, SOFTBUS_MALLOC_ERR);
1333 DISC_LOGE(DISC_BLE, "CreateBleHandlerMsg failed");
1334 return SOFTBUS_MALLOC_ERR;
1335 }
1336 g_discBleHandler.looper->PostMessage(g_discBleHandler.looper, msg);
1337 DfxRecordBleProcessEnd(publishFlags, activeFlags, funcCode, option, SOFTBUS_OK);
1338 return SOFTBUS_OK;
1339 }
1340
BleStartActivePublish(const PublishOption * option)1341 static int32_t BleStartActivePublish(const PublishOption *option)
1342 {
1343 DISC_LOGI(DISC_BLE, "start active publish");
1344 return ProcessBleDiscFunc(true, BLE_PUBLISH, BLE_ACTIVE, PUBLISH_ACTIVE_SERVICE, (void *)option);
1345 }
1346
BleStartPassivePublish(const PublishOption * option)1347 static int32_t BleStartPassivePublish(const PublishOption *option)
1348 {
1349 DISC_LOGD(DISC_BLE, "start passive publish");
1350 return ProcessBleDiscFunc(true, BLE_PUBLISH, BLE_PASSIVE, PUBLISH_PASSIVE_SERVICE, (void *)option);
1351 }
1352
BleStopActivePublish(const PublishOption * option)1353 static int32_t BleStopActivePublish(const PublishOption *option)
1354 {
1355 DISC_LOGI(DISC_BLE, "stop active publish");
1356 return ProcessBleDiscFunc(false, BLE_PUBLISH, BLE_ACTIVE, UNPUBLISH_SERVICE, (void *)option);
1357 }
1358
BleStopPassivePublish(const PublishOption * option)1359 static int32_t BleStopPassivePublish(const PublishOption *option)
1360 {
1361 DISC_LOGD(DISC_BLE, "stop passive publish");
1362 return ProcessBleDiscFunc(false, BLE_PUBLISH, BLE_PASSIVE, UNPUBLISH_SERVICE, (void *)option);
1363 }
1364
BleStartActiveDiscovery(const SubscribeOption * option)1365 static int32_t BleStartActiveDiscovery(const SubscribeOption *option)
1366 {
1367 DISC_LOGI(DISC_BLE, "start active discovery");
1368 return ProcessBleDiscFunc(true, BLE_SUBSCRIBE, BLE_ACTIVE, START_ACTIVE_DISCOVERY, (void *)option);
1369 }
1370
BleStartPassiveDiscovery(const SubscribeOption * option)1371 static int32_t BleStartPassiveDiscovery(const SubscribeOption *option)
1372 {
1373 DISC_LOGI(DISC_BLE, "start passive discovery");
1374 return ProcessBleDiscFunc(true, BLE_SUBSCRIBE, BLE_PASSIVE, START_PASSIVE_DISCOVERY, (void *)option);
1375 }
1376
BleStopActiveDiscovery(const SubscribeOption * option)1377 static int32_t BleStopActiveDiscovery(const SubscribeOption *option)
1378 {
1379 DISC_LOGI(DISC_BLE, "stop active discovery");
1380 return ProcessBleDiscFunc(false, BLE_SUBSCRIBE, BLE_ACTIVE, STOP_DISCOVERY, (void *)option);
1381 }
1382
BleStopPassiveDiscovery(const SubscribeOption * option)1383 static int32_t BleStopPassiveDiscovery(const SubscribeOption *option)
1384 {
1385 DISC_LOGI(DISC_BLE, "stop passive discovery");
1386 return ProcessBleDiscFunc(false, BLE_SUBSCRIBE, BLE_PASSIVE, STOP_DISCOVERY, (void *)option);
1387 }
1388
BleIsConcern(uint32_t capability)1389 static bool BleIsConcern(uint32_t capability)
1390 {
1391 return (capability & g_concernCapabilityMask) != 0;
1392 }
1393
UpdateAdvertiserDeviceInfo(int32_t adv)1394 static int32_t UpdateAdvertiserDeviceInfo(int32_t adv)
1395 {
1396 DiscBleAdvertiser *advertiser = &g_bleAdvertiser[adv];
1397 if (advertiser->isAdvertising) {
1398 int32_t ret = UpdateAdvertiser(adv);
1399 if (ret == SOFTBUS_OK) {
1400 DISC_LOGI(DISC_BLE, "update device info success");
1401 return SOFTBUS_OK;
1402 }
1403 return ret;
1404 }
1405
1406 DISC_LOGI(DISC_BLE, "not advertising or no need to update");
1407 return SOFTBUS_OK;
1408 }
1409
BleUpdateLocalDeviceInfo(InfoTypeChanged type)1410 static void BleUpdateLocalDeviceInfo(InfoTypeChanged type)
1411 {
1412 (void)type;
1413 DISC_CHECK_AND_RETURN_LOGE(
1414 UpdateAdvertiserDeviceInfo(NON_ADV_ID) == SOFTBUS_OK && UpdateAdvertiserDeviceInfo(CON_ADV_ID) == SOFTBUS_OK,
1415 DISC_BLE, "update failed");
1416 DISC_LOGI(DISC_BLE, "update success");
1417 }
1418
1419 static DiscoveryFuncInterface g_discBleFuncInterface = {
1420 .Publish = BleStartActivePublish,
1421 .StartScan = BleStartPassivePublish,
1422 .Unpublish = BleStopActivePublish,
1423 .StopScan = BleStopPassivePublish,
1424 .StartAdvertise = BleStartActiveDiscovery,
1425 .Subscribe = BleStartPassiveDiscovery,
1426 .Unsubscribe = BleStopPassiveDiscovery,
1427 .StopAdvertise = BleStopActiveDiscovery,
1428 .UpdateLocalDeviceInfo = BleUpdateLocalDeviceInfo
1429 };
1430
1431 static DiscoveryBleDispatcherInterface g_discBleDispatcherInterface = {
1432 .IsConcern = BleIsConcern,
1433 .mediumInterface = &g_discBleFuncInterface
1434
1435 };
1436
InitAdvertiser(void)1437 static int32_t InitAdvertiser(void)
1438 {
1439 int32_t conChannel = -1;
1440 int32_t nonChannel = -1;
1441 int32_t ret = SchedulerRegisterBroadcaster(SRV_TYPE_DIS, &conChannel, &g_advCallback);
1442 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BLE, "register broadcaster con fail");
1443
1444 ret = SchedulerRegisterBroadcaster(SRV_TYPE_DIS, &nonChannel, &g_advCallback);
1445 if (ret != SOFTBUS_OK) {
1446 DISC_LOGE(DISC_INIT, "register broadcaster non fail");
1447 (void)SchedulerUnregisterBroadcaster(conChannel);
1448 return ret;
1449 }
1450 if (conChannel < 0 || nonChannel < 0) {
1451 DISC_LOGE(DISC_INIT, "register broadcaster fail. conChannel=%{public}d, nonChannel=%{public}d",
1452 conChannel, nonChannel);
1453 (void)SchedulerUnregisterBroadcaster(conChannel);
1454 (void)SchedulerUnregisterBroadcaster(nonChannel);
1455 return SOFTBUS_DISCOVER_BLE_ADV_INIT_FAIL;
1456 }
1457 DISC_LOGI(DISC_INIT, "conChannel=%{public}d, nonChannel=%{public}d", conChannel, nonChannel);
1458
1459 for (uint32_t i = 0; i < NUM_ADVERTISER; i++) {
1460 g_bleAdvertiser[i].isAdvertising = false;
1461 }
1462 g_bleAdvertiser[CON_ADV_ID].GetDeviceInfo = GetConDeviceInfo;
1463 g_bleAdvertiser[CON_ADV_ID].channel = conChannel;
1464 g_bleAdvertiser[NON_ADV_ID].GetDeviceInfo = GetNonDeviceInfo;
1465 g_bleAdvertiser[NON_ADV_ID].channel = nonChannel;
1466
1467 return SOFTBUS_OK;
1468 }
1469
InitDiscBleInfo(DiscBleInfo * info)1470 static void InitDiscBleInfo(DiscBleInfo *info)
1471 {
1472 (void)memset_s(info, sizeof(DiscBleInfo), 0, sizeof(DiscBleInfo));
1473 for (uint32_t pos = 0; pos < CAPABILITY_MAX_BITNUM; pos++) {
1474 info->freq[pos] = -1;
1475 }
1476 }
1477
DiscBleInitPublish(void)1478 static void DiscBleInitPublish(void)
1479 {
1480 InitDiscBleInfo(&g_bleInfoManager[BLE_PUBLISH | BLE_ACTIVE]);
1481 InitDiscBleInfo(&g_bleInfoManager[BLE_PUBLISH | BLE_PASSIVE]);
1482 }
1483
DiscBleInitSubscribe(void)1484 static void DiscBleInitSubscribe(void)
1485 {
1486 InitDiscBleInfo(&g_bleInfoManager[BLE_SUBSCRIBE | BLE_ACTIVE]);
1487 InitDiscBleInfo(&g_bleInfoManager[BLE_SUBSCRIBE | BLE_PASSIVE]);
1488 }
1489
StartActivePublish(SoftBusMessage * msg)1490 static void StartActivePublish(SoftBusMessage *msg)
1491 {
1492 DISC_LOGD(DISC_BLE, "enter");
1493 if (StartAdvertiser(NON_ADV_ID) != SOFTBUS_OK) {
1494 DISC_LOGE(DISC_BLE, "Start msg failed");
1495 }
1496 DISC_LOGD(DISC_BLE, "end");
1497 }
1498
StartPassivePublish(SoftBusMessage * msg)1499 static void StartPassivePublish(SoftBusMessage *msg)
1500 {
1501 DISC_LOGD(DISC_BLE, "enter");
1502 if (g_bleAdvertiser[NON_ADV_ID].isAdvertising) {
1503 DISC_LOGI(DISC_BLE, "UpdateAdvertiser NON_ADV_ID=%{public}d", NON_ADV_ID);
1504 UpdateAdvertiser(NON_ADV_ID);
1505 }
1506 StartScaner(CON_FILTER_TYPE);
1507 DISC_LOGD(DISC_BLE, "end");
1508 }
1509
StartActiveDiscovery(SoftBusMessage * msg)1510 static void StartActiveDiscovery(SoftBusMessage *msg)
1511 {
1512 DISC_LOGD(DISC_BLE, "enter");
1513 if (StartAdvertiser(CON_ADV_ID) == SOFTBUS_OK) {
1514 StartScaner(NON_FILTER_TYPE);
1515 }
1516 DISC_LOGD(DISC_BLE, "end");
1517 }
1518
StartPassiveDiscovery(SoftBusMessage * msg)1519 static void StartPassiveDiscovery(SoftBusMessage *msg)
1520 {
1521 DISC_LOGD(DISC_BLE, "enter");
1522 StartScaner(NON_FILTER_TYPE);
1523 DISC_LOGD(DISC_BLE, "end");
1524 }
1525
Recovery(SoftBusMessage * msg)1526 static void Recovery(SoftBusMessage *msg)
1527 {
1528 DISC_LOGD(DISC_BLE, "enter");
1529 if (StartAdvertiser(CON_ADV_ID) != SOFTBUS_OK) {
1530 DISC_LOGE(DISC_BLE, "Start CON_ADV_ID failed");
1531 }
1532 if (StartAdvertiser(NON_ADV_ID) != SOFTBUS_OK) {
1533 DISC_LOGE(DISC_BLE, "Start NON_ADV_ID failed");
1534 }
1535 StartScaner(CON_FILTER_TYPE | NON_FILTER_TYPE);
1536 DISC_LOGD(DISC_BLE, "end");
1537 }
1538
BleDiscTurnOff(SoftBusMessage * msg)1539 static void BleDiscTurnOff(SoftBusMessage *msg)
1540 {
1541 DISC_LOGD(DISC_BLE, "enter");
1542 if (StopAdvertiser(NON_ADV_ID) != SOFTBUS_OK) {
1543 DISC_LOGE(DISC_BLE, "Stop NON_ADV_ID failed");
1544 }
1545 if (StopAdvertiser(CON_ADV_ID) != SOFTBUS_OK) {
1546 DISC_LOGE(DISC_BLE, "Stop CON_ADV_ID failed");
1547 }
1548 if (StopScaner() != SOFTBUS_OK) {
1549 DISC_LOGE(DISC_BLE, "Stop failed");
1550 }
1551 DISC_LOGD(DISC_BLE, "end");
1552 }
1553
ReplyPassiveNonBroadcast(void)1554 static int32_t ReplyPassiveNonBroadcast(void)
1555 {
1556 DISC_LOGD(DISC_BLE, "enter");
1557 SoftBusMessage *msg = CreateBleHandlerMsg(REPLY_PASSIVE_NON_BROADCAST, 0, 0, NULL);
1558 if (msg == NULL) {
1559 return SOFTBUS_MALLOC_ERR;
1560 }
1561 g_discBleHandler.looper->PostMessage(g_discBleHandler.looper, msg);
1562 return SOFTBUS_OK;
1563 }
1564
MessageRemovePredicate(const SoftBusMessage * msg,void * args)1565 static int32_t MessageRemovePredicate(const SoftBusMessage *msg, void *args)
1566 {
1567 DISC_LOGD(DISC_BLE, "enter");
1568 uintptr_t key = (uintptr_t)args;
1569 if (msg->what == PROCESS_TIME_OUT && msg->arg1 == key) {
1570 DISC_LOGD(DISC_BLE, "find key");
1571 return 0;
1572 }
1573 DISC_LOGW(DISC_BLE, "not find key");
1574 return 1;
1575 }
1576
GetRecvMessage(const char * key)1577 static RecvMessage *GetRecvMessage(const char *key)
1578 {
1579 RecvMessage *msg = NULL;
1580 LIST_FOR_EACH_ENTRY(msg, &g_recvMessageInfo.node, RecvMessage, node) {
1581 if (memcmp((void *)key, (void *)msg->key, SHA_HASH_LEN) == 0) {
1582 return msg;
1583 }
1584 }
1585 return NULL;
1586 }
1587
MatchRecvMessage(const uint32_t * publishInfoMap,uint32_t * capBitMap,uint32_t len)1588 static int32_t MatchRecvMessage(const uint32_t *publishInfoMap, uint32_t *capBitMap, uint32_t len)
1589 {
1590 DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_recvMessageInfo.lock) == SOFTBUS_OK,
1591 SOFTBUS_LOCK_ERR, DISC_BLE, "lock failed");
1592 RecvMessage *msg = NULL;
1593 DISC_LOGI(DISC_BLE, "recv message cnt=%{public}d", g_recvMessageInfo.numNeedResp);
1594 LIST_FOR_EACH_ENTRY(msg, &g_recvMessageInfo.node, RecvMessage, node) {
1595 for (uint32_t index = 0; index < len; index++) {
1596 capBitMap[index] |= msg->capBitMap[index] & publishInfoMap[index];
1597 }
1598 }
1599 (void)SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1600 return SOFTBUS_OK;
1601 }
1602
StartTimeout(const char * key)1603 static void StartTimeout(const char *key)
1604 {
1605 DISC_LOGD(DISC_BLE, "enter");
1606 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_recvMessageInfo.lock) == SOFTBUS_OK, DISC_BLE, "lock failed");
1607 if (GetRecvMessage(key) == NULL) {
1608 DISC_LOGE(DISC_BLE, "key is not exists");
1609 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1610 return;
1611 }
1612 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1613 SoftBusMessage *msg = CreateBleHandlerMsg(PROCESS_TIME_OUT, (uintptr_t)key, 0, NULL);
1614 DISC_CHECK_AND_RETURN_LOGE(msg != NULL, DISC_BLE, "malloc msg failed");
1615 g_discBleHandler.looper->PostMessageDelay(g_discBleHandler.looper, msg, BLE_MSG_TIME_OUT);
1616 }
1617
RemoveTimeout(const char * key)1618 static void RemoveTimeout(const char *key)
1619 {
1620 DISC_LOGD(DISC_BLE, "enter");
1621 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_recvMessageInfo.lock) == SOFTBUS_OK, DISC_BLE, "lock failed");
1622 if (GetRecvMessage(key) == NULL) {
1623 DISC_LOGI(DISC_BLE, "key is not in recv message");
1624 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1625 return;
1626 }
1627 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1628 g_discBleHandler.looper->RemoveMessageCustom(g_discBleHandler.looper, &g_discBleHandler, MessageRemovePredicate,
1629 (void *)key);
1630 }
1631
RecvMsgAggregateCap(void)1632 static uint32_t RecvMsgAggregateCap(void)
1633 {
1634 RecvMessage *msg = NULL;
1635 uint32_t revMessageCap = 0;
1636 LIST_FOR_EACH_ENTRY(msg, &g_recvMessageInfo.node, RecvMessage, node) {
1637 for (uint32_t index = 0; index < CAPABILITY_NUM; index++) {
1638 revMessageCap = msg->capBitMap[index] | revMessageCap;
1639 }
1640 }
1641 return revMessageCap;
1642 }
1643
DfxRecordAddRecvMsgEnd(const uint32_t * capBitMap,int32_t reason)1644 static void DfxRecordAddRecvMsgEnd(const uint32_t *capBitMap, int32_t reason)
1645 {
1646 DiscEventExtra extra = { 0 };
1647 DiscEventExtraInit(&extra);
1648 extra.discType = BLE + 1;
1649 extra.errcode = reason;
1650 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
1651
1652 if (capBitMap != NULL) {
1653 extra.capabilityBit = (int32_t)capBitMap[0];
1654 }
1655 DISC_EVENT(EVENT_SCENE_BLE, EVENT_STAGE_SCAN_RECV, extra);
1656 }
1657
AddRecvMessage(const char * key,const uint32_t * capBitMap,bool needBrMac)1658 static int32_t AddRecvMessage(const char *key, const uint32_t *capBitMap, bool needBrMac)
1659 {
1660 DISC_LOGD(DISC_BLE, "enter");
1661 if (SoftBusMutexLock(&g_recvMessageInfo.lock) != SOFTBUS_OK) {
1662 DfxRecordAddRecvMsgEnd(capBitMap, SOFTBUS_LOCK_ERR);
1663 DISC_LOGE(DISC_BLE, "lock failed");
1664 return SOFTBUS_LOCK_ERR;
1665 }
1666 uint32_t oldAggregateCap = RecvMsgAggregateCap();
1667 RecvMessage *recvMsg = GetRecvMessage(key);
1668 if (recvMsg == NULL) {
1669 DISC_LOGI(DISC_BLE, "key is not exit");
1670 recvMsg = (RecvMessage *)SoftBusCalloc(sizeof(RecvMessage));
1671 if (recvMsg == NULL) {
1672 DfxRecordAddRecvMsgEnd(capBitMap, SOFTBUS_MALLOC_ERR);
1673 DISC_LOGE(DISC_BLE, "malloc recv msg failed");
1674 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1675 return SOFTBUS_MALLOC_ERR;
1676 }
1677 if (memcpy_s(&recvMsg->key, SHA_HASH_LEN, key, SHA_HASH_LEN) != EOK) {
1678 DfxRecordAddRecvMsgEnd(capBitMap, SOFTBUS_MEM_ERR);
1679 DISC_LOGE(DISC_BLE, "copy key to create recv msg failed");
1680 SoftBusFree(recvMsg);
1681 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1682 return SOFTBUS_MEM_ERR;
1683 }
1684 for (uint32_t index = 0; index < CAPABILITY_NUM; index++) {
1685 recvMsg->capBitMap[index] = capBitMap[index];
1686 }
1687 recvMsg->needBrMac = needBrMac;
1688 g_recvMessageInfo.numNeedBrMac++;
1689 g_recvMessageInfo.numNeedResp++;
1690 ListTailInsert(&g_recvMessageInfo.node, &recvMsg->node);
1691 uint32_t newAggregateCap = RecvMsgAggregateCap();
1692 if (oldAggregateCap != newAggregateCap) {
1693 UpdateInfoManager(NON_ADV_ID, true);
1694 }
1695 } else {
1696 RemoveTimeout(recvMsg->key);
1697 }
1698 StartTimeout(recvMsg->key);
1699 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1700 DfxRecordAddRecvMsgEnd(capBitMap, SOFTBUS_OK);
1701 return SOFTBUS_OK;
1702 }
1703
RemoveRecvMessage(uint64_t key)1704 static void RemoveRecvMessage(uint64_t key)
1705 {
1706 DISC_LOGD(DISC_BLE, "enter");
1707 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_recvMessageInfo.lock) == SOFTBUS_OK, DISC_BLE, "lock failed");
1708
1709 RecvMessage *msg = GetRecvMessage((char *)(uintptr_t)key);
1710 if (msg == NULL) {
1711 DISC_LOGE(DISC_BLE, "not find message");
1712 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1713 return;
1714 }
1715
1716 if (g_discBleHandler.looper && g_discBleHandler.looper->RemoveMessageCustom) {
1717 g_discBleHandler.looper->RemoveMessageCustom(g_discBleHandler.looper, &g_discBleHandler,
1718 MessageRemovePredicate, (void *)key);
1719 }
1720 if (msg->needBrMac) {
1721 g_recvMessageInfo.numNeedBrMac--;
1722 }
1723 g_recvMessageInfo.numNeedResp--;
1724 ListDelete(&msg->node);
1725 SoftBusFree(msg);
1726 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1727 }
1728
ClearRecvMessage(void)1729 static void ClearRecvMessage(void)
1730 {
1731 ListNode *head = &(g_recvMessageInfo.node);
1732 while (!IsListEmpty(head)) {
1733 RecvMessage *msg = LIST_ENTRY(head->next, RecvMessage, node);
1734 ListDelete(&msg->node);
1735 if (g_discBleHandler.looper && g_discBleHandler.looper->RemoveMessageCustom) {
1736 g_discBleHandler.looper->RemoveMessageCustom(g_discBleHandler.looper, &g_discBleHandler,
1737 MessageRemovePredicate, (void *)msg->key);
1738 }
1739 SoftBusFree(msg);
1740 }
1741 }
1742
ProcessTimeout(SoftBusMessage * msg)1743 static void ProcessTimeout(SoftBusMessage *msg)
1744 {
1745 DISC_LOGD(DISC_BLE, "enter");
1746 RemoveRecvMessage(msg->arg1);
1747 if (g_bleAdvertiser[NON_ADV_ID].isAdvertising) {
1748 UpdateAdvertiser(NON_ADV_ID);
1749 }
1750 }
1751
OnBrStateChanged(SoftBusMessage * msg)1752 static void OnBrStateChanged(SoftBusMessage *msg)
1753 {
1754 (void)msg;
1755 DISC_LOGD(DISC_BLE, "enter");
1756 if (g_bleAdvertiser[NON_ADV_ID].isAdvertising) {
1757 DISC_CHECK_AND_RETURN_LOGE(SoftBusMutexLock(&g_recvMessageInfo.lock) == SOFTBUS_OK, DISC_BLE, "lock failed");
1758 uint32_t numNeedBrMac = g_recvMessageInfo.numNeedBrMac;
1759 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1760
1761 if (numNeedBrMac > 0) {
1762 UpdateAdvertiser(NON_ADV_ID);
1763 }
1764 }
1765 }
1766
DiscBleMsgHandler(SoftBusMessage * msg)1767 static void DiscBleMsgHandler(SoftBusMessage *msg)
1768 {
1769 switch (msg->what) {
1770 case PUBLISH_ACTIVE_SERVICE:
1771 StartActivePublish(msg);
1772 break;
1773 case PUBLISH_PASSIVE_SERVICE:
1774 StartPassivePublish(msg);
1775 break;
1776 case UNPUBLISH_SERVICE:
1777 if (g_bleAdvertiser[NON_ADV_ID].isAdvertising) {
1778 UpdateAdvertiser(NON_ADV_ID);
1779 }
1780 StartScaner(CON_FILTER_TYPE);
1781 break;
1782 case START_ACTIVE_DISCOVERY:
1783 StartActiveDiscovery(msg);
1784 break;
1785 case START_PASSIVE_DISCOVERY:
1786 StartPassiveDiscovery(msg);
1787 break;
1788 case STOP_DISCOVERY:
1789 if (g_bleAdvertiser[CON_ADV_ID].isAdvertising) {
1790 UpdateAdvertiser(CON_ADV_ID);
1791 } else {
1792 StartAdvertiser(CON_ADV_ID);
1793 }
1794 StartScaner(NON_FILTER_TYPE);
1795 break;
1796 case REPLY_PASSIVE_NON_BROADCAST:
1797 StartAdvertiser(NON_ADV_ID);
1798 break;
1799 case PROCESS_TIME_OUT:
1800 ProcessTimeout(msg);
1801 break;
1802 case RECOVERY:
1803 Recovery(msg);
1804 break;
1805 case TURN_OFF:
1806 BleDiscTurnOff(msg);
1807 break;
1808 case BR_STATE_CHANGED:
1809 OnBrStateChanged(msg);
1810 break;
1811 default:
1812 DISC_LOGW(DISC_BLE, "wrong msg what=%{public}d", msg->what);
1813 break;
1814 }
1815 }
1816
DiscBleLooperInit(void)1817 static int32_t DiscBleLooperInit(void)
1818 {
1819 g_discBleHandler.looper = GetLooper(LOOP_TYPE_DEFAULT);
1820 DISC_CHECK_AND_RETURN_RET_LOGE(g_discBleHandler.looper != NULL, SOFTBUS_LOOPER_ERR, DISC_INIT, "get looper fail");
1821
1822 g_discBleHandler.name = (char *)"ble_disc_handler";
1823 g_discBleHandler.HandleMessage = DiscBleMsgHandler;
1824 return SOFTBUS_OK;
1825 }
1826
DiscFreeBleScanFilter(BcScanFilter * filter)1827 static void DiscFreeBleScanFilter(BcScanFilter *filter)
1828 {
1829 if (filter != NULL) {
1830 SoftBusFree(filter->serviceData);
1831 SoftBusFree(filter->serviceDataMask);
1832 SoftBusFree(filter);
1833 filter = NULL;
1834 }
1835 }
1836
DiscBleSetScanFilter(int32_t listenerId,int32_t type)1837 static void DiscBleSetScanFilter(int32_t listenerId, int32_t type)
1838 {
1839 DISC_CHECK_AND_RETURN_LOGW(type != 0, DISC_BLE, "not disc capblity, not set filter");
1840 BcScanFilter *filter = (BcScanFilter *)SoftBusCalloc(sizeof(BcScanFilter));
1841 DISC_CHECK_AND_RETURN_LOGE(filter != NULL, DISC_BLE, "malloc filter failed");
1842
1843 filter->serviceData = (uint8_t *)SoftBusCalloc(BLE_SCAN_FILTER_LEN);
1844 filter->serviceDataMask = (uint8_t *)SoftBusCalloc(BLE_SCAN_FILTER_LEN);
1845 if (filter->serviceData == NULL || filter->serviceDataMask == NULL) {
1846 DISC_LOGE(DISC_BLE, "malloc filter data failed");
1847 DiscFreeBleScanFilter(filter);
1848 return;
1849 }
1850
1851 filter->serviceUuid = SERVICE_UUID;
1852 filter->serviceDataLength = BLE_SCAN_FILTER_LEN;
1853 filter->serviceData[POS_VERSION] = BLE_VERSION;
1854 filter->serviceData[POS_BUSINESS] = DISTRIBUTE_BUSINESS;
1855 filter->serviceDataMask[POS_VERSION] = BYTE_MASK;
1856 filter->serviceDataMask[POS_BUSINESS] = BYTE_MASK;
1857
1858 if (type == CON_FILTER_TYPE) {
1859 filter->serviceData[POS_BUSINESS_EXTENSION] = ((1 << BYTE_SHIFT_7BIT) | (1 << BYTE_SHIFT_4BIT));
1860 filter->serviceDataMask[POS_BUSINESS_EXTENSION] = ((1 << BYTE_SHIFT_7BIT) | (1 << BYTE_SHIFT_4BIT));
1861 }
1862 if (type == NON_FILTER_TYPE) {
1863 filter->serviceData[POS_BUSINESS_EXTENSION] = (1 << BYTE_SHIFT_4BIT);
1864 filter->serviceDataMask[POS_BUSINESS_EXTENSION] = ((1 << BYTE_SHIFT_7BIT) | (1 << BYTE_SHIFT_4BIT));
1865 }
1866 if (type == (CON_FILTER_TYPE | NON_FILTER_TYPE)) {
1867 filter->serviceData[POS_BUSINESS_EXTENSION] = ((1 << BYTE_SHIFT_7BIT) | (1 << BYTE_SHIFT_4BIT));
1868 filter->serviceDataMask[POS_BUSINESS_EXTENSION] = (1 << BYTE_SHIFT_4BIT);
1869 }
1870
1871 if (SchedulerSetScanFilter(listenerId, filter, 1) != SOFTBUS_OK) {
1872 DISC_LOGE(DISC_BLE, "set scan filter failed");
1873 DiscFreeBleScanFilter(filter);
1874 }
1875 }
1876
InitBleListener(void)1877 static int32_t InitBleListener(void)
1878 {
1879 int32_t ret = SchedulerRegisterScanListener(SRV_TYPE_DIS, &g_bleListener.scanListenerId, &g_scanListener);
1880 DISC_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, DISC_BLE, "register scanner listener fail");
1881 g_bleListener.stateListenerId = SoftBusAddBtStateListener(&g_stateChangedListener);
1882 if (g_bleListener.stateListenerId < 0 || g_bleListener.scanListenerId < 0) {
1883 return SOFTBUS_BC_MGR_REG_NO_AVAILABLE_LISN_ID;
1884 }
1885 return SOFTBUS_OK;
1886 }
1887
DiscSoftBusBleInit(DiscInnerCallback * callback)1888 DiscoveryBleDispatcherInterface *DiscSoftBusBleInit(DiscInnerCallback *callback)
1889 {
1890 DISC_LOGI(DISC_INIT, "enter");
1891 DISC_CHECK_AND_RETURN_RET_LOGE(callback != NULL && callback->OnDeviceFound != NULL, NULL,
1892 DISC_INIT, "callback invalid.");
1893
1894 ListInit(&g_recvMessageInfo.node);
1895 g_discBleInnerCb = callback;
1896
1897 SoftBusMutexAttr mutexAttr = {
1898 .type = SOFTBUS_MUTEX_RECURSIVE,
1899 };
1900 if (SoftBusMutexInit(&g_recvMessageInfo.lock, &mutexAttr) != SOFTBUS_OK ||
1901 SoftBusMutexInit(&g_bleInfoLock, NULL) != SOFTBUS_OK) {
1902 DiscSoftBusBleDeinit();
1903 DISC_LOGE(DISC_INIT, "init ble lock failed");
1904 return NULL;
1905 }
1906
1907 DiscBleInitPublish();
1908 DiscBleInitSubscribe();
1909 InitScanner();
1910 if (SchedulerInitBroadcast() != SOFTBUS_OK) {
1911 DiscSoftBusBleDeinit();
1912 DISC_LOGE(DISC_INIT, "init broadcast scheduler failed");
1913 return NULL;
1914 }
1915
1916 if (DiscBleLooperInit() != SOFTBUS_OK || InitAdvertiser() != SOFTBUS_OK || InitBleListener() != SOFTBUS_OK) {
1917 DiscSoftBusBleDeinit();
1918 return NULL;
1919 }
1920
1921 SoftBusRegDiscVarDump((char *)BLE_INFO_MANAGER, &BleInfoDump);
1922 SoftBusRegDiscVarDump((char *)BlE_ADVERTISER, &BleAdvertiserDump);
1923 SoftBusRegDiscVarDump((char *)RECV_MESSAGE_INFO, &RecvMessageInfoDump);
1924
1925 DISC_LOGI(DISC_INIT, "success");
1926 return &g_discBleDispatcherInterface;
1927 }
1928
CheckLockInit(SoftBusMutex * lock)1929 static bool CheckLockInit(SoftBusMutex *lock)
1930 {
1931 if (SoftBusMutexLock(lock) != SOFTBUS_OK) {
1932 return false;
1933 }
1934 SoftBusMutexUnlock(lock);
1935 return true;
1936 }
1937
RecvMessageDeinit(void)1938 static void RecvMessageDeinit(void)
1939 {
1940 int32_t ret = SoftBusMutexLock(&g_recvMessageInfo.lock);
1941 ClearRecvMessage();
1942 if (ret == SOFTBUS_OK) {
1943 SoftBusMutexUnlock(&g_recvMessageInfo.lock);
1944 (void)SoftBusMutexDestroy(&g_recvMessageInfo.lock);
1945 }
1946 g_recvMessageInfo.numNeedBrMac = 0;
1947 g_recvMessageInfo.numNeedResp = 0;
1948 }
1949
AdvertiserDeinit(void)1950 static void AdvertiserDeinit(void)
1951 {
1952 (void)SchedulerUnregisterBroadcaster(g_bleAdvertiser[CON_ADV_ID].channel);
1953 (void)SchedulerUnregisterBroadcaster(g_bleAdvertiser[NON_ADV_ID].channel);
1954 for (uint32_t index = 0; index < NUM_ADVERTISER; index++) {
1955 (void)memset_s(&g_bleAdvertiser[index], sizeof(DiscBleAdvertiser), 0x0, sizeof(DiscBleAdvertiser));
1956 }
1957 }
1958
BleListenerDeinit(void)1959 static void BleListenerDeinit(void)
1960 {
1961 (void)SoftBusRemoveBtStateListener(g_bleListener.stateListenerId);
1962 (void)SchedulerUnregisterListener(g_bleListener.scanListenerId);
1963 }
1964
DiscBleInfoDeinit(void)1965 static void DiscBleInfoDeinit(void)
1966 {
1967 for (uint32_t index = 0; index < BLE_INFO_COUNT; index++) {
1968 (void)memset_s(&g_bleInfoManager[index], sizeof(DiscBleInfo), 0x0, sizeof(DiscBleInfo));
1969 }
1970 if (CheckLockInit(&g_bleInfoLock)) {
1971 (void)SoftBusMutexDestroy(&g_bleInfoLock);
1972 }
1973 }
1974
DiscSoftBusBleDeinit(void)1975 void DiscSoftBusBleDeinit(void)
1976 {
1977 if (g_isScanning) {
1978 (void)StopScaner();
1979 }
1980 g_discBleInnerCb = NULL;
1981 BleListenerDeinit();
1982 RecvMessageDeinit();
1983 DiscBleInfoDeinit();
1984 AdvertiserDeinit();
1985 SchedulerDeinitBroadcast();
1986 }
1987
BleInfoDump(int fd)1988 static int32_t BleInfoDump(int fd)
1989 {
1990 DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_bleInfoLock) == SOFTBUS_OK,
1991 SOFTBUS_LOCK_ERR, DISC_BLE, "lock failed.");
1992 SOFTBUS_DPRINTF(fd, "-----------------BleInfoManager Info-------------------\n");
1993 for (int i = 0; i < BLE_INFO_COUNT; i++) {
1994 SOFTBUS_DPRINTF(fd, "BleInfo needUpdate : %d\n", g_bleInfoManager[i].needUpdate);
1995 SOFTBUS_DPRINTF(fd, "BleInfo capBitMap : %u\n", *(g_bleInfoManager[i].capBitMap));
1996 SOFTBUS_DPRINTF(fd, "BleInfo capCount : %d\n", *(g_bleInfoManager[i].capCount));
1997 SOFTBUS_DPRINTF(fd, "BleInfo capabilityData : %s\n", *(g_bleInfoManager[i].capabilityData));
1998 SOFTBUS_DPRINTF(fd, "BleInfo capDataLen : %u\n", *(g_bleInfoManager[i].capDataLen));
1999 SOFTBUS_DPRINTF(fd, "BleInfo isSameAccount : %d\n", *(g_bleInfoManager[i].isSameAccount));
2000 SOFTBUS_DPRINTF(fd, "BleInfo isWakeRemote : %d\n", *(g_bleInfoManager[i].isWakeRemote));
2001 SOFTBUS_DPRINTF(fd, "BleInfo freq : %d\n", *(g_bleInfoManager[i].freq));
2002 SOFTBUS_DPRINTF(fd, "BleInfo rangingRefCnt : %d\n", g_bleInfoManager[i].rangingRefCnt);
2003 }
2004 (void)SoftBusMutexUnlock(&g_bleInfoLock);
2005 return SOFTBUS_OK;
2006 }
2007
BleAdvertiserDump(int fd)2008 static int32_t BleAdvertiserDump(int fd)
2009 {
2010 char bleMac[BT_MAC_LEN] = {0};
2011 char hash[UDID_HASH_LEN] = {0};
2012 char peerUid[MAX_ACCOUNT_HASH_LEN] = {0};
2013 SOFTBUS_DPRINTF(fd, "\n-----------------BleAdvertiser Info-------------------\n");
2014 for (int i = 0; i < NUM_ADVERTISER; i++) {
2015 SOFTBUS_DPRINTF(fd, "BleAdvertiser channel : %d\n", g_bleAdvertiser[i].channel);
2016 SOFTBUS_DPRINTF(fd, "BleAdvertiser isAdvertising : %d\n", g_bleAdvertiser[i].isAdvertising);
2017 SOFTBUS_DPRINTF(fd, "DeviceInfo : \n");
2018 char *anonymizedInfo = NULL;
2019 Anonymize(g_bleAdvertiser[i].deviceInfo.devId, &anonymizedInfo);
2020 SOFTBUS_DPRINTF(fd, "devId : %s\n", AnonymizeWrapper(anonymizedInfo));
2021 AnonymizeFree(anonymizedInfo);
2022 Anonymize(g_bleAdvertiser[i].deviceInfo.accountHash, &anonymizedInfo);
2023 SOFTBUS_DPRINTF(fd, "accountHash : %s\n", AnonymizeWrapper(anonymizedInfo));
2024 AnonymizeFree(anonymizedInfo);
2025 SOFTBUS_DPRINTF(fd, "devType : %u\n", g_bleAdvertiser[i].deviceInfo.devType);
2026 Anonymize(g_bleAdvertiser[i].deviceInfo.devName, &anonymizedInfo);
2027 SOFTBUS_DPRINTF(fd, "devName : %s\n", AnonymizeWrapper(anonymizedInfo));
2028 AnonymizeFree(anonymizedInfo);
2029 SOFTBUS_DPRINTF(fd, "addrNum : %u\n", g_bleAdvertiser[i].deviceInfo.addrNum);
2030 SOFTBUS_DPRINTF(fd, "addr type : %u\n",
2031 g_bleAdvertiser[i].deviceInfo.addr[CONNECTION_ADDR_BLE].type);
2032 DataMasking(g_bleAdvertiser[i].deviceInfo.addr[CONNECTION_ADDR_BLE].info.ble.bleMac,
2033 BT_MAC_LEN, MAC_DELIMITER, bleMac);
2034 SOFTBUS_DPRINTF(fd, "Connection bleMac : %s\n", bleMac);
2035 DataMasking((char *)(g_bleAdvertiser[i].deviceInfo.addr[CONNECTION_ADDR_BLE].info.ble.udidHash),
2036 UDID_HASH_LEN, ID_DELIMITER, hash);
2037 SOFTBUS_DPRINTF(fd, "Connection bleHash : %s\n", hash);
2038 DataMasking(g_bleAdvertiser[i].deviceInfo.addr[CONNECTION_ADDR_BLE].peerUid,
2039 MAX_ACCOUNT_HASH_LEN, ID_DELIMITER, peerUid);
2040 SOFTBUS_DPRINTF(fd, "Connection peerUid : %s\n", peerUid);
2041 SOFTBUS_DPRINTF(fd, "capabilityBitmapNum : %u\n",
2042 g_bleAdvertiser[i].deviceInfo.capabilityBitmapNum);
2043 SOFTBUS_DPRINTF(fd, "capabilityBitmap : %u\n",
2044 *(g_bleAdvertiser[i].deviceInfo.capabilityBitmap));
2045 SOFTBUS_DPRINTF(fd, "custData : %s\n", g_bleAdvertiser[i].deviceInfo.custData);
2046 SOFTBUS_DPRINTF(fd, "range : %d\n", g_bleAdvertiser[i].deviceInfo.range);
2047 }
2048 return SOFTBUS_OK;
2049 }
2050
RecvMessageInfoDump(int fd)2051 static int32_t RecvMessageInfoDump(int fd)
2052 {
2053 DISC_CHECK_AND_RETURN_RET_LOGE(SoftBusMutexLock(&g_recvMessageInfo.lock) == SOFTBUS_OK,
2054 SOFTBUS_LOCK_ERR, DISC_BLE, "lock failed.");
2055 ListNode *item = NULL;
2056 SOFTBUS_DPRINTF(fd, "\n-----------------RecvMessage Info-------------------\n");
2057 SOFTBUS_DPRINTF(fd, "RecvMessageInfo numNeedBrMac : %u\n", g_recvMessageInfo.numNeedBrMac);
2058 SOFTBUS_DPRINTF(fd, "RecvMessageInfo numNeedResp : %u\n", g_recvMessageInfo.numNeedResp);
2059 LIST_FOR_EACH(item, &g_recvMessageInfo.node)
2060 {
2061 RecvMessage *recvNode = LIST_ENTRY(item, RecvMessage, node);
2062 SOFTBUS_DPRINTF(fd, "RecvMessage capBitMap : %u\n", recvNode->capBitMap[0]);
2063 SOFTBUS_DPRINTF(fd, "RecvMessage key : %s\n", recvNode->key);
2064 SOFTBUS_DPRINTF(fd, "needBrMac : %d\n", recvNode->needBrMac);
2065 }
2066 (void)SoftBusMutexUnlock(&g_recvMessageInfo.lock);
2067 return SOFTBUS_OK;
2068 }
2069