1 /*
2 * Copyright (c) 2024 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 "audio_policy_server.h"
20 #include "audio_policy_service.h"
21 #include "audio_device_info.h"
22 #include "message_parcel.h"
23 #include "accesstoken_kit.h"
24 #include "nativetoken_kit.h"
25 #include "token_setproc.h"
26 #include "access_token.h"
27 #include "audio_policy_utils.h"
28 using namespace std;
29
30 namespace OHOS {
31 namespace AudioStandard {
32 const int32_t A2DP_PLAYING = 2;
33 const int32_t A2DP_STOPPED = 1;
34 const int32_t SYSTEM_ABILITY_ID = 3009;
35 const bool RUN_ON_CREATE = false;
36 bool g_hasServerInit = false;
37 bool g_hasPermission = false;
38 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy";
39 static const uint8_t *RAW_DATA = nullptr;
40 static size_t g_dataSize = 0;
41 static size_t g_pos;
42 const size_t THRESHOLD = 10;
43
44 /*
45 * describe: get data from outside untrusted data(RAW_DATA) which size is according to sizeof(T)
46 * tips: only support basic type
47 */
48 template<class T>
GetData()49 T GetData()
50 {
51 T object {};
52 size_t objectSize = sizeof(object);
53 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
54 return object;
55 }
56 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
57 if (ret != EOK) {
58 return {};
59 }
60 g_pos += objectSize;
61 return object;
62 }
63
64 template<class T>
GetArrLength(T & arr)65 uint32_t GetArrLength(T& arr)
66 {
67 if (arr == nullptr) {
68 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
69 return 0;
70 }
71 return sizeof(arr) / sizeof(arr[0]);
72 }
73
GetServerPtr()74 AudioPolicyServer* GetServerPtr()
75 {
76 static AudioPolicyServer server(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
77 if (!g_hasServerInit) {
78 server.OnStart();
79 server.OnAddSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID, "");
80 #ifdef FEATURE_MULTIMODALINPUT_INPUT
81 server.OnAddSystemAbility(MULTIMODAL_INPUT_SERVICE_ID, "");
82 #endif
83 server.OnAddSystemAbility(BLUETOOTH_HOST_SYS_ABILITY_ID, "");
84 server.OnAddSystemAbility(POWER_MANAGER_SERVICE_ID, "");
85 server.OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, "");
86 server.audioPolicyService_.SetDefaultDeviceLoadFlag(true);
87 g_hasServerInit = true;
88 }
89 return &server;
90 }
91
AudioFuzzTestGetPermission()92 void AudioFuzzTestGetPermission()
93 {
94 if (!g_hasPermission) {
95 uint64_t tokenId;
96 constexpr int perNum = 10;
97 const char *perms[perNum] = {
98 "ohos.permission.MICROPHONE",
99 "ohos.permission.MANAGE_INTELLIGENT_VOICE",
100 "ohos.permission.MANAGE_AUDIO_CONFIG",
101 "ohos.permission.MICROPHONE_CONTROL",
102 "ohos.permission.MODIFY_AUDIO_SETTINGS",
103 "ohos.permission.ACCESS_NOTIFICATION_POLICY",
104 "ohos.permission.USE_BLUETOOTH",
105 "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO",
106 "ohos.permission.RECORD_VOICE_CALL",
107 "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS",
108 };
109
110 NativeTokenInfoParams infoInstance = {
111 .dcapsNum = 0,
112 .permsNum = 10,
113 .aclsNum = 0,
114 .dcaps = nullptr,
115 .perms = perms,
116 .acls = nullptr,
117 .processName = "audiofuzztest",
118 .aplStr = "system_basic",
119 };
120 tokenId = GetAccessTokenId(&infoInstance);
121 SetSelfTokenID(tokenId);
122 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
123 g_hasPermission = true;
124 }
125 }
126
AudioPolicyServiceEnhanceOneFuzzTest()127 void AudioPolicyServiceEnhanceOneFuzzTest()
128 {
129 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
130 if (audioRendererFilter == nullptr) {return;}
131 audioRendererFilter->uid = getuid();
132 audioRendererFilter->rendererInfo.rendererFlags = STREAM_FLAG_FAST;
133 audioRendererFilter->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
134
135 AudioCapturerInfo capturerInfo;
136 AudioStreamInfo streamInfo;
137 uint32_t sessionId = GetData<uint32_t>();
138 GetServerPtr()->audioPolicyService_.NotifyCapturerAdded(capturerInfo, streamInfo, sessionId);
139
140 AudioDeviceDescriptor deviceDescriptor;
141 deviceDescriptor.deviceType_ = GetData<DeviceType>();
142 GetServerPtr()->audioPolicyService_.audioActiveDevice_.SetCurrentInputDevice(deviceDescriptor);
143 }
144
AudioPolicyServiceEnhanceTwoFuzzTest()145 void AudioPolicyServiceEnhanceTwoFuzzTest()
146 {
147 AudioStreamInfo audioStreamInfo;
148 GetServerPtr()->audioPolicyService_.audioDeviceCommon_.LoadA2dpModule(DEVICE_TYPE_BLUETOOTH_A2DP,
149 audioStreamInfo, "", "", SOURCE_TYPE_VOICE_RECOGNITION);
150
151 DeviceType deviceType = GetData<DeviceType>();
152 std::string networkId = "LocalDevice";
153 bool isRemote = GetData<DeviceType>();
154 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.ActivateNewDevice(networkId, deviceType, isRemote);
155
156 DeviceBlockStatus status = GetData<DeviceBlockStatus>();
157 GetServerPtr()->audioPolicyService_.OnMicrophoneBlockedUpdate(deviceType, status);
158 GetServerPtr()->audioPolicyService_.audioDeviceLock_.OnBlockedStatusUpdated(deviceType, status);
159
160 AudioDeviceDescriptor updatedDesc;
161 GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(updatedDesc, isRemote);
162 AudioStreamDeviceChangeReasonExt reason = GetData<AudioStreamDeviceChangeReasonExt::ExtEnum>();
163 std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
164 std::vector<std::shared_ptr<AudioDeviceDescriptor>> selectedDesc;
165 selectedDesc.push_back(fuzzAudioDeviceDescriptorSptr);
166 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.UpdateDeviceList(updatedDesc, isRemote,
167 selectedDesc, reason);
168
169 std::string macAddress = "";
170 std::unordered_map<uint32_t, bool> sessionIDToSpatialization;
171 GetServerPtr()->audioPolicyService_.UpdateA2dpOffloadFlagBySpatialService(macAddress, sessionIDToSpatialization);
172 GetServerPtr()->audioPolicyService_.audioRouteMap_.RemoveDeviceInRouterMap(networkId);
173 GetServerPtr()->audioPolicyService_.audioRouteMap_.RemoveDeviceInFastRouterMap(networkId);
174 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.HandleOfflineDistributedDevice();
175 }
176
AudioPolicyServiceEnhanceThreeFuzzTest()177 void AudioPolicyServiceEnhanceThreeFuzzTest()
178 {
179 DStatusInfo statusInfo;
180 std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
181 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descForCb;
182 descForCb.push_back(fuzzAudioDeviceDescriptorSptr);
183 GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(statusInfo, true);
184 GetServerPtr()->audioPolicyService_.OnMonoAudioConfigChanged(true);
185 GetServerPtr()->audioPolicyService_.UpdateDescWhenNoBTPermission(descForCb);
186 DeviceBlockStatus status = GetData<DeviceBlockStatus>();
187 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.TriggerMicrophoneBlockedCallback(descForCb, status);
188 float audioBalance = GetData<float>();
189 GetServerPtr()->audioPolicyService_.OnAudioBalanceChanged(audioBalance);
190 std::string macAddress = "";
191 GetServerPtr()->audioPolicyService_.audioVolumeManager_.SetAbsVolumeSceneAsync(macAddress, true);
192 std::vector<AudioPin> audioPin = {
193 AUDIO_PIN_NONE, AUDIO_PIN_OUT_SPEAKER, AUDIO_PIN_OUT_HEADSET,
194 AUDIO_PIN_OUT_LINEOUT, AUDIO_PIN_OUT_HDMI, AUDIO_PIN_OUT_USB,
195 AUDIO_PIN_OUT_USB_EXT, AUDIO_PIN_OUT_DAUDIO_DEFAULT, AUDIO_PIN_IN_MIC,
196 AUDIO_PIN_IN_HS_MIC, AUDIO_PIN_IN_LINEIN, AUDIO_PIN_IN_PENCIL,
197 AUDIO_PIN_IN_UWB, AUDIO_PIN_IN_USB_EXT, AUDIO_PIN_IN_DAUDIO_DEFAULT,
198 AUDIO_PIN_OUT_DP,
199 };
200 uint32_t audioPinInt = GetData<uint32_t>() % audioPin.size();
201 AudioPin pin = audioPin[audioPinInt];
202 AudioPolicyUtils::GetInstance().GetDeviceRole(pin);
203 }
204
AudioPolicyServiceEnhanceFourFuzzTest()205 void AudioPolicyServiceEnhanceFourFuzzTest()
206 {
207 int32_t clientUid = GetData<int32_t>();
208 int32_t sessionId = GetData<int32_t>();
209
210 std::vector<AudioPin> audioPin = {
211 AUDIO_PIN_NONE,
212 AUDIO_PIN_OUT_SPEAKER,
213 AUDIO_PIN_OUT_DAUDIO_DEFAULT,
214 AUDIO_PIN_OUT_HEADSET,
215 AUDIO_PIN_OUT_LINEOUT,
216 AUDIO_PIN_OUT_HDMI,
217 AUDIO_PIN_OUT_USB,
218 AUDIO_PIN_OUT_USB_EXT,
219 AUDIO_PIN_OUT_USB_HEADSET,
220 AUDIO_PIN_IN_USB_HEADSET,
221 AUDIO_PIN_IN_PENCIL,
222 AUDIO_PIN_IN_UWB,
223 AUDIO_PIN_IN_MIC,
224 AUDIO_PIN_IN_DAUDIO_DEFAULT,
225 AUDIO_PIN_IN_HS_MIC,
226 AUDIO_PIN_IN_LINEIN,
227 AUDIO_PIN_IN_USB_EXT,
228 };
229 uint32_t audioPinInt = GetData<uint32_t>() % audioPin.size();
230 AudioPin hdiPin = audioPin[audioPinInt];
231 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.GetDeviceTypeFromPin(hdiPin);
232
233 AudioDeviceDescriptor deviceInfo;
234 AudioProcessConfig config;
235 config.audioMode = AUDIO_MODE_PLAYBACK;
236 bool lockFlag = GetData<bool>();
237 GetServerPtr()->audioPolicyService_.GetProcessDeviceInfo(config, lockFlag, deviceInfo);
238
239 AudioProcessConfig processInfoConfig;
240 processInfoConfig.audioMode = AUDIO_MODE_RECORD;
241 GetServerPtr()->audioPolicyService_.GetProcessDeviceInfo(processInfoConfig, lockFlag, deviceInfo);
242
243 AudioProcessConfig processConfig;
244 processConfig.audioMode = AUDIO_MODE_RECORD;
245 processConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
246 GetServerPtr()->audioPolicyService_.GetProcessDeviceInfo(processConfig, lockFlag, deviceInfo);
247
248 int32_t type = GetData<int32_t>();
249 std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
250 std::vector<std::shared_ptr<AudioDeviceDescriptor>> preferredDeviceList;
251 preferredDeviceList.push_back(fuzzAudioDeviceDescriptorSptr);
252 GetServerPtr()->audioPolicyService_.GetVoipDeviceInfo(processConfig, deviceInfo, type, preferredDeviceList);
253
254 std::shared_ptr<AudioSharedMemory> buffer;
255 GetServerPtr()->audioPolicyService_.InitSharedVolume(buffer);
256 }
257
AudioPolicyServiceEnhanceFiveFuzzTest()258 void AudioPolicyServiceEnhanceFiveFuzzTest()
259 {
260 Volume vol;
261 AudioVolumeType streamType = GetData<AudioVolumeType>();
262 DeviceType deviceType = GetData<DeviceType>();
263
264 uint64_t sessionID = GetData<uint32_t>();
265 GetServerPtr()->audioPolicyService_.audioCapturerSession_.OnCapturerSessionRemoved(sessionID);
266 GetServerPtr()->audioPolicyService_.audioCapturerSession_.HandleRemainingSource();
267 AudioDeviceDescriptor inputDevice;
268 AudioDeviceDescriptor outputDevice;
269 inputDevice.deviceType_ = DEVICE_TYPE_DEFAULT;
270 outputDevice.deviceType_ = deviceType;
271 GetServerPtr()->audioPolicyService_.audioCapturerSession_.ReloadSourceForDeviceChange(
272 inputDevice, outputDevice, "test");
273 }
274
AudioPolicyServiceEnhanceSixFuzzTest()275 void AudioPolicyServiceEnhanceSixFuzzTest()
276 {
277 AudioEnhancePropertyArray oldPropertyArray;
278 AudioEnhancePropertyArray newPropertyArray;
279 GetServerPtr()->audioPolicyService_.audioCapturerSession_.ReloadSourceForEffect(oldPropertyArray, newPropertyArray);
280
281 std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
282 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
283 descs.push_back(fuzzAudioDeviceDescriptorSptr);
284 AudioDeviceUsage usage = GetData<AudioDeviceUsage>();
285 GetServerPtr()->audioPolicyService_.DeviceFilterByUsageInner(usage, descs);
286
287 uint32_t delayValue = GetData<uint32_t>();
288 uint64_t sendDataSize = GetData<uint64_t>();
289 uint32_t timeStamp = GetData<uint32_t>();
290 GetServerPtr()->audioPolicyService_.OffloadGetRenderPosition(delayValue, sendDataSize, timeStamp);
291
292 uint32_t uid = GetData<uint32_t>();
293 std::string bundleName = "";
294 GetServerPtr()->audioPolicyService_.GetAndSaveClientType(uid, bundleName);
295 }
296
AudioPolicyServiceEnhanceSevenFuzzTest()297 void AudioPolicyServiceEnhanceSevenFuzzTest()
298 {
299 AudioDeviceDescriptor desc;
300 desc.deviceCategory_ = BT_UNWEAR_HEADPHONE;
301 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReason::UNKNOWN;
302 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.OnPreferredStateUpdated(desc, CATEGORY_UPDATE, reason);
303
304 AudioDeviceDescriptor descUpdated;
305 descUpdated.deviceCategory_ = BT_UNWEAR_HEADPHONE;
306 descUpdated.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
307 descUpdated.connectState_ = DEACTIVE_CONNECTED;
308 GetServerPtr()->audioPolicyService_.OnDeviceInfoUpdated(desc, ENABLE_UPDATE);
309 AudioPolicyUtils::GetInstance().WriteServiceStartupError("Audio Tone Load Configuration failed");
310
311 GetServerPtr()->audioPolicyService_.audioVolumeManager_.ringerModeMute_ = false;
312
313 std::string deviceAddress = "";
314 vector<int32_t> sessionIds = {0};
315 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->ConnectA2dpOffload(deviceAddress, sessionIds);
316
317 A2dpOffloadConnectionState currentOffloadConnectionState = GetData<A2dpOffloadConnectionState>();
318 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->
319 audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(currentOffloadConnectionState);
320
321 int32_t sessionId = GetData<uint32_t>();
322 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->IsA2dpOffloadConnecting(sessionId);
323
324 EventFwk::CommonEventData eventData;
325 GetServerPtr()->audioPolicyService_.OnReceiveEvent(eventData);
326 }
327
AudioPolicyServiceEnhanceEightFuzzTest()328 void AudioPolicyServiceEnhanceEightFuzzTest()
329 {
330 std::shared_ptr<AudioDeviceDescriptor> remote = std::make_shared<AudioDeviceDescriptor>();
331 CastType type = GetData<CastType>();
332 GetServerPtr()->audioPolicyService_.audioDeviceCommon_.SwitchActiveA2dpDevice(remote);
333
334 AudioProcessConfig config;
335 GetServerPtr()->audioPolicyService_.NotifyWakeUpCapturerRemoved();
336 GetServerPtr()->audioPolicyService_.IsAbsVolumeSupported();
337
338 AudioModuleInfo moduleInfo;
339 AudioStreamInfo audioStreamInfo;
340 GetServerPtr()->audioPolicyService_.audioDeviceCommon_.ReloadA2dpAudioPort(moduleInfo,
341 DEVICE_TYPE_BLUETOOTH_A2DP, audioStreamInfo, "", "", SOURCE_TYPE_MIC);
342
343 InternalDeviceType internalDeviceType = GetData<InternalDeviceType>();
344
345 std::string anahsShowType = "";
346 GetServerPtr()->audioPolicyService_.OnUpdateAnahsSupport(anahsShowType);
347
348 DeviceType deviceType = GetData<DeviceType>();
349 std::string macAddress = "";
350 std::string deviceName = "";
351 AudioStreamInfo streamInfo;
352 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.ReloadA2dpOffloadOnDeviceChanged(
353 deviceType, macAddress, deviceName, streamInfo);
354 }
355
AudioPolicyServiceEnhanceNineFuzzTest()356 void AudioPolicyServiceEnhanceNineFuzzTest()
357 {
358 DStatusInfo statusInfo;
359 std::vector<std::shared_ptr<AudioDeviceDescriptor>> descForCb;
360 AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN;
361 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.HandleDistributedDeviceUpdate(statusInfo, descForCb, reason);
362 GetServerPtr()->audioPolicyDump_.GetEffectManagerInfo();
363 GetServerPtr()->audioPolicyService_.audioConfigManager_.OnVoipConfigParsed(true);
364 std::unordered_map<AudioAdapterType, std::shared_ptr<PolicyAdapterInfo>> adapterInfoMap;
365 GetServerPtr()->audioPolicyService_.audioConfigManager_.GetAudioAdapterInfos(adapterInfoMap);
366 std::unordered_map<std::string, std::string> volumeGroupData;
367 GetServerPtr()->audioPolicyService_.audioConfigManager_.GetVolumeGroupData(volumeGroupData);
368 GetServerPtr()->audioPolicyService_.audioConfigManager_.GetInterruptGroupData(volumeGroupData);
369 std::unordered_map<ClassType, std::list<AudioModuleInfo>> deviceClassInfo;
370 GetServerPtr()->audioPolicyService_.audioConfigManager_.GetDeviceClassInfo(deviceClassInfo);
371 GlobalConfigs globalConfigs;
372 GetServerPtr()->audioPolicyService_.audioConfigManager_.GetVoipConfig();
373 int32_t clientId = GetData<int32_t>();
374 MessageParcel data;
375 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
376 data.WriteBuffer(RAW_DATA, g_dataSize);
377 data.RewindRead(0);
378 sptr<IRemoteObject> object = data.ReadRemoteObject();
379 AudioDeviceUsage usage = GetData<AudioDeviceUsage>();
380 GetServerPtr()->audioPolicyService_.SetAvailableDeviceChangeCallback(clientId, usage, object, true);
381 GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_FILE_SINK;
382 }
383
AudioPolicyServiceEnhanceTenFuzzTest()384 void AudioPolicyServiceEnhanceTenFuzzTest()
385 {
386 OHOS::AudioStandard::AudioPolicyServiceEnhanceNineFuzzTest();
387 int32_t notificationId = GetData<int32_t>();
388 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CancelSafeVolumeNotification(notificationId);
389
390 std::string dumpString = "";
391 GetServerPtr()->audioPolicyDump_.DevicesInfoDump(dumpString);
392 GetServerPtr()->audioPolicyDump_.GetMicrophoneDescriptorsDump(dumpString);
393 GetServerPtr()->audioPolicyDump_.AudioPolicyParserDump(dumpString);
394 GetServerPtr()->audioPolicyDump_.XmlParsedDataMapDump(dumpString);
395 GetServerPtr()->audioPolicyDump_.EffectManagerInfoDump(dumpString);
396 GetServerPtr()->audioPolicyDump_.MicrophoneMuteInfoDump(dumpString);
397
398 AudioEffectPropertyArray effectPropertyArray;
399 GetServerPtr()->audioPolicyService_.GetSupportedAudioEffectProperty(effectPropertyArray);
400 GetServerPtr()->audioPolicyService_.GetAudioEffectProperty(effectPropertyArray);
401 GetServerPtr()->audioPolicyService_.SetAudioEffectProperty(effectPropertyArray);
402
403 AudioEnhancePropertyArray enhancePropertyArray;
404 GetServerPtr()->audioPolicyService_.GetAudioEnhanceProperty(enhancePropertyArray);
405 GetServerPtr()->audioPolicyService_.SetAudioEnhanceProperty(enhancePropertyArray);
406 }
407
AudioPolicyServiceEnhanceElevenFuzzTest()408 void AudioPolicyServiceEnhanceElevenFuzzTest()
409 {
410 std::string deviceAddress = "deviceAddress";
411 int32_t playingState = GetData<int32_t>();
412 GetServerPtr()->
413 audioPolicyService_.audioA2dpOffloadManager_->OnA2dpPlayingStateChanged(deviceAddress, playingState);
414 std::string deviceAddressEnmpy = "";
415 int32_t playingStateOne = 0;
416 GetServerPtr()->
417 audioPolicyService_.audioA2dpOffloadManager_->OnA2dpPlayingStateChanged(deviceAddressEnmpy, playingStateOne);
418 int32_t playingStateTwo = A2DP_STOPPED;
419 GetServerPtr()->
420 audioPolicyService_.audioA2dpOffloadManager_->OnA2dpPlayingStateChanged(deviceAddressEnmpy, playingStateTwo);
421 int32_t playingStateThree = A2DP_PLAYING;
422 A2dpOffloadConnectionState currentOffloadConnectionState = GetData<A2dpOffloadConnectionState>();
423 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->
424 audioA2dpOffloadFlag_.SetCurrentOffloadConnectedState(currentOffloadConnectionState);
425 GetServerPtr()->
426 audioPolicyService_.audioA2dpOffloadManager_->OnA2dpPlayingStateChanged(deviceAddressEnmpy, playingStateThree);
427 }
428
429 typedef void (*TestFuncs[11])();
430
431 TestFuncs g_testFuncs = {
432 AudioPolicyServiceEnhanceOneFuzzTest,
433 AudioPolicyServiceEnhanceTwoFuzzTest,
434 AudioPolicyServiceEnhanceThreeFuzzTest,
435 AudioPolicyServiceEnhanceFourFuzzTest,
436 AudioPolicyServiceEnhanceFiveFuzzTest,
437 AudioPolicyServiceEnhanceSixFuzzTest,
438 AudioPolicyServiceEnhanceSevenFuzzTest,
439 AudioPolicyServiceEnhanceEightFuzzTest,
440 AudioPolicyServiceEnhanceNineFuzzTest,
441 AudioPolicyServiceEnhanceTenFuzzTest,
442 AudioPolicyServiceEnhanceElevenFuzzTest,
443 };
444
FuzzTest(const uint8_t * rawData,size_t size)445 bool FuzzTest(const uint8_t* rawData, size_t size)
446 {
447 if (rawData == nullptr) {
448 return false;
449 }
450
451 // initialize data
452 RAW_DATA = rawData;
453 g_dataSize = size;
454 g_pos = 0;
455
456 uint32_t code = GetData<uint32_t>();
457 uint32_t len = GetArrLength(g_testFuncs);
458 if (len > 0) {
459 g_testFuncs[code % len]();
460 } else {
461 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
462 }
463
464 return true;
465 }
466 } // namespace AudioStandard
467 } // namesapce OHOS
468
LLVMFuzzerInitialize(int * argc,char *** argv)469 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
470 {
471 OHOS::AudioStandard::AudioFuzzTestGetPermission();
472 return 0;
473 }
474
475 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)476 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
477 {
478 if (size < OHOS::AudioStandard::THRESHOLD) {
479 return 0;
480 }
481
482 OHOS::AudioStandard::FuzzTest(data, size);
483 return 0;
484 }
485