1 /*
2 * Copyright (c) 2023-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 "softbus_ble_utils.h"
17 #include "softbus_adapter_mem.h"
18 #include "softbus_broadcast_type.h"
19 #include "softbus_error_code.h"
20 #include "softbus_utils.h"
21 #include "softbus_broadcast_utils.h"
22 #include "disc_log.h"
23 #include <securec.h>
24
25 #define UUID_LEN 2
26 #define UUID_MASK_LEN 2
27 #define ID_LEN 2
28 #define MANUFACTURE_DATA_LEN 1
29 #define MANUFACTURE_DATA_ID 0x027D
30
BtStatusToSoftBus(BtStatus btStatus)31 int32_t BtStatusToSoftBus(BtStatus btStatus)
32 {
33 switch (btStatus) {
34 case OHOS_BT_STATUS_SUCCESS:
35 return SOFTBUS_BC_STATUS_SUCCESS;
36 case OHOS_BT_STATUS_FAIL:
37 return SOFTBUS_BC_STATUS_FAIL;
38 case OHOS_BT_STATUS_NOT_READY:
39 return SOFTBUS_BC_STATUS_NOT_READY;
40 case OHOS_BT_STATUS_NOMEM:
41 return SOFTBUS_BC_STATUS_NOMEM;
42 case OHOS_BT_STATUS_BUSY:
43 return SOFTBUS_BC_STATUS_BUSY;
44 case OHOS_BT_STATUS_DONE:
45 return SOFTBUS_BC_STATUS_DONE;
46 case OHOS_BT_STATUS_UNSUPPORTED:
47 return SOFTBUS_BC_STATUS_UNSUPPORTED;
48 case OHOS_BT_STATUS_PARM_INVALID:
49 return SOFTBUS_BC_STATUS_PARM_INVALID;
50 case OHOS_BT_STATUS_UNHANDLED:
51 return SOFTBUS_BC_STATUS_UNHANDLED;
52 case OHOS_BT_STATUS_AUTH_FAILURE:
53 return SOFTBUS_BC_STATUS_AUTH_FAILURE;
54 case OHOS_BT_STATUS_RMT_DEV_DOWN:
55 return SOFTBUS_BC_STATUS_RMT_DEV_DOWN;
56 case OHOS_BT_STATUS_AUTH_REJECTED:
57 return SOFTBUS_BC_STATUS_AUTH_REJECTED;
58 case OHOS_BT_STATUS_DUPLICATED_ADDR:
59 return SOFTBUS_BC_STATUS_DUPLICATED_ADDR;
60 default:
61 return SOFTBUS_BC_STATUS_FAIL;
62 }
63 }
64
SoftbusAdvDataTypeToBt(uint16_t advType)65 static uint16_t SoftbusAdvDataTypeToBt(uint16_t advType)
66 {
67 switch (advType) {
68 case BC_DATA_TYPE_SERVICE:
69 return SERVICE_BC_TYPE;
70 case BC_DATA_TYPE_MANUFACTURER:
71 return MANUFACTURE_BC_TYPE;
72 default:
73 return 0x00;
74 }
75 }
76
BtAdvTypeToSoftbus(uint16_t advType)77 static uint16_t BtAdvTypeToSoftbus(uint16_t advType)
78 {
79 switch (advType) {
80 case SERVICE_BC_TYPE:
81 return BC_DATA_TYPE_SERVICE;
82 case MANUFACTURE_BC_TYPE:
83 return BC_DATA_TYPE_MANUFACTURER;
84 default:
85 return 0x00;
86 }
87 }
88
SoftbusAdvFilterToBt(uint8_t advFilter)89 static BleAdvFilter SoftbusAdvFilterToBt(uint8_t advFilter)
90 {
91 switch (advFilter) {
92 case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
93 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
94 case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY:
95 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY;
96 case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST:
97 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST;
98 case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST:
99 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST;
100 default:
101 return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
102 }
103 }
104
SoftbusAdvTypeToBt(uint8_t advType)105 static BleAdvType SoftbusAdvTypeToBt(uint8_t advType)
106 {
107 switch (advType) {
108 case SOFTBUS_BC_ADV_IND:
109 return OHOS_BLE_ADV_IND;
110 case SOFTBUS_BC_ADV_DIRECT_IND_HIGH:
111 return OHOS_BLE_ADV_DIRECT_IND_HIGH;
112 case SOFTBUS_BC_ADV_SCAN_IND:
113 return OHOS_BLE_ADV_SCAN_IND;
114 case SOFTBUS_BC_ADV_NONCONN_IND:
115 return OHOS_BLE_ADV_NONCONN_IND;
116 case SOFTBUS_BC_ADV_DIRECT_IND_LOW:
117 return OHOS_BLE_ADV_DIRECT_IND_LOW;
118 default:
119 return OHOS_BLE_ADV_IND;
120 }
121 }
122
SoftbusAdvParamToBt(const SoftbusBroadcastParam * src,BleAdvParams * dst)123 void SoftbusAdvParamToBt(const SoftbusBroadcastParam *src, BleAdvParams *dst)
124 {
125 if (memcpy_s(dst->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, src->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
126 DISC_LOGW(DISC_BLE_ADAPTER, "copy peer addr failed");
127 }
128 dst->minInterval = src->minInterval;
129 dst->maxInterval = src->maxInterval;
130 dst->advType = SoftbusAdvTypeToBt(src->advType);
131 dst->ownAddrType = (unsigned char)src->ownAddrType;
132 dst->peerAddrType = (unsigned char)src->peerAddrType;
133 dst->channelMap = src->channelMap;
134 dst->advFilterPolicy = SoftbusAdvFilterToBt(src->advFilterPolicy);
135 dst->txPower = src->txPower;
136 dst->duration = src->duration;
137 }
138
BtScanEventTypeToSoftbus(unsigned char eventType)139 static uint8_t BtScanEventTypeToSoftbus(unsigned char eventType)
140 {
141 switch (eventType) {
142 case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE:
143 return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE;
144 case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED:
145 return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
146 case OHOS_BLE_EVT_CONNECTABLE:
147 return SOFTBUS_BC_EVT_CONNECTABLE;
148 case OHOS_BLE_EVT_CONNECTABLE_DIRECTED:
149 return SOFTBUS_BC_EVT_CONNECTABLE_DIRECTED;
150 case OHOS_BLE_EVT_SCANNABLE:
151 return SOFTBUS_BC_EVT_SCANNABLE;
152 case OHOS_BLE_EVT_SCANNABLE_DIRECTED:
153 return SOFTBUS_BC_EVT_SCANNABLE_DIRECTED;
154 case OHOS_BLE_EVT_LEGACY_NON_CONNECTABLE:
155 return SOFTBUS_BC_EVT_LEGACY_NON_CONNECTABLE;
156 case OHOS_BLE_EVT_LEGACY_SCANNABLE:
157 return SOFTBUS_BC_EVT_LEGACY_SCANNABLE;
158 case OHOS_BLE_EVT_LEGACY_CONNECTABLE:
159 return SOFTBUS_BC_EVT_LEGACY_CONNECTABLE;
160 case OHOS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED:
161 return SOFTBUS_BC_EVT_LEGACY_CONNECTABLE_DIRECTED;
162 case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN:
163 return SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN;
164 case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV:
165 return SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV;
166 default:
167 return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE;
168 }
169 }
170
BtScanDataStatusToSoftbus(unsigned char dataStatus)171 static uint8_t BtScanDataStatusToSoftbus(unsigned char dataStatus)
172 {
173 switch (dataStatus) {
174 case OHOS_BLE_DATA_COMPLETE:
175 return SOFTBUS_BC_DATA_COMPLETE;
176 case OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME:
177 return SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME;
178 case OHOS_BLE_DATA_INCOMPLETE_TRUNCATED:
179 return SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED;
180 default:
181 return SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED;
182 }
183 }
184
BtScanAddrTypeToSoftbus(unsigned char addrType)185 static uint8_t BtScanAddrTypeToSoftbus(unsigned char addrType)
186 {
187 switch (addrType) {
188 case OHOS_BLE_PUBLIC_DEVICE_ADDRESS:
189 return SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
190 case OHOS_BLE_RANDOM_DEVICE_ADDRESS:
191 return SOFTBUS_BC_RANDOM_DEVICE_ADDRESS;
192 case OHOS_BLE_PUBLIC_IDENTITY_ADDRESS:
193 return SOFTBUS_BC_PUBLIC_IDENTITY_ADDRESS;
194 case OHOS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS:
195 return SOFTBUS_BC_RANDOM_STATIC_IDENTITY_ADDRESS;
196 case OHOS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS:
197 return SOFTBUS_BC_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
198 case OHOS_BLE_NO_ADDRESS:
199 return SOFTBUS_BC_NO_ADDRESS;
200 default:
201 return SOFTBUS_BC_NO_ADDRESS;
202 }
203 }
204
BtScanPhyTypeToSoftbus(unsigned char phyType)205 static uint8_t BtScanPhyTypeToSoftbus(unsigned char phyType)
206 {
207 switch (phyType) {
208 case OHOS_BLE_SCAN_PHY_NO_PACKET:
209 return SOFTBUS_BC_SCAN_PHY_NO_PACKET;
210 case OHOS_BLE_SCAN_PHY_1M:
211 return SOFTBUS_BC_SCAN_PHY_1M;
212 case OHOS_BLE_SCAN_PHY_2M:
213 return SOFTBUS_BC_SCAN_PHY_2M;
214 case OHOS_BLE_SCAN_PHY_CODED:
215 return SOFTBUS_BC_SCAN_PHY_CODED;
216 default:
217 return SOFTBUS_BC_SCAN_PHY_NO_PACKET;
218 }
219 }
220
BtScanResultToSoftbus(const BtScanResultData * src,SoftBusBcScanResult * dst)221 void BtScanResultToSoftbus(const BtScanResultData *src, SoftBusBcScanResult *dst)
222 {
223 dst->eventType = BtScanEventTypeToSoftbus(src->eventType);
224 dst->dataStatus = BtScanDataStatusToSoftbus(src->dataStatus);
225 dst->addrType = BtScanAddrTypeToSoftbus(src->addrType);
226 if (memcpy_s(dst->addr.addr, SOFTBUS_ADDR_MAC_LEN, src->addr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
227 DISC_LOGW(DISC_BLE_ADAPTER, "copy addr failed");
228 }
229 dst->primaryPhy = BtScanPhyTypeToSoftbus(src->primaryPhy);
230 dst->secondaryPhy = BtScanPhyTypeToSoftbus(src->secondaryPhy);
231 dst->advSid = (uint8_t)src->advSid;
232 dst->txPower = (int8_t)src->txPower;
233 dst->rssi = (int8_t)src->rssi;
234 }
235
SoftbusFilterToBt(BleScanNativeFilter * nativeFilter,const SoftBusBcScanFilter * filter,uint8_t filterSize)236 void SoftbusFilterToBt(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize)
237 {
238 while (filterSize-- > 0) {
239 (nativeFilter + filterSize)->address = (char *)(filter + filterSize)->address;
240 (nativeFilter + filterSize)->deviceName = (char *)(filter + filterSize)->deviceName;
241 (nativeFilter + filterSize)->manufactureData = (unsigned char *)(filter + filterSize)->manufactureData;
242 (nativeFilter + filterSize)->manufactureDataLength =
243 (unsigned int)(filter + filterSize)->manufactureDataLength;
244 (nativeFilter + filterSize)->manufactureDataMask = (unsigned char *)(filter + filterSize)->manufactureDataMask;
245 (nativeFilter + filterSize)->manufactureId = (unsigned short)(filter + filterSize)->manufactureId;
246 (nativeFilter + filterSize)->advIndReport = (filter + filterSize)->advIndReport;
247
248 if ((filter + filterSize)->serviceData == NULL || (filter + filterSize)->serviceDataMask == NULL) {
249 continue;
250 }
251
252 // serviceData = uuid + serviceData, serviceDataMask = 0xFFFF + serviceDataMask
253 uint16_t serviceUuid = (filter + filterSize)->serviceUuid;
254 uint16_t serviceDataLen = (filter + filterSize)->serviceDataLength + 2;
255 uint8_t *serviceData = (uint8_t *)SoftBusCalloc(serviceDataLen);
256 if (serviceData == NULL) {
257 DISC_LOGW(DISC_BLE_ADAPTER, "malloc service data failed");
258 continue;
259 }
260 serviceData[0] = serviceUuid & BC_BYTE_MASK;
261 serviceData[1] = (serviceUuid >> BC_SHIFT_BIT) & BC_BYTE_MASK;
262 if (memcpy_s(serviceData + UUID_LEN, serviceDataLen - UUID_LEN, (filter + filterSize)->serviceData,
263 serviceDataLen - UUID_LEN) != EOK) {
264 DISC_LOGW(DISC_BLE_ADAPTER, "copy service data failed");
265 }
266 uint8_t *serviceDataMask = (uint8_t *)SoftBusCalloc(serviceDataLen);
267 if (serviceDataMask == NULL) {
268 SoftBusFree(serviceData);
269 DISC_LOGW(DISC_BLE_ADAPTER, "malloc service data mask failed");
270 continue;
271 }
272 serviceDataMask[0] = BC_BYTE_MASK;
273 serviceDataMask[1] = BC_BYTE_MASK;
274 if (memcpy_s(serviceDataMask + UUID_MASK_LEN, serviceDataLen - UUID_MASK_LEN,
275 (filter + filterSize)->serviceDataMask, serviceDataLen - UUID_MASK_LEN) != EOK) {
276 DISC_LOGW(DISC_BLE_ADAPTER, "copy service data mask failed");
277 }
278 (nativeFilter + filterSize)->serviceData = (unsigned char *)serviceData;
279 (nativeFilter + filterSize)->serviceDataLength = (unsigned int)serviceDataLen;
280 (nativeFilter + filterSize)->serviceDataMask = (unsigned char *)serviceDataMask;
281 }
282 }
283
SoftbusSetManufactureFilter(BleScanNativeFilter * nativeFilter,uint8_t filterSize)284 void SoftbusSetManufactureFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
285 {
286 while (filterSize-- > 0) {
287 uint8_t *manufactureData = (uint8_t *)SoftBusCalloc(MANUFACTURE_DATA_LEN);
288 if (manufactureData == NULL) {
289 DISC_LOGW(DISC_BLE_ADAPTER, "malloc manufacture data failed");
290 return;
291 }
292 uint8_t *manufactureMask = (uint8_t *)SoftBusCalloc(MANUFACTURE_DATA_LEN);
293 if (manufactureMask == NULL) {
294 SoftBusFree(manufactureData);
295 DISC_LOGW(DISC_BLE_ADAPTER, "malloc manufacture mask failed");
296 return;
297 }
298 (nativeFilter + filterSize)->manufactureData = manufactureData;
299 (nativeFilter + filterSize)->manufactureDataLength = MANUFACTURE_DATA_LEN;
300 (nativeFilter + filterSize)->manufactureDataMask = manufactureMask;
301 (nativeFilter + filterSize)->manufactureId = MANUFACTURE_DATA_ID;
302 }
303 }
304
FreeBtFilter(BleScanNativeFilter * nativeFilter,int32_t filterSize)305 void FreeBtFilter(BleScanNativeFilter *nativeFilter, int32_t filterSize)
306 {
307 while (filterSize-- > 0) {
308 SoftBusFree((nativeFilter + filterSize)->serviceData);
309 SoftBusFree((nativeFilter + filterSize)->serviceDataMask);
310 }
311 SoftBusFree(nativeFilter);
312 }
313
DumpBleScanFilter(BleScanNativeFilter * nativeFilter,int32_t filterSize)314 void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, int32_t filterSize)
315 {
316 while (filterSize-- > 0) {
317 bool advIndReport = (nativeFilter + filterSize)->advIndReport;
318 uint32_t len = (nativeFilter + filterSize)->serviceDataLength;
319 if (len == 0) {
320 continue;
321 }
322 uint32_t hexLen = HEXIFY_LEN(len);
323 char *serviceData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
324 if (serviceData == NULL) {
325 continue;
326 }
327 char *serviceDataMask = (char *)SoftBusCalloc(sizeof(char) * hexLen);
328 if (serviceDataMask == NULL) {
329 SoftBusFree(serviceData);
330 continue;
331 }
332 (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
333 (void)ConvertBytesToHexString(serviceDataMask, hexLen, (nativeFilter + filterSize)->serviceDataMask, len);
334 DISC_LOGD(DISC_BLE_ADAPTER,
335 "ble scan filter size=%{public}d, serviceData=%{public}s, serviceDataMask=%{public}s,"
336 "advIndReport=%{public}d", filterSize, serviceData, serviceDataMask, advIndReport);
337 SoftBusFree(serviceData);
338 SoftBusFree(serviceDataMask);
339 }
340 }
341
GetBtScanMode(uint16_t scanInterval,uint16_t scanWindow)342 int GetBtScanMode(uint16_t scanInterval, uint16_t scanWindow)
343 {
344 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2) {
345 return OHOS_BLE_SCAN_MODE_OP_P2_60_3000;
346 }
347 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2_FAST && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2_FAST) {
348 return OHOS_BLE_SCAN_MODE_OP_P2_30_1500;
349 }
350 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P10) {
351 return OHOS_BLE_SCAN_MODE_OP_P10_30_300;
352 }
353 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P25) {
354 return OHOS_BLE_SCAN_MODE_OP_P25_60_240;
355 }
356 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P50 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P50) {
357 return OHOS_BLE_SCAN_MODE_OP_P50_30_60;
358 }
359 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P75 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P75) {
360 return OHOS_BLE_SCAN_MODE_OP_P75_30_40;
361 }
362 if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P100) {
363 return OHOS_BLE_SCAN_MODE_OP_P100_1000_1000;
364 }
365 return OHOS_BLE_SCAN_MODE_LOW_POWER;
366 }
367
AssembleAdvData(const SoftbusBroadcastData * data,uint16_t * dataLen)368 uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
369 {
370 uint16_t payloadLen = (data->bcData.payloadLen > BC_DATA_MAX_LEN) ? BC_DATA_MAX_LEN : data->bcData.payloadLen;
371 uint16_t len = data->isSupportFlag ? payloadLen + BC_HEAD_LEN : payloadLen + BC_HEAD_LEN - BC_FLAG_LEN;
372 uint8_t *advData = (uint8_t *)SoftBusCalloc(len);
373 if (advData == NULL) {
374 DISC_LOGE(DISC_BLE_ADAPTER, "malloc adv data failed");
375 return NULL;
376 }
377
378 int8_t offset = -BC_FLAG_LEN;
379 if (data->isSupportFlag) {
380 advData[IDX_BC_FLAG_BYTE_LEN] = BC_FLAG_BYTE_LEN;
381 advData[IDX_BC_FLAG_AD_TYPE] = BC_FLAG_AD_TYPE;
382 advData[IDX_BC_FLAG_AD_DATA] = data->flag;
383 offset += BC_FLAG_LEN;
384 }
385
386 advData[IDX_PACKET_LEN + offset] = payloadLen + BC_HEAD_LEN - BC_FLAG_LEN - 1;
387 advData[IDX_BC_TYPE + offset] = SoftbusAdvDataTypeToBt(data->bcData.type);
388 uint16_t payloadId = data->bcData.id;
389 advData[IDX_BC_UUID + offset] = (uint8_t)(payloadId & BC_BYTE_MASK);
390 advData[IDX_BC_UUID + offset + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
391
392 if (memcpy_s(&advData[BC_HEAD_LEN + offset], payloadLen, data->bcData.payload, payloadLen) != EOK) {
393 DISC_LOGE(DISC_BLE_ADAPTER, "copy adv payload failed");
394 SoftBusFree(advData);
395 return NULL;
396 }
397 *dataLen = len;
398 return advData;
399 }
400
AssembleRspData(const SoftbusBroadcastPayload * data,uint16_t * dataLen)401 uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen)
402 {
403 uint16_t payloadLen = (data->payloadLen > RSP_DATA_MAX_LEN) ? RSP_DATA_MAX_LEN : data->payloadLen;
404 uint16_t len = payloadLen + RSP_HEAD_LEN;
405 uint8_t *rspData = (uint8_t *)SoftBusCalloc(len);
406 if (rspData == NULL) {
407 DISC_LOGE(DISC_BLE_ADAPTER, "malloc rsp data failed");
408 return NULL;
409 }
410 rspData[IDX_RSP_PACKET_LEN] = payloadLen + RSP_HEAD_LEN - 1;
411 rspData[IDX_RSP_TYPE] = SoftbusAdvDataTypeToBt(data->type);
412 uint16_t payloadId = data->id;
413 rspData[IDX_RSP_UUID] = (uint8_t)(payloadId & BC_BYTE_MASK);
414 rspData[IDX_RSP_UUID + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
415
416 if (memcpy_s(&rspData[RSP_HEAD_LEN], payloadLen, data->payload, payloadLen) != EOK) {
417 DISC_LOGE(DISC_BLE_ADAPTER, "copy rsp payload failed");
418 SoftBusFree(rspData);
419 return NULL;
420 }
421 *dataLen = len;
422 return rspData;
423 }
424
ParseFlag(const uint8_t * advData,uint8_t advLen,SoftBusBcScanResult * dst,uint8_t index)425 static int32_t ParseFlag(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst, uint8_t index)
426 {
427 if (index + 1 >= advLen) {
428 DISC_LOGW(DISC_BLE_ADAPTER, "parse flag failed");
429 return SOFTBUS_OK;
430 }
431 dst->data.flag = advData[index + 1];
432 dst->data.isSupportFlag = true;
433 return SOFTBUS_OK;
434 }
435
ParseLocalName(const uint8_t * advData,uint8_t advLen,SoftBusBcScanResult * dst,uint8_t index,uint8_t len)436 static int32_t ParseLocalName(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst, uint8_t index,
437 uint8_t len)
438 {
439 if (index + 1 >= advLen) {
440 DISC_LOGW(DISC_BLE_ADAPTER, "parse local name failed");
441 return SOFTBUS_OK;
442 }
443 if (memcpy_s(dst->localName, sizeof(dst->localName), &advData[index + 1], len - 1) != EOK) {
444 DISC_LOGE(DISC_BLE_ADAPTER, "copy local name failed");
445 return SOFTBUS_MEM_ERR;
446 }
447 return SOFTBUS_OK;
448 }
449
ParseScanResult(const uint8_t * advData,uint8_t advLen,SoftBusBcScanResult * dst)450 int32_t ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst)
451 {
452 uint8_t index = 0;
453 bool isRsp = false;
454 while (index < advLen) {
455 uint8_t len = advData[index];
456 if (len == 0) {
457 index++;
458 continue;
459 }
460 if (index + len >= advLen || index + 1 >= advLen) {
461 break;
462 }
463 uint8_t type = advData[++index];
464 if (type == BC_FLAG_AD_TYPE) {
465 DISC_CHECK_AND_RETURN_RET_LOGE(ParseFlag(advData, advLen, dst, index) == SOFTBUS_OK,
466 SOFTBUS_BC_ADAPTER_PARSE_FAIL, DISC_BLE_ADAPTER, "parse flag failed");
467 } else if (type == SHORTENED_LOCAL_NAME_BC_TYPE || type == LOCAL_NAME_BC_TYPE) {
468 DISC_CHECK_AND_RETURN_RET_LOGE(ParseLocalName(advData, advLen, dst, index, len) == SOFTBUS_OK,
469 SOFTBUS_BC_ADAPTER_PARSE_FAIL, DISC_BLE_ADAPTER, "parse local name failed");
470 } else {
471 if (type != SERVICE_BC_TYPE && type != MANUFACTURE_BC_TYPE) {
472 index += len;
473 DISC_LOGD(DISC_BLE_ADAPTER, "unsupported type, type=%{public}hhu", type);
474 continue;
475 }
476 SoftbusBroadcastPayload *data = isRsp ? &dst->data.rspData : &dst->data.bcData;
477 data->payloadLen = len - ID_LEN - 1;
478 if (data->payloadLen < 0 || index + ID_LEN >= advLen) {
479 DISC_LOGE(DISC_BLE_ADAPTER, "parse payload failed");
480 return SOFTBUS_BC_ADAPTER_PARSE_FAIL;
481 }
482 isRsp = !isRsp;
483 data->type = BtAdvTypeToSoftbus(type);
484 data->id = ((uint16_t)advData[index + ID_LEN] << BC_SHIFT_BIT) | (uint16_t)advData[index + ID_LEN - 1];
485 if (data->payloadLen == 0) {
486 index += len;
487 DISC_LOGW(DISC_BLE_ADAPTER, "parse no payload, isRsp=%{public}d", isRsp);
488 continue;
489 }
490 data->payload = (uint8_t *)SoftBusCalloc(data->payloadLen);
491 DISC_CHECK_AND_RETURN_RET_LOGE(data->payload != NULL, SOFTBUS_MALLOC_ERR, DISC_BLE_ADAPTER,
492 "malloc payload failed");
493 (void)memcpy_s(data->payload, data->payloadLen, &advData[index + ID_LEN + 1], data->payloadLen);
494 }
495 index += len;
496 }
497 return SOFTBUS_OK;
498 }
499
DumpSoftbusAdapterData(const char * description,uint8_t * data,uint16_t len)500 void DumpSoftbusAdapterData(const char *description, uint8_t *data, uint16_t len)
501 {
502 DISC_CHECK_AND_RETURN_LOGE(description != NULL, DISC_BLE_ADAPTER, "data is null!");
503 DISC_CHECK_AND_RETURN_LOGE(len != 0, DISC_BLE_ADAPTER, "len is 0!");
504 DISC_CHECK_AND_RETURN_LOGE(data != NULL, DISC_BLE_ADAPTER, "data is null!");
505
506 int32_t hexLen = HEXIFY_LEN(len);
507 char *softbusData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
508 DISC_CHECK_AND_RETURN_LOGE(softbusData != NULL, DISC_BLE_ADAPTER, "malloc failed!");
509
510 (void)ConvertBytesToHexString(softbusData, hexLen, data, len);
511 DISC_LOGI(DISC_BLE_ADAPTER, "description=%{public}s, softbusData=%{public}s", description, softbusData);
512
513 SoftBusFree(softbusData);
514 }
515