1 /*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef A2DP_CODEC_HELPERFUNCTIONS_H_
18 #define A2DP_CODEC_HELPERFUNCTIONS_H_
19
20 #include <fuzzer/FuzzedDataProvider.h>
21
22 #include <vector>
23
24 #include "stack/include/bt_hdr.h"
25
26 static const std::vector<btav_a2dp_codec_index_t> CODEC_INDEX_ENUM_VALS = {
27 BTAV_A2DP_CODEC_INDEX_SOURCE_MIN,
28 BTAV_A2DP_CODEC_INDEX_SOURCE_SBC,
29 BTAV_A2DP_CODEC_INDEX_SOURCE_AAC,
30 BTAV_A2DP_CODEC_INDEX_SOURCE_APTX,
31 BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD,
32 BTAV_A2DP_CODEC_INDEX_SOURCE_LDAC,
33 BTAV_A2DP_CODEC_INDEX_SOURCE_MAX,
34 BTAV_A2DP_CODEC_INDEX_SINK_MIN,
35 BTAV_A2DP_CODEC_INDEX_SINK_SBC,
36 BTAV_A2DP_CODEC_INDEX_SINK_AAC,
37 BTAV_A2DP_CODEC_INDEX_SINK_MAX,
38 BTAV_A2DP_CODEC_INDEX_MIN,
39 BTAV_A2DP_CODEC_INDEX_MAX};
40
41 static const std::vector<btav_a2dp_codec_priority_t> CODEC_PRIORITY_ENUM_VALS = {
42 BTAV_A2DP_CODEC_PRIORITY_DISABLED, BTAV_A2DP_CODEC_PRIORITY_DEFAULT,
43 BTAV_A2DP_CODEC_PRIORITY_HIGHEST};
44
45 static const std::vector<btav_a2dp_codec_sample_rate_t> CODEC_SAMPLERATE_ENUM_VALS = {
46 BTAV_A2DP_CODEC_SAMPLE_RATE_NONE, BTAV_A2DP_CODEC_SAMPLE_RATE_44100,
47 BTAV_A2DP_CODEC_SAMPLE_RATE_48000, BTAV_A2DP_CODEC_SAMPLE_RATE_88200,
48 BTAV_A2DP_CODEC_SAMPLE_RATE_96000, BTAV_A2DP_CODEC_SAMPLE_RATE_176400,
49 BTAV_A2DP_CODEC_SAMPLE_RATE_192000, BTAV_A2DP_CODEC_SAMPLE_RATE_16000,
50 BTAV_A2DP_CODEC_SAMPLE_RATE_24000};
51
52 static const std::vector<btav_a2dp_codec_bits_per_sample_t> CODEC_BPS_ENUM_VALS = {
53 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE, BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16,
54 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24, BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32};
55
56 static const std::vector<btav_a2dp_codec_channel_mode_t> CODEC_CHANNELMODE_ENUM_VALS = {
57 BTAV_A2DP_CODEC_CHANNEL_MODE_NONE, BTAV_A2DP_CODEC_CHANNEL_MODE_MONO,
58 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO};
59
60 // Construct a btav_a2dp_codec_index_t object
getArbitraryBtavCodecIndex(FuzzedDataProvider * fdp)61 btav_a2dp_codec_index_t getArbitraryBtavCodecIndex(FuzzedDataProvider* fdp) {
62 return CODEC_INDEX_ENUM_VALS.at(
63 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_INDEX_ENUM_VALS.size() - 1));
64 }
65
66 // Construct a btav_a2dp_codec_priority_t object
getArbitraryBtavCodecPriority(FuzzedDataProvider * fdp)67 btav_a2dp_codec_priority_t getArbitraryBtavCodecPriority(FuzzedDataProvider* fdp) {
68 return CODEC_PRIORITY_ENUM_VALS.at(
69 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_PRIORITY_ENUM_VALS.size() - 1));
70 }
71 // Construct a btav_a2dp_codec_sample_rate_t object
getArbitraryBtavCodecSampleRate(FuzzedDataProvider * fdp)72 btav_a2dp_codec_sample_rate_t getArbitraryBtavCodecSampleRate(FuzzedDataProvider* fdp) {
73 return CODEC_SAMPLERATE_ENUM_VALS.at(
74 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_SAMPLERATE_ENUM_VALS.size() - 1));
75 }
76 // Construct a btav_a2dp_codec_bits_per_sample_t object
getArbitraryBtavCodecBitsPerSample(FuzzedDataProvider * fdp)77 btav_a2dp_codec_bits_per_sample_t getArbitraryBtavCodecBitsPerSample(FuzzedDataProvider* fdp) {
78 return CODEC_BPS_ENUM_VALS.at(
79 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_BPS_ENUM_VALS.size() - 1));
80 }
81 // Construct a btav_a2dp_codec_channel_mode_t object
getArbitraryBtavCodecChannelMode(FuzzedDataProvider * fdp)82 btav_a2dp_codec_channel_mode_t getArbitraryBtavCodecChannelMode(FuzzedDataProvider* fdp) {
83 return CODEC_CHANNELMODE_ENUM_VALS.at(
84 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_CHANNELMODE_ENUM_VALS.size() - 1));
85 }
86 // Construct a btav_a2dp_codec_config_t object
getArbitraryBtavCodecConfig(FuzzedDataProvider * fdp)87 btav_a2dp_codec_config_t getArbitraryBtavCodecConfig(FuzzedDataProvider* fdp) {
88 btav_a2dp_codec_config_t config;
89
90 config.codec_type = getArbitraryBtavCodecIndex(fdp);
91 config.codec_priority = getArbitraryBtavCodecPriority(fdp);
92 config.sample_rate = getArbitraryBtavCodecSampleRate(fdp);
93 config.bits_per_sample = getArbitraryBtavCodecBitsPerSample(fdp);
94 config.channel_mode = getArbitraryBtavCodecChannelMode(fdp);
95 config.codec_specific_1 = fdp->ConsumeIntegral<int64_t>();
96 config.codec_specific_2 = fdp->ConsumeIntegral<int64_t>();
97 config.codec_specific_3 = fdp->ConsumeIntegral<int64_t>();
98 config.codec_specific_4 = fdp->ConsumeIntegral<int64_t>();
99
100 return config;
101 }
102
getArbitraryA2dpEncoderInitPeerParams(FuzzedDataProvider * fdp)103 tA2DP_ENCODER_INIT_PEER_PARAMS getArbitraryA2dpEncoderInitPeerParams(FuzzedDataProvider* fdp) {
104 tA2DP_ENCODER_INIT_PEER_PARAMS params;
105
106 params.is_peer_edr = fdp->ConsumeBool();
107 params.peer_supports_3mbps = fdp->ConsumeBool();
108 params.peer_mtu = fdp->ConsumeIntegral<uint16_t>();
109
110 return params;
111 }
112
113 #define MAX_BTHDR_SIZE 1024
getArbitraryBtHdr(FuzzedDataProvider * fdp)114 std::shared_ptr<BT_HDR> getArbitraryBtHdr(FuzzedDataProvider* fdp) {
115 // Build a data buffer
116 size_t buf_size = fdp->ConsumeIntegralInRange<size_t>(0, MAX_BTHDR_SIZE);
117 std::vector<uint8_t> bytes = fdp->ConsumeBytes<uint8_t>(buf_size);
118
119 if (bytes.empty()) {
120 return nullptr;
121 }
122
123 uint16_t hdr_size = bytes.size() + sizeof(BT_HDR);
124 std::shared_ptr<BT_HDR> bt_hdr(reinterpret_cast<BT_HDR*>(calloc(1, hdr_size)), free);
125
126 bt_hdr->event = fdp->ConsumeIntegral<uint16_t>();
127 bt_hdr->len = bytes.size();
128 bt_hdr->offset = fdp->ConsumeIntegralInRange<uint16_t>(0, hdr_size - sizeof(BT_HDR));
129 bt_hdr->layer_specific = fdp->ConsumeIntegral<uint16_t>();
130 std::copy(bytes.begin(), bytes.end(), bt_hdr->data);
131
132 return bt_hdr;
133 }
134
135 #include "bta/av/bta_av_int.h"
generateArbitrarytA2dpOffload(FuzzedDataProvider * fdp)136 tBT_A2DP_OFFLOAD generateArbitrarytA2dpOffload(FuzzedDataProvider* fdp) {
137 tBT_A2DP_OFFLOAD retval;
138
139 retval.codec_type = fdp->ConsumeIntegral<uint32_t>();
140 retval.max_latency = fdp->ConsumeIntegral<uint16_t>();
141 std::vector<uint8_t> scms_t_enable = fdp->ConsumeBytes<uint8_t>(2);
142 memcpy(&retval.scms_t_enable[0], scms_t_enable.data(), scms_t_enable.size());
143 retval.sample_rate = fdp->ConsumeIntegral<uint32_t>();
144 retval.bits_per_sample = fdp->ConsumeIntegral<uint8_t>();
145 retval.ch_mode = fdp->ConsumeIntegral<uint8_t>();
146 retval.encoded_audio_bitrate = fdp->ConsumeIntegral<uint32_t>();
147 retval.acl_hdl = fdp->ConsumeIntegral<uint16_t>();
148 retval.l2c_rcid = fdp->ConsumeIntegral<uint16_t>();
149 retval.mtu = fdp->ConsumeIntegral<uint16_t>();
150
151 std::vector<uint8_t> codec_info_bytes = fdp->ConsumeBytes<uint8_t>(32);
152 memcpy(&retval.codec_info[0], codec_info_bytes.data(), codec_info_bytes.size());
153
154 return retval;
155 }
156
157 #endif // A2DP_CODEC_HELPERFUNCTIONS_H_
158