1 /*
2  * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #ifndef LOG_TAG
16 #define LOG_TAG "bt_ipc_parcel_ble_advertiser"
17 #endif
18 
19 #include "bluetooth_ble_advertiser_data.h"
20 #include "bluetooth_log.h"
21 #include "bt_uuid.h"
22 
23 using OHOS::bluetooth::Uuid;
24 namespace OHOS {
25 namespace Bluetooth {
26 const int32_t BLE_ADV__SERVICE_READ_DATA_SIZE_MAX_LEN = 0x400;
Marshalling(Parcel & parcel) const27 bool BluetoothBleAdvertiserData::Marshalling(Parcel &parcel) const
28 {
29     if (!WriteServiceUuids(parcel)) {
30         return false;
31     }
32     if (!WriteManufacturerData(parcel)) {
33         return false;
34     }
35     if (!WriteServiceData(parcel)) {
36         return false;
37     }
38     if (!parcel.WriteUint8(advFlag_)) {
39         return false;
40     }
41     if (!parcel.WriteString(payload_)) {
42         return false;
43     }
44     if (!parcel.WriteBool(includeDeviceName_)) {
45         return false;
46     }
47     if (!parcel.WriteBool(includeTxPower_)) {
48         return false;
49     }
50     return true;
51 }
52 
WriteToParcel(Parcel & parcel)53 bool BluetoothBleAdvertiserData::WriteToParcel(Parcel &parcel)
54 {
55     return Marshalling(parcel);
56 }
57 
Unmarshalling(Parcel & parcel)58 BluetoothBleAdvertiserData *BluetoothBleAdvertiserData::Unmarshalling(Parcel &parcel)
59 {
60     BluetoothBleAdvertiserData *advertiserData = new BluetoothBleAdvertiserData();
61     if (advertiserData != nullptr && !advertiserData->ReadFromParcel(parcel)) {
62         delete advertiserData;
63         advertiserData = nullptr;
64     }
65     return advertiserData;
66 }
67 
ReadFromParcel(Parcel & parcel)68 bool BluetoothBleAdvertiserData::ReadFromParcel(Parcel &parcel)
69 {
70     if (!ReadServiceUuids(serviceUuids_, parcel)) {
71         return false;
72     }
73     if (!ReadManufacturerData(manufacturerSpecificData_, parcel)) {
74         return false;
75     }
76     if (!ReadServiceData(serviceData_, parcel)) {
77         return false;
78     }
79     if (!parcel.ReadUint8(advFlag_)) {
80         return false;
81     }
82     if (!parcel.ReadString(payload_)) {
83         return false;
84     }
85     if (!parcel.ReadBool(includeDeviceName_)) {
86         return false;
87     }
88     if (!parcel.ReadBool(includeTxPower_)) {
89         return false;
90     }
91     return true;
92 }
93 
WriteServiceUuids(Parcel & parcel) const94 bool BluetoothBleAdvertiserData::WriteServiceUuids(Parcel &parcel) const
95 {
96     if (!parcel.WriteInt32(serviceUuids_.size())) {
97         return false;
98     }
99     for (auto &serviceUuids : serviceUuids_) {
100         uint8_t buffer[Uuid::UUID128_BYTES_TYPE] = {0};
101         if (!serviceUuids.ConvertToBytesLE(buffer, Uuid::UUID128_BYTES_TYPE)) {
102             return false;
103         }
104         if (!parcel.WriteBuffer(static_cast<void *>(buffer), Uuid::UUID128_BYTES_TYPE)) {
105             return false;
106         }
107     }
108     return true;
109 }
110 
ReadServiceUuids(std::vector<Uuid> & serviceUuids,Parcel & parcel)111 bool BluetoothBleAdvertiserData::ReadServiceUuids(std::vector<Uuid> &serviceUuids, Parcel &parcel)
112 {
113     int32_t serviceUuidSize = 0;
114     if (!parcel.ReadInt32(serviceUuidSize) || serviceUuidSize > BLE_ADV__SERVICE_READ_DATA_SIZE_MAX_LEN) {
115         HILOGE("read Parcelable size failed.");
116         return false;
117     }
118     for (int i = 0; i < serviceUuidSize; ++i) {
119         const uint8_t *buffer = parcel.ReadBuffer(static_cast<size_t>(Uuid::UUID128_BYTES_TYPE));
120         if (buffer == nullptr) {
121             HILOGE("ReadBuffer failed");
122             return false;
123         }
124         Uuid uuid = Uuid::ConvertFromBytesLE(buffer, static_cast<size_t>(Uuid::UUID128_BYTES_TYPE));
125         serviceUuids.push_back(uuid);
126     }
127     return true;
128 }
129 
WriteManufacturerData(Parcel & parcel) const130 bool BluetoothBleAdvertiserData::WriteManufacturerData(Parcel &parcel) const
131 {
132     if (!parcel.WriteInt32(manufacturerSpecificData_.size())) {
133         return false;
134     }
135     for (auto &manufacturer : manufacturerSpecificData_) {
136         if (!parcel.WriteUint16(manufacturer.first)) {
137             return false;
138         }
139         if (!parcel.WriteString(manufacturer.second)) {
140             return false;
141         }
142     }
143     return true;
144 }
145 
ReadManufacturerData(std::map<uint16_t,std::string> & manufacturerData,Parcel & parcel)146 bool BluetoothBleAdvertiserData::ReadManufacturerData(std::map<uint16_t, std::string> &manufacturerData, Parcel &parcel)
147 {
148     int manufacturerSize = 0;
149     if (!parcel.ReadInt32(manufacturerSize) || manufacturerSize > BLE_ADV__SERVICE_READ_DATA_SIZE_MAX_LEN) {
150         HILOGE("read Parcelable size failed.");
151         return false;
152     }
153     uint16_t manufacturerId;
154     std::string manufacturerDataValue;
155     for (int i = 0; i < manufacturerSize; ++i) {
156         if (!parcel.ReadUint16(manufacturerId)) {
157             return false;
158         }
159         if (!parcel.ReadString(manufacturerDataValue)) {
160             return false;
161         }
162         manufacturerData.emplace(manufacturerId, manufacturerDataValue);
163     }
164     return true;
165 }
166 
WriteServiceData(Parcel & parcel) const167 bool BluetoothBleAdvertiserData::WriteServiceData(Parcel &parcel) const
168 {
169     if (!parcel.WriteInt32(serviceData_.size())) {
170         return false;
171     }
172     for (auto &service : serviceData_) {
173         if (!parcel.WriteUint32(service.first.ConvertTo32Bits())) {
174             return false;
175         }
176         if (!parcel.WriteString(service.second)) {
177             return false;
178         }
179     }
180     return true;
181 }
182 
ReadServiceData(std::map<Uuid,std::string> & serviceData,Parcel & parcel)183 bool BluetoothBleAdvertiserData::ReadServiceData(std::map<Uuid, std::string> &serviceData, Parcel &parcel)
184 {
185     int serviceDataSize = 0;
186     if (!parcel.ReadInt32(serviceDataSize) || serviceDataSize > BLE_ADV__SERVICE_READ_DATA_SIZE_MAX_LEN) {
187         HILOGE("read Parcelable size failed.");
188         return false;
189     }
190     Uuid serviceDataId;
191     std::string serviceDataData;
192     for (int i = 0; i < serviceDataSize; ++i) {
193         uint32_t uuid;
194         if (parcel.ReadUint32(uuid)) {
195             serviceDataId = Uuid::ConvertFrom32Bits(uuid);
196         } else {
197             return false;
198         }
199         if (!parcel.ReadString(serviceDataData)) {
200             return false;
201         }
202         serviceData.emplace(serviceDataId, serviceDataData);
203     }
204     return true;
205 }
206 }  // namespace Bluetooth
207 }  // namespace OHOS
208