1 /*
2 * Copyright (c) 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 <iostream>
17 #include <cstddef>
18 #include <cstdint>
19 #include <cstring>
20 #include "audio_info.h"
21 #include "audio_policy_server.h"
22 #include "audio_policy_service.h"
23 #include "audio_device_info.h"
24 #include "audio_utils.h"
25 #include "accesstoken_kit.h"
26 #include "nativetoken_kit.h"
27 #include "token_setproc.h"
28 #include "access_token.h"
29 #include "audio_channel_blend.h"
30 #include "volume_ramp.h"
31 #include "audio_speed.h"
32
33 #include "audio_policy_utils.h"
34 #include "audio_stream_descriptor.h"
35 #include "audio_limiter_manager.h"
36 #include "dfx_msg_manager.h"
37 #include "hpae_manager.h"
38 #include "audio_info.h"
39 #include "device_status_listener.h"
40 #include "audio_policy_service.h"
41
42 namespace OHOS {
43 namespace AudioStandard {
44 using namespace std;
45
46 static const uint8_t* RAW_DATA = nullptr;
47 static size_t g_dataSize = 0;
48 static size_t g_pos;
49 const size_t THRESHOLD = 10;
50 const uint8_t TESTSIZE = 19;
51
52 typedef void (*TestFuncs)();
53
54 vector<AudioDeviceUsage> AudioDeviceUsageVec = {
55 MEDIA_OUTPUT_DEVICES,
56 MEDIA_INPUT_DEVICES,
57 ALL_MEDIA_DEVICES,
58 CALL_OUTPUT_DEVICES,
59 CALL_INPUT_DEVICES,
60 ALL_CALL_DEVICES,
61 D_ALL_DEVICES,
62 };
63
64 const vector<DeviceType> g_testDeviceTypes = {
65 DEVICE_TYPE_NONE,
66 DEVICE_TYPE_INVALID,
67 DEVICE_TYPE_EARPIECE,
68 DEVICE_TYPE_SPEAKER,
69 DEVICE_TYPE_WIRED_HEADSET,
70 DEVICE_TYPE_WIRED_HEADPHONES,
71 DEVICE_TYPE_BLUETOOTH_SCO,
72 DEVICE_TYPE_BLUETOOTH_A2DP,
73 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
74 DEVICE_TYPE_MIC,
75 DEVICE_TYPE_WAKEUP,
76 DEVICE_TYPE_USB_HEADSET,
77 DEVICE_TYPE_DP,
78 DEVICE_TYPE_REMOTE_CAST,
79 DEVICE_TYPE_USB_DEVICE,
80 DEVICE_TYPE_ACCESSORY,
81 DEVICE_TYPE_REMOTE_DAUDIO,
82 DEVICE_TYPE_HDMI,
83 DEVICE_TYPE_LINE_DIGITAL,
84 DEVICE_TYPE_NEARLINK,
85 DEVICE_TYPE_NEARLINK_IN,
86 DEVICE_TYPE_FILE_SINK,
87 DEVICE_TYPE_FILE_SOURCE,
88 DEVICE_TYPE_EXTERN_CABLE,
89 DEVICE_TYPE_DEFAULT,
90 DEVICE_TYPE_USB_ARM_HEADSET,
91 DEVICE_TYPE_MAX
92 };
93
94 const vector<StreamUsage> g_testStreamUsages = {
95 STREAM_USAGE_INVALID,
96 STREAM_USAGE_UNKNOWN,
97 STREAM_USAGE_MEDIA,
98 STREAM_USAGE_MUSIC,
99 STREAM_USAGE_VOICE_COMMUNICATION,
100 STREAM_USAGE_VOICE_ASSISTANT,
101 STREAM_USAGE_ALARM,
102 STREAM_USAGE_VOICE_MESSAGE,
103 STREAM_USAGE_NOTIFICATION_RINGTONE,
104 STREAM_USAGE_RINGTONE,
105 STREAM_USAGE_NOTIFICATION,
106 STREAM_USAGE_ACCESSIBILITY,
107 STREAM_USAGE_SYSTEM,
108 STREAM_USAGE_MOVIE,
109 STREAM_USAGE_GAME,
110 STREAM_USAGE_AUDIOBOOK,
111 STREAM_USAGE_NAVIGATION,
112 STREAM_USAGE_DTMF,
113 STREAM_USAGE_ENFORCED_TONE,
114 STREAM_USAGE_ULTRASONIC,
115 STREAM_USAGE_VIDEO_COMMUNICATION,
116 STREAM_USAGE_RANGING,
117 STREAM_USAGE_VOICE_MODEM_COMMUNICATION,
118 STREAM_USAGE_VOICE_RINGTONE,
119 STREAM_USAGE_VOICE_CALL_ASSISTANT,
120 STREAM_USAGE_MAX,
121 };
122
123 const vector<SourceType> g_testSourceTypes = {
124 SOURCE_TYPE_INVALID,
125 SOURCE_TYPE_MIC,
126 SOURCE_TYPE_VOICE_RECOGNITION,
127 SOURCE_TYPE_PLAYBACK_CAPTURE,
128 SOURCE_TYPE_WAKEUP,
129 SOURCE_TYPE_VOICE_CALL,
130 SOURCE_TYPE_VOICE_COMMUNICATION,
131 SOURCE_TYPE_ULTRASONIC,
132 SOURCE_TYPE_VIRTUAL_CAPTURE,
133 SOURCE_TYPE_VOICE_MESSAGE,
134 SOURCE_TYPE_REMOTE_CAST,
135 SOURCE_TYPE_VOICE_TRANSCRIPTION,
136 SOURCE_TYPE_CAMCORDER,
137 SOURCE_TYPE_UNPROCESSED,
138 SOURCE_TYPE_EC,
139 SOURCE_TYPE_MIC_REF,
140 SOURCE_TYPE_LIVE,
141 SOURCE_TYPE_MAX,
142 };
143
144 const vector<AudioScene> g_testAudioScenes = {
145 AUDIO_SCENE_INVALID,
146 AUDIO_SCENE_DEFAULT,
147 AUDIO_SCENE_RINGING,
148 AUDIO_SCENE_PHONE_CALL,
149 AUDIO_SCENE_PHONE_CHAT,
150 AUDIO_SCENE_CALL_START,
151 AUDIO_SCENE_CALL_END,
152 AUDIO_SCENE_VOICE_RINGING,
153 AUDIO_SCENE_MAX,
154 };
155
156 template<class T>
GetData()157 T GetData()
158 {
159 T object {};
160 size_t objectSize = sizeof(object);
161 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
162 return object;
163 }
164 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
165 if (ret != EOK) {
166 return {};
167 }
168 g_pos += objectSize;
169 return object;
170 }
171
172 template<class T>
GetArrLength(T & arr)173 uint32_t GetArrLength(T& arr)
174 {
175 if (arr == nullptr) {
176 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
177 return 0;
178 }
179 return sizeof(arr) / sizeof(arr[0]);
180 }
181
RecoveryPreferredDevicesFuzzTest()182 void RecoveryPreferredDevicesFuzzTest()
183 {
184 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
185 audioRecoveryDevice->RecoveryPreferredDevices();
186 }
187
RecoverExcludedOutputDevicesFuzzTest()188 void RecoverExcludedOutputDevicesFuzzTest()
189 {
190 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
191 audioRecoveryDevice->RecoverExcludedOutputDevices();
192 }
193
HandleExcludedOutputDevicesRecoveryFuzzTest()194 void HandleExcludedOutputDevicesRecoveryFuzzTest()
195 {
196 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
197 std::vector<std::shared_ptr<Media::MediaMonitor::MonitorDeviceInfo>> excludedDevices;
198 auto mediaMonitor = std::make_shared<Media::MediaMonitor::MonitorDeviceInfo>();
199 excludedDevices.push_back(mediaMonitor);
200 uint32_t audioDevUsageCount = GetData<uint32_t>() % AudioDeviceUsageVec.size();
201 AudioDeviceUsage audioDevUsage = AudioDeviceUsageVec[audioDevUsageCount];
202 audioRecoveryDevice->HandleExcludedOutputDevicesRecovery(audioDevUsage, excludedDevices);
203 }
204
AudioRecoveryDeviceHandleRecoveryPreferredDevicesFuzzTest()205 void AudioRecoveryDeviceHandleRecoveryPreferredDevicesFuzzTest()
206 {
207 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
208 if (audioRecoveryDevice == nullptr || g_testDeviceTypes.size() == 0) {
209 return;
210 }
211 std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager = std::make_shared<AudioA2dpOffloadManager>();
212 audioRecoveryDevice->Init(audioA2dpOffloadManager);
213
214 DeviceType deviceType = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
215
216 int32_t deviceTypeToInt = static_cast<int32_t>(deviceType);
217 int32_t usageOrSourceType = GetData<int32_t>();
218 int32_t preferredType = GetData<int32_t>();
219 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptor = make_shared<AudioDeviceDescriptor>();
220 if (audioDeviceDescriptor == nullptr) {
221 return;
222 }
223 audioDeviceDescriptor->deviceType_ = deviceType;
224 audioRecoveryDevice->audioConnectedDevice_.connectedDevices_.push_back(audioDeviceDescriptor);
225 audioRecoveryDevice->HandleRecoveryPreferredDevices(preferredType, deviceTypeToInt, usageOrSourceType);
226 }
227
AudioRecoveryDeviceSelectOutputDeviceFuzzTest()228 void AudioRecoveryDeviceSelectOutputDeviceFuzzTest()
229 {
230 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
231 sptr<AudioRendererFilter> audioRendererFilter = new AudioRendererFilter();
232 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
233 if (audioRecoveryDevice == nullptr || g_testDeviceTypes.size() == 0
234 || audioRendererFilter == nullptr || deviceDescriptor == nullptr) {
235 return;
236 }
237 audioRendererFilter->uid = GetData<int32_t>();
238 audioRendererFilter->rendererInfo.rendererFlags = GetData<int32_t>();
239 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDesc;
240 deviceDescriptor->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
241 deviceDescriptor->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
242 selectedDesc.push_back(deviceDescriptor);
243 audioRecoveryDevice->audioA2dpOffloadManager_ = make_shared<AudioA2dpOffloadManager>();
244 audioRecoveryDevice->SelectOutputDevice(audioRendererFilter, selectedDesc);
245 }
246
AudioRecoveryDeviceHandleFetchDeviceChangeFuzzTest()247 void AudioRecoveryDeviceHandleFetchDeviceChangeFuzzTest()
248 {
249 static const vector<AudioStreamDeviceChangeReason> testAudioStreamDeviceChangeReason = {
250 AudioStreamDeviceChangeReason::UNKNOWN,
251 AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE,
252 AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE,
253 AudioStreamDeviceChangeReason::OVERRODE,
254 AudioStreamDeviceChangeReason::AUDIO_SESSION_ACTIVATE,
255 AudioStreamDeviceChangeReason::STREAM_PRIORITY_CHANGED,
256 };
257 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
258 if (audioRecoveryDevice == nullptr || g_testDeviceTypes.size() == 0
259 || testAudioStreamDeviceChangeReason.size() == 0) {
260 return;
261 }
262 audioRecoveryDevice->audioActiveDevice_.currentActiveDevice_.deviceType_ =
263 g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
264 audioRecoveryDevice->audioActiveDevice_.currentActiveDevice_.networkId_ = "testNetworkId";
265 AudioStreamDeviceChangeReason reason =
266 testAudioStreamDeviceChangeReason[GetData<uint32_t>() % testAudioStreamDeviceChangeReason.size()];
267 std::string caller{};
268 audioRecoveryDevice->audioA2dpOffloadManager_ = make_shared<AudioA2dpOffloadManager>();
269 audioRecoveryDevice->HandleFetchDeviceChange(reason, caller);
270 }
271
AudioRecoveryDeviceSelectOutputDeviceForFastInnerFuzzTest()272 void AudioRecoveryDeviceSelectOutputDeviceForFastInnerFuzzTest()
273 {
274 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
275 if (audioRecoveryDevice == nullptr) {
276 return;
277 }
278 sptr<AudioRendererFilter> audioRendererFilter = new AudioRendererFilter();
279 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDesc;
280 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
281 selectedDesc.push_back(deviceDescriptor);
282
283 audioRecoveryDevice->SelectOutputDeviceForFastInner(audioRendererFilter, selectedDesc);
284 }
285
AudioRecoveryDeviceSetRenderDeviceForUsageFuzzTest()286 void AudioRecoveryDeviceSetRenderDeviceForUsageFuzzTest()
287 {
288 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
289 std::shared_ptr<AudioDeviceDescriptor> desc = std::make_shared<AudioDeviceDescriptor>();
290 if (audioRecoveryDevice == nullptr || g_testStreamUsages.size() == 0 || desc == nullptr
291 || g_testDeviceTypes.size() == 0) {
292 return;
293 }
294 StreamUsage streamUsage = g_testStreamUsages[GetData<uint32_t>() % g_testStreamUsages.size()];
295 desc->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
296
297 audioRecoveryDevice->SetRenderDeviceForUsage(streamUsage, desc);
298 }
299
AudioRecoveryDeviceConnectVirtualDeviceFuzzTest()300 void AudioRecoveryDeviceConnectVirtualDeviceFuzzTest()
301 {
302 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
303 std::shared_ptr<AudioDeviceDescriptor> selectedDesc = std::make_shared<AudioDeviceDescriptor>();
304 if (audioRecoveryDevice == nullptr || selectedDesc == nullptr || g_testDeviceTypes.size() == 0) {
305 return;
306 }
307 selectedDesc->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
308
309 audioRecoveryDevice->ConnectVirtualDevice(selectedDesc);
310 }
311
AudioRecoveryDeviceWriteSelectOutputSysEventsFuzzTest()312 void AudioRecoveryDeviceWriteSelectOutputSysEventsFuzzTest()
313 {
314 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
315 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDescs;
316 std::shared_ptr<AudioDeviceDescriptor> selectedDesc = std::make_shared<AudioDeviceDescriptor>();
317 if (audioRecoveryDevice == nullptr || selectedDesc == nullptr ||
318 g_testDeviceTypes.size() == 0 || g_testStreamUsages.size() == 0) {
319 return;
320 }
321 selectedDesc->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
322 selectedDescs.push_back(selectedDesc);
323 StreamUsage strUsage = g_testStreamUsages[GetData<uint32_t>() % g_testStreamUsages.size()];
324
325 audioRecoveryDevice->WriteSelectOutputSysEvents(selectedDescs, strUsage);
326 }
327
AudioRecoveryDeviceSelectFastOutputDeviceFuzzTest()328 void AudioRecoveryDeviceSelectFastOutputDeviceFuzzTest()
329 {
330 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
331 sptr<AudioRendererFilter> audioRendererFilter = new AudioRendererFilter();
332 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
333 if (audioRecoveryDevice == nullptr || audioRendererFilter == nullptr || deviceDescriptor == nullptr) {
334 return;
335 }
336 audioRendererFilter->uid = GetData<int32_t>();
337 deviceDescriptor->networkId_ = "testNetworkId";
338
339 audioRecoveryDevice->SelectFastOutputDevice(audioRendererFilter, deviceDescriptor);
340 }
341
AudioRecoveryDeviceSelectOutputDeviceByFilterInnerFuzzTest()342 void AudioRecoveryDeviceSelectOutputDeviceByFilterInnerFuzzTest()
343 {
344 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
345 sptr<AudioRendererFilter> audioRendererFilter = new AudioRendererFilter();
346 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
347 if (audioRecoveryDevice == nullptr || audioRendererFilter == nullptr ||
348 deviceDescriptor == nullptr || g_testDeviceTypes.size() == 0) {
349 return;
350 }
351 audioRendererFilter->uid = GetData<int32_t>();
352 deviceDescriptor->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
353 deviceDescriptor->networkId_ = "testNetworkId";
354 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDesc;
355 selectedDesc.push_back(deviceDescriptor);
356 std::shared_ptr<AudioRendererChangeInfo> audioRendererChangeInfo = make_shared<AudioRendererChangeInfo>();
357 audioRecoveryDevice->streamCollector_.audioRendererChangeInfos_.push_back(audioRendererChangeInfo);
358
359 audioRecoveryDevice->SelectOutputDeviceByFilterInner(audioRendererFilter, selectedDesc);
360 }
361
AudioRecoveryDeviceSelectInputDeviceFuzzTest()362 void AudioRecoveryDeviceSelectInputDeviceFuzzTest()
363 {
364 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
365 sptr<AudioCapturerFilter> audioCapturerFilter = new AudioCapturerFilter();
366 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
367 if (audioRecoveryDevice == nullptr || audioCapturerFilter == nullptr ||
368 deviceDescriptor == nullptr || g_testSourceTypes.size() == 0 || g_testDeviceTypes.size() == 0) {
369 return;
370 }
371
372 audioCapturerFilter->uid = GetData<int32_t>();
373 audioCapturerFilter->capturerInfo.sourceType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
374 audioCapturerFilter->capturerInfo.capturerFlags = GetData<int32_t>();
375 deviceDescriptor->networkId_ = "testNetworkId";
376 deviceDescriptor->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
377 deviceDescriptor->macAddress_ = "testMacAddress";
378 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDesc;
379 selectedDesc.push_back(deviceDescriptor);
380
381 audioRecoveryDevice->SelectInputDevice(audioCapturerFilter, selectedDesc);
382 }
383
AudioRecoveryDeviceExcludeOutputDevicesFuzzTest()384 void AudioRecoveryDeviceExcludeOutputDevicesFuzzTest()
385 {
386 static const vector<AudioDeviceUsage> testAudioDeviceUsage = {
387 MEDIA_OUTPUT_DEVICES,
388 MEDIA_INPUT_DEVICES,
389 ALL_MEDIA_DEVICES,
390 CALL_OUTPUT_DEVICES,
391 CALL_INPUT_DEVICES,
392 ALL_CALL_DEVICES,
393 D_ALL_DEVICES,
394 };
395 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
396 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
397 if (audioRecoveryDevice == nullptr || testAudioDeviceUsage.size() == 0
398 || deviceDescriptor == nullptr || g_testDeviceTypes.size() == 0) {
399 return;
400 }
401 AudioDeviceUsage audioDevUsage =
402 testAudioDeviceUsage[GetData<uint32_t>() % testAudioDeviceUsage.size()];
403 deviceDescriptor->networkId_ = "testNetworkId";
404 deviceDescriptor->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
405 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDesc;
406 selectedDesc.push_back(deviceDescriptor);
407 audioRecoveryDevice->audioA2dpOffloadManager_ = make_shared<AudioA2dpOffloadManager>();
408
409 audioRecoveryDevice->ExcludeOutputDevices(audioDevUsage, selectedDesc);
410 }
411
AudioRecoveryDeviceUnexcludeOutputDevicesFuzzTest()412 void AudioRecoveryDeviceUnexcludeOutputDevicesFuzzTest()
413 {
414 static const vector<AudioDeviceUsage> testAudioDeviceUsage = {
415 MEDIA_OUTPUT_DEVICES,
416 MEDIA_INPUT_DEVICES,
417 ALL_MEDIA_DEVICES,
418 CALL_OUTPUT_DEVICES,
419 CALL_INPUT_DEVICES,
420 ALL_CALL_DEVICES,
421 D_ALL_DEVICES,
422 };
423 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
424 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
425 if (audioRecoveryDevice == nullptr || testAudioDeviceUsage.size() == 0
426 || deviceDescriptor == nullptr || g_testDeviceTypes.size() == 0) {
427 return;
428 }
429 AudioDeviceUsage audioDevUsage =
430 testAudioDeviceUsage[GetData<uint32_t>() % testAudioDeviceUsage.size()];
431 deviceDescriptor->networkId_ = "testNetworkId";
432 deviceDescriptor->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
433 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDesc;
434 selectedDesc.push_back(deviceDescriptor);
435 audioRecoveryDevice->audioA2dpOffloadManager_ = make_shared<AudioA2dpOffloadManager>();
436
437 audioRecoveryDevice->UnexcludeOutputDevices(audioDevUsage, selectedDesc);
438 }
439
AudioRecoveryDeviceSetCaptureDeviceForUsageFuzzTest()440 void AudioRecoveryDeviceSetCaptureDeviceForUsageFuzzTest()
441 {
442 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
443 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
444 if (audioRecoveryDevice == nullptr || g_testSourceTypes.size() == 0
445 || deviceDescriptor == nullptr || g_testAudioScenes.size() == 0) {
446 return;
447 }
448 AudioScene scene = g_testAudioScenes[GetData<uint32_t>() % g_testAudioScenes.size()];
449 SourceType srcType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
450 audioRecoveryDevice->audioA2dpOffloadManager_ = make_shared<AudioA2dpOffloadManager>();
451
452 audioRecoveryDevice->SetCaptureDeviceForUsage(scene, srcType, deviceDescriptor);
453 }
454
AudioRecoveryDeviceSelectFastInputDeviceFuzzTest()455 void AudioRecoveryDeviceSelectFastInputDeviceFuzzTest()
456 {
457 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
458 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
459 if (audioRecoveryDevice == nullptr || deviceDescriptor == nullptr) {
460 return;
461 }
462 sptr<AudioCapturerFilter> audioCapturerFilter = new AudioCapturerFilter();
463 audioRecoveryDevice->audioA2dpOffloadManager_ = make_shared<AudioA2dpOffloadManager>();
464
465 audioRecoveryDevice->SelectFastInputDevice(audioCapturerFilter, deviceDescriptor);
466 }
467
AudioRecoveryDeviceWriteSelectInputSysEventsFuzzTest()468 void AudioRecoveryDeviceWriteSelectInputSysEventsFuzzTest()
469 {
470 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
471 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
472 if (audioRecoveryDevice == nullptr || g_testDeviceTypes.size() == 0
473 || deviceDescriptor == nullptr || g_testSourceTypes.size() == 0 || g_testAudioScenes.size() == 0) {
474 return;
475 }
476
477 SourceType srcType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
478 AudioScene scene = g_testAudioScenes[GetData<uint32_t>() % g_testAudioScenes.size()];
479 deviceDescriptor->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
480 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDesc;
481 selectedDesc.push_back(deviceDescriptor);
482 audioRecoveryDevice->audioA2dpOffloadManager_ = make_shared<AudioA2dpOffloadManager>();
483
484 audioRecoveryDevice->WriteSelectInputSysEvents(selectedDesc, srcType, scene);
485 }
486
AudioRecoveryDeviceWriteExcludeOutputSysEventsFuzzTest()487 void AudioRecoveryDeviceWriteExcludeOutputSysEventsFuzzTest()
488 {
489 auto audioRecoveryDevice = std::make_shared<AudioRecoveryDevice>();
490 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
491 if (audioRecoveryDevice == nullptr || g_testDeviceTypes.size() == 0
492 || deviceDescriptor == nullptr ||AudioDeviceUsageVec.size() == 0) {
493 return;
494 }
495
496 deviceDescriptor->deviceType_ = g_testDeviceTypes[GetData<uint32_t>() % g_testDeviceTypes.size()];
497 AudioDeviceUsage audioDevUsage = AudioDeviceUsageVec[GetData<uint32_t>() % AudioDeviceUsageVec.size()];
498 audioRecoveryDevice->audioA2dpOffloadManager_ = make_shared<AudioA2dpOffloadManager>();
499
500 audioRecoveryDevice->WriteExcludeOutputSysEvents(audioDevUsage, deviceDescriptor);
501 }
502
503 TestFuncs g_testFuncs[TESTSIZE] = {
504 RecoveryPreferredDevicesFuzzTest,
505 RecoverExcludedOutputDevicesFuzzTest,
506 HandleExcludedOutputDevicesRecoveryFuzzTest,
507 AudioRecoveryDeviceHandleRecoveryPreferredDevicesFuzzTest,
508 AudioRecoveryDeviceSelectOutputDeviceFuzzTest,
509 AudioRecoveryDeviceHandleFetchDeviceChangeFuzzTest,
510 AudioRecoveryDeviceSelectOutputDeviceForFastInnerFuzzTest,
511 AudioRecoveryDeviceSetRenderDeviceForUsageFuzzTest,
512 AudioRecoveryDeviceConnectVirtualDeviceFuzzTest,
513 AudioRecoveryDeviceWriteSelectOutputSysEventsFuzzTest,
514 AudioRecoveryDeviceSelectFastOutputDeviceFuzzTest,
515 AudioRecoveryDeviceSelectOutputDeviceByFilterInnerFuzzTest,
516 AudioRecoveryDeviceSelectInputDeviceFuzzTest,
517 AudioRecoveryDeviceExcludeOutputDevicesFuzzTest,
518 AudioRecoveryDeviceUnexcludeOutputDevicesFuzzTest,
519 AudioRecoveryDeviceSetCaptureDeviceForUsageFuzzTest,
520 AudioRecoveryDeviceSelectFastInputDeviceFuzzTest,
521 AudioRecoveryDeviceWriteSelectInputSysEventsFuzzTest,
522 AudioRecoveryDeviceWriteExcludeOutputSysEventsFuzzTest,
523 };
524
FuzzTest(const uint8_t * rawData,size_t size)525 bool FuzzTest(const uint8_t* rawData, size_t size)
526 {
527 if (rawData == nullptr) {
528 return false;
529 }
530
531 // initialize data
532 RAW_DATA = rawData;
533 g_dataSize = size;
534 g_pos = 0;
535
536 uint32_t code = GetData<uint32_t>();
537 uint32_t len = GetArrLength(g_testFuncs);
538 if (len > 0) {
539 g_testFuncs[code % len]();
540 } else {
541 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
542 }
543
544 return true;
545 }
546 } // namespace AudioStandard
547 } // namesapce OHOS
548
549 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)550 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
551 {
552 if (size < OHOS::AudioStandard::THRESHOLD) {
553 return 0;
554 }
555
556 OHOS::AudioStandard::FuzzTest(data, size);
557 return 0;
558 }
559