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
38 #include "audio_source_clock.h"
39 #include "capturer_clock_manager.h"
40 #include "hpae_policy_manager.h"
41 #include "audio_policy_state_monitor.h"
42 #include "audio_device_info.h"
43
44 namespace OHOS {
45 namespace AudioStandard {
46 using namespace std;
47
48 static const uint8_t* RAW_DATA = nullptr;
49 static size_t g_dataSize = 0;
50 static size_t g_pos;
51 const size_t THRESHOLD = 10;
52 const uint8_t TESTSIZE = 24;
53 static int32_t NUM_2 = 2;
54
55 typedef void (*TestFuncs)();
56
57 template<class T>
GetData()58 T GetData()
59 {
60 T object {};
61 size_t objectSize = sizeof(object);
62 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
63 return object;
64 }
65 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
66 if (ret != EOK) {
67 return {};
68 }
69 g_pos += objectSize;
70 return object;
71 }
72
73 template<class T>
GetArrLength(T & arr)74 uint32_t GetArrLength(T& arr)
75 {
76 if (arr == nullptr) {
77 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
78 return 0;
79 }
80 return sizeof(arr) / sizeof(arr[0]);
81 }
82
83 vector<DeviceType> DeviceTypeVec = {
84 DEVICE_TYPE_NONE,
85 DEVICE_TYPE_INVALID,
86 DEVICE_TYPE_EARPIECE,
87 DEVICE_TYPE_SPEAKER,
88 DEVICE_TYPE_WIRED_HEADSET,
89 DEVICE_TYPE_WIRED_HEADPHONES,
90 DEVICE_TYPE_BLUETOOTH_SCO,
91 DEVICE_TYPE_BLUETOOTH_A2DP,
92 DEVICE_TYPE_BLUETOOTH_A2DP_IN,
93 DEVICE_TYPE_MIC,
94 DEVICE_TYPE_WAKEUP,
95 DEVICE_TYPE_USB_HEADSET,
96 DEVICE_TYPE_DP,
97 DEVICE_TYPE_REMOTE_CAST,
98 DEVICE_TYPE_USB_DEVICE,
99 DEVICE_TYPE_ACCESSORY,
100 DEVICE_TYPE_REMOTE_DAUDIO,
101 DEVICE_TYPE_HDMI,
102 DEVICE_TYPE_LINE_DIGITAL,
103 DEVICE_TYPE_NEARLINK,
104 DEVICE_TYPE_NEARLINK_IN,
105 DEVICE_TYPE_FILE_SINK,
106 DEVICE_TYPE_FILE_SOURCE,
107 DEVICE_TYPE_EXTERN_CABLE,
108 DEVICE_TYPE_DEFAULT,
109 DEVICE_TYPE_USB_ARM_HEADSET,
110 DEVICE_TYPE_MAX,
111 };
112
113 vector<DeviceRole> DeviceRoleVec = {
114 DEVICE_ROLE_NONE,
115 INPUT_DEVICE,
116 OUTPUT_DEVICE,
117 DEVICE_ROLE_MAX,
118 };
119
120 vector<DeviceCategory> DeviceCategoryVec = {
121 CATEGORY_DEFAULT,
122 BT_HEADPHONE,
123 BT_SOUNDBOX,
124 BT_CAR,
125 BT_GLASSES,
126 BT_WATCH,
127 BT_HEARAID,
128 BT_UNWEAR_HEADPHONE,
129 };
130
131 vector<AudioPin> AudioPinVec = {
132 AUDIO_PIN_NONE,
133 AUDIO_PIN_OUT_SPEAKER,
134 AUDIO_PIN_OUT_HEADSET,
135 AUDIO_PIN_OUT_LINEOUT,
136 AUDIO_PIN_OUT_HDMI,
137 AUDIO_PIN_OUT_USB,
138 AUDIO_PIN_OUT_USB_EXT,
139 AUDIO_PIN_OUT_EARPIECE,
140 AUDIO_PIN_OUT_BLUETOOTH_SCO,
141 AUDIO_PIN_OUT_DAUDIO_DEFAULT,
142 AUDIO_PIN_OUT_HEADPHONE,
143 AUDIO_PIN_OUT_USB_HEADSET,
144 AUDIO_PIN_OUT_BLUETOOTH_A2DP,
145 AUDIO_PIN_OUT_DP,
146 AUDIO_PIN_OUT_NEARLINK,
147 AUDIO_PIN_IN_MIC,
148 AUDIO_PIN_IN_HS_MIC,
149 AUDIO_PIN_IN_LINEIN,
150 AUDIO_PIN_IN_USB_EXT,
151 AUDIO_PIN_IN_BLUETOOTH_SCO_HEADSET,
152 AUDIO_PIN_IN_DAUDIO_DEFAULT,
153 AUDIO_PIN_IN_USB_HEADSET,
154 AUDIO_PIN_IN_PENCIL,
155 AUDIO_PIN_IN_UWB,
156 AUDIO_PIN_IN_NEARLINK,
157 };
158
HandleArmUsbDeviceFuzzTest()159 void HandleArmUsbDeviceFuzzTest()
160 {
161 std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager = std::make_shared<AudioA2dpOffloadManager>();
162 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler =
163 DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
164 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
165 audioA2dpOffloadManager->Init();
166 audioDeviceStatus.Init(audioA2dpOffloadManager, audioPolicyServerHandler);
167
168 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
169 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
170 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
171 DeviceRole deviceRole = DeviceRoleVec[roleCount];
172 std::string address = "00:11:22:33:44:55";
173 audioDeviceStatus.HandleArmUsbDevice(deviceType, deviceRole, address);
174
175 audioDeviceStatus.DeInit();
176 }
177
RehandlePnpDeviceFuzzTest()178 void RehandlePnpDeviceFuzzTest()
179 {
180 std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager = std::make_shared<AudioA2dpOffloadManager>();
181 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler =
182 DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
183 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
184 audioA2dpOffloadManager->Init();
185 audioDeviceStatus.Init(audioA2dpOffloadManager, audioPolicyServerHandler);
186
187 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
188 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
189 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
190 DeviceRole deviceRole = DeviceRoleVec[roleCount];
191 std::string address = "00:11:22:33:44:55";
192 audioDeviceStatus.RehandlePnpDevice(deviceType, deviceRole, address);
193
194 audioDeviceStatus.DeInit();
195 }
196
NoNeedChangeUsbDeviceFuzzTest()197 void NoNeedChangeUsbDeviceFuzzTest()
198 {
199 std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager = std::make_shared<AudioA2dpOffloadManager>();
200 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler =
201 DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
202 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
203 audioA2dpOffloadManager->Init();
204 audioDeviceStatus.Init(audioA2dpOffloadManager, audioPolicyServerHandler);
205
206 std::string address = "00:11:22:33:44:55";
207 audioDeviceStatus.NoNeedChangeUsbDevice(address);
208
209 audioDeviceStatus.DeInit();
210 }
211
TriggerMicrophoneBlockedCallbackFuzzTest()212 void TriggerMicrophoneBlockedCallbackFuzzTest()
213 {
214 std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager = std::make_shared<AudioA2dpOffloadManager>();
215 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler =
216 DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
217 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
218 audioA2dpOffloadManager->Init();
219 audioDeviceStatus.Init(audioA2dpOffloadManager, audioPolicyServerHandler);
220
221 vector<std::shared_ptr<AudioDeviceDescriptor>> desc;
222 int32_t statusCount = static_cast<int32_t>(DeviceBlockStatus::DEVICE_BLOCKED) + 1;
223 DeviceBlockStatus status = static_cast<DeviceBlockStatus>(GetData<uint8_t>() % statusCount);
224 audioDeviceStatus.TriggerMicrophoneBlockedCallback(desc, status);
225
226 audioDeviceStatus.DeInit();
227 }
228
ReloadA2dpOffloadOnDeviceChangedFuzzTest()229 void ReloadA2dpOffloadOnDeviceChangedFuzzTest()
230 {
231 std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager = std::make_shared<AudioA2dpOffloadManager>();
232 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler =
233 DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
234 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
235 audioA2dpOffloadManager->Init();
236 audioDeviceStatus.Init(audioA2dpOffloadManager, audioPolicyServerHandler);
237
238 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
239 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
240 std::string macAddress = "00:11:22:33:44:55";
241 std::string deviceName = "usb_headset";
242 AudioStreamInfo streamInfo = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
243 std::unique_ptr <AudioAffinityManager> audioAffinityManager = std::make_unique<AudioAffinityManager>();
244 int32_t classTypeCount = static_cast<int32_t>(ClassType::TYPE_INVALID) + 1;
245 ClassType classType = static_cast<ClassType>(GetData<uint8_t>() % classTypeCount);
246 AudioModuleInfo moduleInfo = {"className", "TEST", "TEST"};
247 moduleInfo.name = "testModule";
248 std::list<AudioModuleInfo> audioModuleListData = {};
249 audioModuleListData.push_back(moduleInfo);
250 audioDeviceStatus.audioConfigManager_.deviceClassInfo_[classType] = audioModuleListData;
251 AudioIOHandle audioIoHandle = GetData<uint32_t>();
252 audioDeviceStatus.audioIOHandleMap_.IOHandles_.insert({moduleInfo.name, audioIoHandle});
253 audioDeviceStatus.ReloadA2dpOffloadOnDeviceChanged(deviceType, macAddress, deviceName, streamInfo);
254
255 audioDeviceStatus.DeInit();
256 }
257
GetDeviceTypeFromPinFuzzTest()258 void GetDeviceTypeFromPinFuzzTest()
259 {
260 std::shared_ptr<AudioA2dpOffloadManager> audioA2dpOffloadManager = std::make_shared<AudioA2dpOffloadManager>();
261 std::shared_ptr<AudioPolicyServerHandler> audioPolicyServerHandler =
262 DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
263 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
264 audioA2dpOffloadManager->Init();
265 audioDeviceStatus.Init(audioA2dpOffloadManager, audioPolicyServerHandler);
266
267 uint32_t hdiPinCount = GetData<uint32_t>() % AudioPinVec.size();
268 AudioPin hdiPin = AudioPinVec[hdiPinCount];
269 audioDeviceStatus.GetDeviceTypeFromPin(hdiPin);
270
271 audioDeviceStatus.DeInit();
272 }
273
OnDeviceStatusUpdatedFuzzTest()274 void OnDeviceStatusUpdatedFuzzTest()
275 {
276 DStatusInfo statusInfo;
277 uint32_t hdiPinCount = GetData<uint32_t>() % AudioPinVec.size();
278 statusInfo.hdiPin = AudioPinVec[hdiPinCount];
279 statusInfo.macAddress = "00:11:22:33:44:55";
280 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
281 audioDeviceStatus.OnDeviceStatusUpdated(statusInfo, GetData<uint32_t>() % NUM_2);
282 }
283
HandleDistributedDeviceUpdateFuzzTest()284 void HandleDistributedDeviceUpdateFuzzTest()
285 {
286 DStatusInfo statusInfo;
287 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descForCb;
288 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
289 uint32_t hdiPinCount = GetData<uint32_t>() % AudioPinVec.size();
290 statusInfo.hdiPin = AudioPinVec[hdiPinCount];
291 statusInfo.deviceName = "test";
292 statusInfo.macAddress = "00:11:22:33:44:55";
293 statusInfo.isConnected = GetData<uint32_t>() % NUM_2;
294 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN;
295 audioDeviceStatus.HandleDistributedDeviceUpdate(statusInfo, descForCb, reason);
296 }
297
UpdateDeviceListFuzzTest()298 void UpdateDeviceListFuzzTest()
299 {
300 AudioDeviceDescriptor updatedDesc;
301 bool isConnected = GetData<uint32_t>() % NUM_2;
302 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descForCb;
303 AudioStreamDeviceChangeReasonExt::ExtEnum oldDevice =
304 AudioStreamDeviceChangeReasonExt::ExtEnum::OLD_DEVICE_UNAVALIABLE;
305 AudioStreamDeviceChangeReasonExt reason(oldDevice);
306 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
307 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
308 updatedDesc.deviceType_ = DeviceTypeVec[deviceTypeCount];
309 updatedDesc.macAddress_ = "00:11:22:33:44:55";
310 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
311 updatedDesc.deviceRole_ = DeviceRoleVec[roleCount];
312 audioDeviceStatus.UpdateDeviceList(updatedDesc, isConnected, descForCb, reason);
313 }
314
OnPreferredStateUpdatedFuzzTest()315 void OnPreferredStateUpdatedFuzzTest()
316 {
317 AudioDeviceDescriptor desc;
318 int32_t updateCommandCount = static_cast<int32_t>(DeviceInfoUpdateCommand::EXCEPTION_FLAG_UPDATE -
319 DeviceInfoUpdateCommand::CATEGORY_UPDATE) + 1;
320 DeviceInfoUpdateCommand updateCommand =
321 static_cast<DeviceInfoUpdateCommand>(GetData<uint8_t>() % updateCommandCount + 1);
322 AudioStreamDeviceChangeReasonExt::ExtEnum oldDevice =
323 AudioStreamDeviceChangeReasonExt::ExtEnum::OLD_DEVICE_UNAVALIABLE;
324 AudioStreamDeviceChangeReasonExt reason(oldDevice);
325 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
326 uint32_t deviceCategoryCount = GetData<uint32_t>() % DeviceCategoryVec.size();
327 desc.deviceCategory_ = DeviceCategoryVec[deviceCategoryCount];
328 audioDeviceStatus.OnPreferredStateUpdated(desc, updateCommand, reason);
329 }
330
CheckAndActiveHfpDeviceFuzzTest()331 void CheckAndActiveHfpDeviceFuzzTest()
332 {
333 AudioDeviceDescriptor desc;
334 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
335 desc.deviceType_ = DeviceTypeVec[deviceTypeCount];
336 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
337 audioDeviceStatus.CheckAndActiveHfpDevice(desc);
338 }
339
TriggerAvailableDeviceChangedCallbackFuzzTest()340 void TriggerAvailableDeviceChangedCallbackFuzzTest()
341 {
342 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
343 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
344 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
345 bool isConnected = GetData<uint32_t>() % NUM_2;
346 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
347 audioDeviceStatus.DeInit();
348 audioDeviceStatus.TriggerAvailableDeviceChangedCallback(audioDeviceDescriptorSptrVector, isConnected);
349 }
350
TriggerDeviceChangedCallbackFuzzTest()351 void TriggerDeviceChangedCallbackFuzzTest()
352 {
353 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
354 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptorSptrVector;
355 audioDeviceDescriptorSptrVector.push_back(audioDeviceDescriptorSptr);
356 bool isConnected = GetData<uint32_t>() % NUM_2;
357 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
358 audioDeviceStatus.TriggerDeviceChangedCallback(audioDeviceDescriptorSptrVector, isConnected);
359 }
360
HandleDpDeviceFuzzTest()361 void HandleDpDeviceFuzzTest()
362 {
363 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
364 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
365 std::string address = "00:11:22:33:44:55";
366 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
367 audioDeviceStatus.HandleDpDevice(deviceType, address);
368 }
369
HandleLocalDeviceConnectedFuzzTest()370 void HandleLocalDeviceConnectedFuzzTest()
371 {
372 AudioDeviceDescriptor updatedDesc;
373 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
374 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
375 updatedDesc.deviceType_ = DeviceTypeVec[deviceTypeCount];
376 audioDeviceStatus.HandleLocalDeviceConnected(updatedDesc);
377 }
378
HandleLocalDeviceDisconnectedFuzzTest()379 void HandleLocalDeviceDisconnectedFuzzTest()
380 {
381 AudioDeviceDescriptor updatedDesc;
382 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
383 updatedDesc.deviceType_ = DeviceTypeVec[deviceTypeCount];
384 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
385 audioDeviceStatus.HandleLocalDeviceDisconnected(updatedDesc);
386 }
387
HandleSpecialDeviceTypeFuzzTest()388 void HandleSpecialDeviceTypeFuzzTest()
389 {
390 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
391 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
392 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
393 DeviceRole deviceRole = DeviceRoleVec[roleCount];
394 std::string address = "00:11:22:33:44:55";
395 bool isConnected = GetData<uint32_t>() % NUM_2;
396 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
397 audioDeviceStatus.HandleSpecialDeviceType(deviceType, isConnected, address, deviceRole);
398 }
399
OnPnpDeviceStatusUpdatedFuzzTest()400 void OnPnpDeviceStatusUpdatedFuzzTest()
401 {
402 AudioDeviceDescriptor desc;
403 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
404 desc.deviceType_ = DeviceTypeVec[deviceTypeCount];
405 desc.macAddress_ = "00:11:22:33:44:55";
406 desc.deviceName_ = "NONE";
407 bool isConnected = GetData<uint32_t>() % NUM_2;
408 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
409 audioDeviceStatus.audioA2dpOffloadManager_ = std::make_shared<AudioA2dpOffloadManager>();
410 audioDeviceStatus.hasModulesLoaded = GetData<bool>();
411 audioDeviceStatus.OnPnpDeviceStatusUpdated(desc, isConnected);
412 }
413
UpdateActiveA2dpDeviceWhenDisconnectingFuzzTest()414 void UpdateActiveA2dpDeviceWhenDisconnectingFuzzTest()
415 {
416 std::string address = "00:11:22:33:44:55";
417 std::string device = address;
418 A2dpDeviceConfigInfo config;
419 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
420 audioDeviceStatus.audioA2dpDevice_.AddA2dpInDevice(device, config);
421 audioDeviceStatus.UpdateActiveA2dpDeviceWhenDisconnecting(address);
422 }
423
IsConfigurationUpdatedFuzzTest()424 void IsConfigurationUpdatedFuzzTest()
425 {
426 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
427 DeviceType deviceType = DeviceTypeVec[deviceTypeCount];
428 AudioStreamInfo streamInfo;
429 AudioDeviceStatus audioDeviceStatus;
430 audioDeviceStatus.IsConfigurationUpdated(deviceType, streamInfo);
431 }
432
OpenPortAndAddDeviceOnServiceConnectedFuzzTest()433 void OpenPortAndAddDeviceOnServiceConnectedFuzzTest()
434 {
435 AudioModuleInfo moduleInfo;
436 vector<string> moduleInfoNameList = {
437 "file_source",
438 "Built_in_mic",
439 "Speaker",
440 };
441 uint32_t moduleInfoNameCount = GetData<uint32_t>() % moduleInfoNameList.size();
442 moduleInfo.name = moduleInfoNameList[moduleInfoNameCount];
443 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
444 audioDeviceStatus.OpenPortAndAddDeviceOnServiceConnected(moduleInfo);
445 }
446
OnForcedDeviceSelectedFuzzTest()447 void OnForcedDeviceSelectedFuzzTest()
448 {
449 std::string macAddress = "00:11:22:33:44:55";
450 uint32_t deviceTypeCount = GetData<uint32_t>() % DeviceTypeVec.size();
451 DeviceType devType = DeviceTypeVec[deviceTypeCount];
452
453 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
454 remoteDeviceDescriptor->deviceType_ = devType;
455 remoteDeviceDescriptor->macAddress_ = "00:11:22:33:44:55";
456 uint32_t roleCount = GetData<uint32_t>() % DeviceRoleVec.size();
457 remoteDeviceDescriptor->deviceRole_ = DeviceRoleVec[roleCount];
458
459 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
460 audioDeviceStatus.audioConnectedDevice_.AddConnectedDevice(remoteDeviceDescriptor);
461 shared_ptr<AudioDeviceDescriptor> desc = make_shared<AudioDeviceDescriptor>();
462 if (desc == nullptr) {
463 return;
464 }
465 desc->deviceType_ = devType;
466 desc->macAddress_ = macAddress;
467 desc->deviceRole_ = DeviceRole::OUTPUT_DEVICE;
468 audioDeviceStatus.audioDeviceManager_.connectedDevices_.push_back(desc);
469
470 audioDeviceStatus.OnForcedDeviceSelected(devType, macAddress);
471 }
472
AudioDeviceStatusLoadAccessoryModuleFuzzTest()473 void AudioDeviceStatusLoadAccessoryModuleFuzzTest()
474 {
475 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
476 std::string deviceInfo = "testDeviceInfo";
477 ClassType classType = GetData<ClassType>();
478 AudioModuleInfo moduleInfo;
479 std::list<AudioModuleInfo> moduleInfoList;
480 moduleInfoList.push_back(moduleInfo);
481 audioDeviceStatus.audioConfigManager_.deviceClassInfo_.insert({classType, moduleInfoList});
482
483 audioDeviceStatus.LoadAccessoryModule(deviceInfo);
484 }
485
AudioDeviceStatusOnDeviceConfigurationChangedFuzzTest()486 void AudioDeviceStatusOnDeviceConfigurationChangedFuzzTest()
487 {
488 AudioDeviceStatus& audioDeviceStatus = AudioDeviceStatus::GetInstance();
489 DeviceType deviceType = GetData<DeviceType>();
490 std::string macAddress = "00:11:22:33:44:55";
491 std::string deviceName = "testDevice";
492 AudioStreamInfo streamInfo;
493 audioDeviceStatus.audioActiveDevice_.SetActiveBtDeviceMac("00:11:22:33:44:50");
494 audioDeviceStatus.audioA2dpOffloadManager_ = std::make_shared<AudioA2dpOffloadManager>();
495
496 audioDeviceStatus.OnDeviceConfigurationChanged(deviceType, macAddress, deviceName, streamInfo);
497 }
498
499 TestFuncs g_testFuncs[TESTSIZE] = {
500 HandleArmUsbDeviceFuzzTest,
501 RehandlePnpDeviceFuzzTest,
502 NoNeedChangeUsbDeviceFuzzTest,
503 TriggerMicrophoneBlockedCallbackFuzzTest,
504 ReloadA2dpOffloadOnDeviceChangedFuzzTest,
505 GetDeviceTypeFromPinFuzzTest,
506 OnDeviceStatusUpdatedFuzzTest,
507 HandleDistributedDeviceUpdateFuzzTest,
508 UpdateDeviceListFuzzTest,
509 OnPreferredStateUpdatedFuzzTest,
510 CheckAndActiveHfpDeviceFuzzTest,
511 TriggerAvailableDeviceChangedCallbackFuzzTest,
512 TriggerDeviceChangedCallbackFuzzTest,
513 HandleDpDeviceFuzzTest,
514 HandleLocalDeviceConnectedFuzzTest,
515 HandleLocalDeviceDisconnectedFuzzTest,
516 HandleSpecialDeviceTypeFuzzTest,
517 OnPnpDeviceStatusUpdatedFuzzTest,
518 UpdateActiveA2dpDeviceWhenDisconnectingFuzzTest,
519 IsConfigurationUpdatedFuzzTest,
520 OpenPortAndAddDeviceOnServiceConnectedFuzzTest,
521 OnForcedDeviceSelectedFuzzTest,
522 AudioDeviceStatusLoadAccessoryModuleFuzzTest,
523 AudioDeviceStatusOnDeviceConfigurationChangedFuzzTest,
524 };
525
FuzzTest(const uint8_t * rawData,size_t size)526 bool FuzzTest(const uint8_t* rawData, size_t size)
527 {
528 if (rawData == nullptr) {
529 return false;
530 }
531
532 // initialize data
533 RAW_DATA = rawData;
534 g_dataSize = size;
535 g_pos = 0;
536
537 uint32_t code = GetData<uint32_t>();
538 uint32_t len = GetArrLength(g_testFuncs);
539 if (len > 0) {
540 g_testFuncs[code % len]();
541 } else {
542 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
543 }
544
545 return true;
546 }
547 } // namespace AudioStandard
548 } // namesapce OHOS
549
550 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)551 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
552 {
553 if (size < OHOS::AudioStandard::THRESHOLD) {
554 return 0;
555 }
556
557 OHOS::AudioStandard::FuzzTest(data, size);
558 return 0;
559 }
560