1 /*
2 * Copyright (c) 2024-2025 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 "audio_log.h"
17 #include "audio_zone.h"
18 #include "audio_zone_client_manager.h"
19 #include "audio_zone_service.h"
20
21 using namespace std;
22
23 namespace OHOS {
24 namespace AudioStandard {
25
26 static const uint8_t* RAW_DATA = nullptr;
27 static size_t g_dataSize = 0;
28 static size_t g_pos;
29 static size_t NUM_2 = 2;
30 const size_t THRESHOLD = 10;
31 typedef void (*TestPtr)();
32
33 template<class T>
GetArrLength(T & arr)34 uint32_t GetArrLength(T& arr)
35 {
36 if (arr == nullptr) {
37 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
38 return 0;
39 }
40 return sizeof(arr) / sizeof(arr[0]);
41 }
42
43 template<class T>
GetData()44 T GetData()
45 {
46 T object {};
47 size_t objectSize = sizeof(object);
48 if (g_dataSize < g_pos) {
49 return object;
50 }
51 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
52 return object;
53 }
54 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
55 if (ret != EOK) {
56 return {};
57 }
58 g_pos += objectSize;
59 return object;
60 }
61
AudioZoneBindKeyAudioZoneBindKeyFuzzTest()62 void AudioZoneBindKeyAudioZoneBindKeyFuzzTest()
63 {
64 std::string deviceTag = "testDeviceTag";
65 std::string streamTag = "testStreamTag";
66 int32_t uid = GetData<int32_t>();
67 AudioZoneBindKey audioZoneBindKey_1(uid);
68 AudioZoneBindKey audioZoneBindKey_2(uid, deviceTag);
69 AudioZoneBindKey audioZoneBindKey_3(uid, deviceTag, streamTag);
70 AudioZoneBindKey audioZoneBindKey_4(audioZoneBindKey_1);
71 AudioZoneBindKey audioZoneBindKey_5(std::move(audioZoneBindKey_1));
72 }
73
AudioZoneBindKeyOperatorFuzzTest()74 void AudioZoneBindKeyOperatorFuzzTest()
75 {
76 std::string deviceTag = "testDeviceTag";
77 std::string streamTag = "testStreamTag";
78 int32_t uid = GetData<int32_t>();
79 AudioZoneBindKey audioZoneBindKey_1(uid, deviceTag, streamTag);
80 AudioZoneBindKey audioZoneBindKey_2 = audioZoneBindKey_1;
81 }
82
AudioZoneBindKeyGetUidFuzzTest()83 void AudioZoneBindKeyGetUidFuzzTest()
84 {
85 int32_t uid = GetData<int32_t>();
86 AudioZoneBindKey audioZoneBindKey(uid);
87 audioZoneBindKey.GetUid();
88 }
89
AudioZoneBindKeyGetStringFuzzTest()90 void AudioZoneBindKeyGetStringFuzzTest()
91 {
92 int32_t uid = GetData<int32_t>();
93 AudioZoneBindKey audioZoneBindKey(uid);
94 audioZoneBindKey.GetString();
95 }
96
AudioZoneBindKeyIsContainFuzzTest()97 void AudioZoneBindKeyIsContainFuzzTest()
98 {
99 int32_t uid = GetData<int32_t>();
100 AudioZoneBindKey audioZoneBindKey(uid);
101 AudioZoneBindKey audioZoneBindKey1(uid);
102 audioZoneBindKey.IsContain(audioZoneBindKey1);
103 }
104
AudioZoneBindKeyGetSupportKeysFuzzTest()105 void AudioZoneBindKeyGetSupportKeysFuzzTest()
106 {
107 std::string deviceTag = "testDeviceTag";
108 std::string streamTag = "testStreamTag";
109 int32_t uid = GetData<int32_t>();
110 StreamUsage usage = static_cast<StreamUsage>
111 (GetData<int32_t>() % StreamUsage::STREAM_USAGE_MAX);
112 AudioZoneBindKey audioZoneBindKey(uid, deviceTag, streamTag);
113 AudioZoneBindKey audioZoneBindKey_1(uid, deviceTag, streamTag);
114 audioZoneBindKey.GetSupportKeys(audioZoneBindKey_1);
115 audioZoneBindKey.GetSupportKeys(uid, deviceTag, streamTag, usage);
116 }
117
AudioZoneGetDescriptorFuzzTest()118 void AudioZoneGetDescriptorFuzzTest()
119 {
120 std::string name = "testAudioZone";
121 AudioZoneContext context;
122 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
123 std::shared_ptr<AudioZone> zone =
124 std::make_shared<AudioZone>(zoneClientManager, name, context);
125 zone->GetDescriptor();
126 }
127
AudioZoneGetStringDescriptorFuzzTest()128 void AudioZoneGetStringDescriptorFuzzTest()
129 {
130 std::string name = "testAudioZone";
131 AudioZoneContext context;
132 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
133 std::shared_ptr<AudioZone> zone =
134 std::make_shared<AudioZone>(zoneClientManager, name, context);
135 zone->GetStringDescriptor();
136 }
137
AudioZoneGetDescriptorNoLockFuzzTest()138 void AudioZoneGetDescriptorNoLockFuzzTest()
139 {
140 std::string name = "testAudioZone";
141 AudioZoneContext context;
142 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
143 std::shared_ptr<AudioZone> zone =
144 std::make_shared<AudioZone>(zoneClientManager, name, context);
145 zone->GetDescriptorNoLock();
146 }
147
AudioZoneBindByKeyFuzzTest()148 void AudioZoneBindByKeyFuzzTest()
149 {
150 std::string name = "testAudioZone";
151 AudioZoneContext context;
152 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
153 std::shared_ptr<AudioZone> zone =
154 std::make_shared<AudioZone>(zoneClientManager, name, context);
155 int32_t uid = GetData<int32_t>();
156 AudioZoneBindKey audioZoneBindKey(uid);
157 zone->BindByKey(audioZoneBindKey);
158 }
159
AudioZoneRemoveKeyFuzzTest()160 void AudioZoneRemoveKeyFuzzTest()
161 {
162 std::string name = "testAudioZone";
163 AudioZoneContext context;
164 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
165 std::shared_ptr<AudioZone> zone =
166 std::make_shared<AudioZone>(zoneClientManager, name, context);
167 int32_t uid = GetData<int32_t>();
168 AudioZoneBindKey audioZoneBindKey(uid);
169 zone->RemoveKey(audioZoneBindKey);
170 }
171
AudioZoneIsContainKeyFuzzTest()172 void AudioZoneIsContainKeyFuzzTest()
173 {
174 std::string name = "testAudioZone";
175 AudioZoneContext context;
176 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
177 std::shared_ptr<AudioZone> zone =
178 std::make_shared<AudioZone>(zoneClientManager, name, context);
179 int32_t uid = GetData<int32_t>();
180 AudioZoneBindKey audioZoneBindKey(uid);
181 zone->IsContainKey(audioZoneBindKey);
182 }
183
AudioZoneRemoveDeviceDescriptorFuzzTest()184 void AudioZoneRemoveDeviceDescriptorFuzzTest()
185 {
186 std::string name = "testAudioZone";
187 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
188 auto device = std::make_shared<AudioDeviceDescriptor>();
189 devices.push_back(device);
190 AudioZoneContext context;
191 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
192 std::shared_ptr<AudioZone> zone =
193 std::make_shared<AudioZone>(zoneClientManager, name, context);
194 zone->RemoveDeviceDescriptor(devices);
195 }
196
AudioZoneAddDeviceDescriptorFuzzTest()197 void AudioZoneAddDeviceDescriptorFuzzTest()
198 {
199 std::string name = "testAudioZone";
200 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
201 auto device = std::make_shared<AudioDeviceDescriptor>();
202 devices.push_back(device);
203 AudioZoneContext context;
204 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
205 std::shared_ptr<AudioZone> zone =
206 std::make_shared<AudioZone>(zoneClientManager, name, context);
207 zone->AddDeviceDescriptor(devices);
208 }
209
AudioZoneUpdateDeviceDescriptorFuzzTest()210 void AudioZoneUpdateDeviceDescriptorFuzzTest()
211 {
212 std::string name = "testAudioZone";
213 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
214 auto device = std::make_shared<AudioDeviceDescriptor>();
215 devices.push_back(device);
216 AudioZoneContext context;
217 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
218 std::shared_ptr<AudioZone> zone =
219 std::make_shared<AudioZone>(zoneClientManager, name, context);
220 zone->AddDeviceDescriptor(devices);
221 zone->UpdateDeviceDescriptor(device);
222 }
223
AudioZoneEnableDeviceDescriptorFuzzTest()224 void AudioZoneEnableDeviceDescriptorFuzzTest()
225 {
226 std::string name = "testAudioZone";
227 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
228 auto device = std::make_shared<AudioDeviceDescriptor>();
229 devices.push_back(device);
230 AudioZoneContext context;
231 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
232 std::shared_ptr<AudioZone> zone =
233 std::make_shared<AudioZone>(zoneClientManager, name, context);
234 zone->AddDeviceDescriptor(devices);
235 zone->EnableDeviceDescriptor(device);
236 }
237
AudioZoneDisableDeviceDescriptorFuzzTest()238 void AudioZoneDisableDeviceDescriptorFuzzTest()
239 {
240 std::string name = "testAudioZone";
241 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
242 auto device = std::make_shared<AudioDeviceDescriptor>();
243 devices.push_back(device);
244 AudioZoneContext context;
245 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
246 std::shared_ptr<AudioZone> zone =
247 std::make_shared<AudioZone>(zoneClientManager, name, context);
248 zone->AddDeviceDescriptor(devices);
249 zone->DisableDeviceDescriptor(device);
250 }
251
AudioZoneIsDeviceConnectFuzzTest()252 void AudioZoneIsDeviceConnectFuzzTest()
253 {
254 std::string name = "testAudioZone";
255 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
256 auto device = std::make_shared<AudioDeviceDescriptor>();
257 devices.push_back(device);
258 AudioZoneContext context;
259 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
260 std::shared_ptr<AudioZone> zone =
261 std::make_shared<AudioZone>(zoneClientManager, name, context);
262 zone->AddDeviceDescriptor(devices);
263 zone->IsDeviceConnect(device);
264 }
265
AudioZoneFetchOutputDevicesFuzzTest()266 void AudioZoneFetchOutputDevicesFuzzTest()
267 {
268 std::string name = "testAudioZone";
269 StreamUsage streamUsage =
270 static_cast<StreamUsage>(GetData<int32_t>() % StreamUsage::STREAM_USAGE_MAX);
271 int32_t clientUid = GetData<int32_t>();
272 RouterType bypassType = GetData<RouterType>();
273 AudioZoneContext context;
274 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
275 std::shared_ptr<AudioZone> zone =
276 std::make_shared<AudioZone>(zoneClientManager, name, context);
277 zone->FetchOutputDevices(streamUsage, clientUid, bypassType);
278 }
279
AudioZoneFetchInputDeviceFuzzTest()280 void AudioZoneFetchInputDeviceFuzzTest()
281 {
282 std::string name = "testAudioZone";
283 SourceType sourceType =
284 static_cast<SourceType>(GetData<int32_t>() % SourceType::SOURCE_TYPE_MAX);
285 int32_t clientUid = GetData<int32_t>();
286 AudioZoneContext context;
287 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
288 std::shared_ptr<AudioZone> zone =
289 std::make_shared<AudioZone>(zoneClientManager, name, context);
290 zone->FetchInputDevice(sourceType, clientUid);
291 }
292
AudioZoneEnableChangeReportFuzzTest()293 void AudioZoneEnableChangeReportFuzzTest()
294 {
295 std::string name = "testAudioZone";
296 bool enable = static_cast<bool>(GetData<int32_t>() % NUM_2);
297 pid_t clientPid = GetData<pid_t>();
298 AudioZoneContext context;
299 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
300 std::shared_ptr<AudioZone> zone =
301 std::make_shared<AudioZone>(zoneClientManager, name, context);
302 zone->EnableChangeReport(clientPid, enable);
303 }
304
AudioZoneEnableSystemVolumeProxyFuzzTest()305 void AudioZoneEnableSystemVolumeProxyFuzzTest()
306 {
307 std::string name = "testAudioZone";
308 bool enable = static_cast<bool>(GetData<int32_t>() %NUM_2);
309 pid_t clientPid = GetData<pid_t>();
310 AudioZoneContext context;
311 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
312 std::shared_ptr<AudioZone> zone =
313 std::make_shared<AudioZone>(zoneClientManager, name, context);
314 zone->EnableSystemVolumeProxy(clientPid, enable);
315 }
316
AudioZoneSetSystemVolumeLevelFuzzTest()317 void AudioZoneSetSystemVolumeLevelFuzzTest()
318 {
319 std::string name = "testAudioZone";
320 AudioVolumeType volumeProxyClientPid = GetData<AudioVolumeType>();
321 int32_t volumeLevel = GetData<int32_t>();
322 int32_t volumeFlag = GetData<int32_t>();
323 AudioZoneContext context;
324 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
325 std::shared_ptr<AudioZone> zone =
326 std::make_shared<AudioZone>(zoneClientManager, name, context);
327 zone->SetSystemVolumeLevel(volumeProxyClientPid, volumeLevel, volumeFlag);
328 }
329
AudioZoneGetSystemVolumeLevelFuzzTest()330 void AudioZoneGetSystemVolumeLevelFuzzTest()
331 {
332 std::string name = "testAudioZone";
333 AudioVolumeType volumeProxyClientPid = GetData<AudioVolumeType>();
334 AudioZoneContext context;
335 std::shared_ptr<AudioZoneClientManager> zoneClientManager;
336 std::shared_ptr<AudioZone> zone =
337 std::make_shared<AudioZone>(zoneClientManager, name, context);
338 zone->GetSystemVolumeLevel(volumeProxyClientPid);
339 }
340
341 TestPtr g_testPtrs[] = {
342 AudioZoneBindKeyAudioZoneBindKeyFuzzTest,
343 AudioZoneBindKeyOperatorFuzzTest,
344 AudioZoneBindKeyGetUidFuzzTest,
345 AudioZoneBindKeyGetStringFuzzTest,
346 AudioZoneBindKeyIsContainFuzzTest,
347 AudioZoneBindKeyGetSupportKeysFuzzTest,
348 AudioZoneGetDescriptorFuzzTest,
349 AudioZoneGetStringDescriptorFuzzTest,
350 AudioZoneGetDescriptorNoLockFuzzTest,
351 AudioZoneBindByKeyFuzzTest,
352 AudioZoneRemoveKeyFuzzTest,
353 AudioZoneIsContainKeyFuzzTest,
354 AudioZoneRemoveDeviceDescriptorFuzzTest,
355 AudioZoneAddDeviceDescriptorFuzzTest,
356 AudioZoneEnableDeviceDescriptorFuzzTest,
357 AudioZoneDisableDeviceDescriptorFuzzTest,
358 AudioZoneIsDeviceConnectFuzzTest,
359 AudioZoneFetchOutputDevicesFuzzTest,
360 AudioZoneFetchInputDeviceFuzzTest,
361 AudioZoneEnableChangeReportFuzzTest,
362 AudioZoneEnableSystemVolumeProxyFuzzTest,
363 AudioZoneSetSystemVolumeLevelFuzzTest,
364 AudioZoneGetSystemVolumeLevelFuzzTest,
365 };
366
FuzzTest(const uint8_t * rawData,size_t size)367 void FuzzTest(const uint8_t* rawData, size_t size)
368 {
369 if (rawData == nullptr) {
370 return;
371 }
372
373 RAW_DATA = rawData;
374 g_dataSize = size;
375 g_pos = 0;
376
377 uint32_t code = GetData<uint32_t>();
378 uint32_t len = GetArrLength(g_testPtrs);
379 if (len > 0) {
380 g_testPtrs[code % len]();
381 } else {
382 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
383 }
384 return;
385 }
386
387 } // namespace AudioStandard
388 } // namesapce OHOS
389
390 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)391 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
392 {
393 if (size < OHOS::AudioStandard::THRESHOLD) {
394 return 0;
395 }
396 OHOS::AudioStandard::FuzzTest(data, size);
397 return 0;
398 }