diff --git a/test/BUILD.gn b/test/BUILD.gn index 7522dc425c01f04f4c906e6a5d13cb800f747cb9..2f9af12c64846bae7b04a69bb19e56fd0c9ff776 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -266,6 +266,7 @@ group("audio_fuzz_test") { "fuzztest/audioserverbalance_fuzzer:fuzztest", "fuzztest/audioservermore_fuzzer:fuzztest", "fuzztest/audioserverproxy_fuzzer:fuzztest", + "fuzztest/audioserversup_fuzzer:fuzztest", "fuzztest/audioservice_fuzzer:fuzztest", # "fuzztest/audioserviceclient_fuzzer:fuzztest", "fuzztest/audioservicecommon_fuzzer:fuzztest", @@ -273,6 +274,7 @@ group("audio_fuzz_test") { "fuzztest/audioserviceserversrc_fuzzer:fuzztest", "fuzztest/audioserviceserversrcenhance_fuzzer:fuzztest", "fuzztest/audioservicestub_fuzzer:fuzztest", + "fuzztest/audioservicesup_fuzzer:fuzztest", "fuzztest/audiosession_fuzzer:fuzztest", "fuzztest/audiosessionservice_fuzzer:fuzztest", "fuzztest/audiosocketthread_fuzzer:fuzztest", diff --git a/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp b/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp index 5140345861473afa9b7ada6c495010b772f69f00..1ca2f2d3ec5fe470873951b3fd8a046770ffcecf 100644 --- a/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp +++ b/test/fuzztest/audioresourceservice_fuzzer/audio_resource_service_fuzzer.cpp @@ -26,6 +26,9 @@ using namespace std; FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy"; const int32_t TEST_RTG_ID = 2; +const int32_t NUM_1 = 1; +const int32_t NUM_2 = 2; +const int32_t NUM_3 = 3; typedef void (*TestFuncs)(); @@ -39,6 +42,16 @@ public: int Dump(int fd, const std::vector &args) { return 0; }; }; +class AudioWorkgroupCallbackForMonitorTest : public AudioWorkgroupCallbackForMonitor { +public: + AudioWorkgroupCallbackForMonitorTest() = default; + ~AudioWorkgroupCallbackForMonitorTest() override + { + AUDIO_INFO_LOG("AudioWorkgroupCallbackForMonitorTest destroyed"); + } + void OnWorkgroupChange(const AudioWorkgroupChangeInfo &info) override {} +}; + void ResourceServiceCreateAudioWorkgroupFuzzTest() { int32_t pid = g_fuzzUtils.GetData(); @@ -90,29 +103,153 @@ void ResourceServiceReleaseWorkgroupDeathRecipientFuzzTest() { std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); sptr remoteObj = new RemoteObjectTestStub(); + AudioResourceService::GetInstance()->deathRecipientMap_[workgroup] = + std::make_pair(remoteObj, new AudioResourceService::AudioWorkgroupDeathRecipient()); AudioResourceService::GetInstance()->ReleaseWorkgroupDeathRecipient(workgroup, remoteObj); } void ResourceServiceWorkgroupRendererMonitorFuzzTest() { + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + workgroup->callback = std::make_shared(); + if (!workgroup->callback) { + return; + } auto audioResourceService = AudioResourceService::GetInstance(); int32_t testPid = g_fuzzUtils.GetData(); if (audioResourceService == nullptr) { return; } + int32_t pid = g_fuzzUtils.GetData(); audioResourceService->audioWorkgroupMap_[testPid].permission = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[testPid].groups[pid] = {workgroup}; audioResourceService->WorkgroupRendererMonitor(testPid, true); } void ResourceServiceDumpAudioWorkgroupMapFuzzTest() { + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } auto audioResourceService = AudioResourceService::GetInstance(); if (audioResourceService == nullptr) { return; } + int32_t pid = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[0].groups[pid] = {workgroup}; audioResourceService->DumpAudioWorkgroupMap(); } +void AudioWorkgroupCheckFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[TEST_RTG_ID] = {workgroup}; + audioResourceService->AudioWorkgroupCheck(pid); + pid = g_fuzzUtils.GetData() + 1; + audioResourceService->AudioWorkgroupCheck(pid); +} + +void CreateAudioWorkgroupFuzzTest() +{ + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + sptr object = new RemoteObjectTestStub(); + if (object == nullptr) { + return; + } + audioResourceService->CreateAudioWorkgroup(pid, object); +} + +void ReleaseAudioWorkgroupFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId] = {workgroup}; + audioResourceService->ReleaseAudioWorkgroup(pid, workgroupId); +} + +void AddThreadToGroupFuzzTest() +{ + std::shared_ptr workgroup1 = std::make_shared(TEST_RTG_ID); + std::shared_ptr workgroup2 = std::make_shared(TEST_RTG_ID); + std::shared_ptr workgroup3 = std::make_shared(TEST_RTG_ID); + std::shared_ptr workgroup4 = std::make_shared(TEST_RTG_ID); + if (!workgroup1 || !workgroup2 || !workgroup3 || !workgroup4) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + int32_t tokenId = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId] = {workgroup1}; + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId + NUM_1] = {workgroup2}; + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId + NUM_2] = {workgroup3}; + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId + NUM_3] = {workgroup4}; + audioResourceService->AddThreadToGroup(pid, workgroupId, tokenId); + audioResourceService->RemoveThreadFromGroup(pid, workgroupId, tokenId); +} + +void StartGroupFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + uint64_t startTime = g_fuzzUtils.GetData(); + uint64_t deadlineTime = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId] = {workgroup}; + audioResourceService->StartGroup(pid, workgroupId, startTime, deadlineTime); + audioResourceService->StopGroup(pid, workgroupId); +} + +void GetThreadsNumPerProcessFuzzTest() +{ + std::shared_ptr workgroup = std::make_shared(TEST_RTG_ID); + if (!workgroup) { + return; + } + auto audioResourceService = AudioResourceService::GetInstance(); + if (audioResourceService == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + int32_t workgroupId = g_fuzzUtils.GetData(); + audioResourceService->audioWorkgroupMap_[pid].groups[workgroupId] = {workgroup}; + audioResourceService->GetThreadsNumPerProcess(pid); +} + vector g_testFuncs = { ResourceServiceCreateAudioWorkgroupFuzzTest, ResourceServiceAudioWorkgroupDeathRecipientFuzzTest, @@ -121,6 +258,12 @@ vector g_testFuncs = { ResourceServiceReleaseWorkgroupDeathRecipientFuzzTest, ResourceServiceWorkgroupRendererMonitorFuzzTest, ResourceServiceDumpAudioWorkgroupMapFuzzTest, + AudioWorkgroupCheckFuzzTest, + CreateAudioWorkgroupFuzzTest, + ReleaseAudioWorkgroupFuzzTest, + AddThreadToGroupFuzzTest, + StartGroupFuzzTest, + GetThreadsNumPerProcessFuzzTest, }; } // namespace AudioStandard diff --git a/test/fuzztest/audioserversup_fuzzer/BUILD.gn b/test/fuzztest/audioserversup_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..366bb9f9d8d49afed720250eb8296ba85bedc571 --- /dev/null +++ b/test/fuzztest/audioserversup_fuzzer/BUILD.gn @@ -0,0 +1,66 @@ +# Copyright (c) 2022-2023 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioServerSupFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audioserversup_fuzzer" + + include_dirs = [ + "../../../frameworks/native/audioinnercall/include", + "../../../services/audio_service/server/include", + "../../../services/audio_policy/client/include", + ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ "audio_server_sup_fuzzer.cpp" ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../services/audio_service/idl:audio_framework_interface", + "../../../services/audio_policy:audio_policy_client", + "../../../services/audio_service:audio_service_static", + ] + external_deps = [ + "access_token:libaccesstoken_sdk", + "c_utils:utils", + "hdf_core:libhdi", + "hdf_core:libpub_utils", + "hilog:libhilog", + "ipc:ipc_single", + "qos_manager:concurrent_task_client", + "safwk:system_ability_fwk", + ] + + defines = [] + if (use_libfuzzer || use_clang_coverage) { + defines += [ "TEST_COVERAGE" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioServerSupFuzzTest" ] +} diff --git a/test/fuzztest/audioserversup_fuzzer/audio_server_sup_fuzzer.cpp b/test/fuzztest/audioserversup_fuzzer/audio_server_sup_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..38d166b407ebc2811ebcf982595b3c2bd60d11f5 --- /dev/null +++ b/test/fuzztest/audioserversup_fuzzer/audio_server_sup_fuzzer.cpp @@ -0,0 +1,518 @@ +/* +* Copyright (c) 2025 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "audio_server.h" +#include "audio_policy_manager_listener_stub_impl.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); + +const int32_t SYSTEM_ABILITY_ID = 3001; +const int32_t MEDIA_SERVICE_UID = 1013; +const bool RUN_ON_CREATE = false; +const std::string PCM_DUMP_KEY = "PCM_DUMP"; + +typedef void (*TestFuncs)(); + +void AudioServerSetReleaseFlagFuzzTest() +{ + bool flag = g_fuzzUtils.GetData(); + uint32_t sessionId = g_fuzzUtils.GetData(); + std::shared_ptr pipeinfoGuard = std::make_shared(sessionId); + if (pipeinfoGuard == nullptr) { + return; + } + pipeinfoGuard->SetReleaseFlag(flag); +} + +void RemoveRendererDataTransferCallbackFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + int32_t pid = g_fuzzUtils.GetData(); + auto callback = make_shared(); + if (callback == nullptr) { + return; + } + audioServer->audioDataTransferCbMap_[pid] = callback; + audioServer->RemoveRendererDataTransferCallback(pid); +} + +void RegisterDataTransferCallbackFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + sptr listener = new (std::nothrow) AudioPolicyManagerListenerStubImpl(); + if (listener == nullptr) { + return; + } + sptr object = listener->AsObject(); + if (object == nullptr) { + AUDIO_INFO_LOG("AudioServer:set listener object is nullptr"); + return; + } + audioServer->RegisterDataTransferCallback(object); +} + +void UnregisterDataTransferMonitorParamFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + int32_t callbackId = g_fuzzUtils.GetData(); + audioServer->UnregisterDataTransferMonitorParam(callbackId); +} + +void OnDataTransferStateChangeFuzzTest() +{ + std::shared_ptr callback = + std::make_shared(); + if (callback == nullptr) { + return; + } + int32_t callbackId = g_fuzzUtils.GetData(); + AudioRendererDataTransferStateChangeInfo info; + callback->OnDataTransferStateChange(callbackId, info); +} + +void GetPcmDumpParameterFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::vector subKeys; + std::string subKey = "test"; + subKeys.push_back(subKey); + std::vector> result; + std::pair pair; + pair.first = "test"; + pair.second = "test"; + result.push_back(pair); + audioServer->GetPcmDumpParameter(subKeys, result); +} + +void InnerCheckCaptureLimitFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + #ifdef HAS_FEATURE_INNERCAPTURER + AudioPlaybackCaptureConfig config; + int32_t innerCapId = g_fuzzUtils.GetData(); + audioServer->InnerCheckCaptureLimit(config, innerCapId); + #endif +} + +void SetParameterCallbackFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + sptr listener = new (std::nothrow) AudioPolicyManagerListenerStubImpl(); + if (listener == nullptr) { + return; + } + sptr object = listener->AsObject(); + if (object == nullptr) { + AUDIO_INFO_LOG("AudioServer:set listener object is nullptr"); + return; + } + audioServer->SetParameterCallback(object); +} + +void SetWakeupSourceCallbackFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + sptr listener = new (std::nothrow) AudioPolicyManagerListenerStubImpl(); + if (listener == nullptr) { + return; + } + sptr object = listener->AsObject(); + if (object == nullptr) { + AUDIO_INFO_LOG("AudioServer:set listener object is nullptr"); + return; + } + audioServer->SetWakeupSourceCallback(object); +} + +void CheckInnerRecorderPermissionFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.capturerInfo.sourceType = SOURCE_TYPE_REMOTE_CAST; + audioServer->CheckInnerRecorderPermission(config); + config.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE; + config.innerCapMode = MODERN_INNER_CAP; + audioServer->CheckInnerRecorderPermission(config); +} + +void SetForegroundListFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::string foreground = "test"; + std::vector list; + list.push_back(foreground); + audioServer->SetForegroundList(list); +} + +void SendInterruptEventToAudioServerFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioServer->SendInterruptEventToAudioServer(sessionId, interruptEvent); +} + +void CheckVoiceCallRecorderPermissionFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + Security::AccessToken::AccessTokenID tokenId = Security::AccessToken::INVALID_TOKENID; + audioServer->CheckVoiceCallRecorderPermission(tokenId); +} + +void NotifyStreamVolumeChangedFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + int32_t streamType = g_fuzzUtils.GetData(); + float volume = g_fuzzUtils.GetData(); + audioServer->NotifyStreamVolumeChanged(streamType, volume); +} + +void ResetRouteForDisconnectFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + int32_t type = g_fuzzUtils.GetData(); + audioServer->ResetRouteForDisconnect(type); +} + +void GetMaxAmplitudeFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + bool isOutputDevice = g_fuzzUtils.GetData(); + std::string deviceClass = "test"; + int32_t sourceType = g_fuzzUtils.GetData(); + float maxAmplitude = g_fuzzUtils.GetData(); + audioServer->GetMaxAmplitude(isOutputDevice, deviceClass, sourceType, maxAmplitude); +} + +void ResetAudioEndpointFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + audioServer->ResetAudioEndpoint(); +} + +void ReportEventFuzzTest() +{ + std::shared_ptr callback = + std::make_shared(); + if (callback == nullptr) { + return; + } + int32_t callbackId = g_fuzzUtils.GetData(); + AudioRendererDataTransferStateChangeInfo info; + info.stateChangeType = DATA_TRANS_STOP; + callback->OnDataTransferStateChange(callbackId, info); +} + +void GetOfflineAudioEffectChainsFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::string effectChain = "test"; + std::vector effectChains; + effectChains.push_back(effectChain); + audioServer->GetOfflineAudioEffectChains(effectChains); +} + +void GetAllSinkInputsFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::vector sinkInputs = {}; + audioServer->GetAllSinkInputs(sinkInputs); +} + +void DestroyHdiPortFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + uint32_t id = g_fuzzUtils.GetData(); + audioServer->DestroyHdiPort(id); +} + +void SetBtHdiInvalidStateFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + audioServer->SetBtHdiInvalidState(); +} + +void ForceStopAudioStreamFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + vector stopTypes = { + STOP_ALL, + STOP_RENDER, + STOP_RECORD + }; + int32_t audioType = stopTypes[g_fuzzUtils.GetData() % stopTypes.size()]; + audioServer->ForceStopAudioStream(audioType); +} + +void GetExtraParametersInnerFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::string mainKey = PCM_DUMP_KEY; + audioServer->isAudioParameterParsed_ = g_fuzzUtils.GetData(); + std::vector subKeys = {"key1", "key2"}; + std::vector> result; + audioServer->audioParameterKeys = { + { + PCM_DUMP_KEY, { + {"Key1", {"Value1", "Value2"}} + } + } + }; + audioServer->GetExtraParametersInner(mainKey, subKeys, result); +} + +void GetAudioParameterInnerFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + std::string networkId = LOCAL_NETWORK_ID; + vector keys = { + NONE, + VOLUME, + INTERRUPT, + PARAM_KEY_STATE, + A2DP_SUSPEND_STATE, + BT_HEADSET_NREC, + BT_WBS, + A2DP_OFFLOAD_STATE, + GET_DP_DEVICE_INFO, + GET_PENCIL_INFO, + GET_UWB_INFO, + USB_DEVICE, + PERF_INFO, + MMI, + PARAM_KEY_LOWPOWER, + }; + AudioParamKey key = keys[g_fuzzUtils.GetData() % keys.size()]; + std::string condition = ""; + audioServer->GetAudioParameterInner(networkId, key, condition); +} + +void SetAudioMonoStateFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + bool audioMono = g_fuzzUtils.GetData(); + audioServer->SetAudioMonoState(audioMono); +} + +void SetAudioBalanceValueFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + float rawBalance = g_fuzzUtils.GetData(); + float audioBalance = std::clamp(rawBalance, -1.0f, 1.0f); + audioServer->SetAudioBalanceValue(audioBalance); +} + +void ResetRecordConfigFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE; + config.callerUid = g_fuzzUtils.GetData(); + audioServer->ResetRecordConfig(config); + config.callerUid = MEDIA_SERVICE_UID; + audioServer->ResetRecordConfig(config); +} + +void CheckRendererFormatFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.rendererInfo.streamUsage = static_cast(STREAM_USAGE_MAX + 1); + audioServer->CheckRendererFormat(config); +} + +void CheckStreamInfoFormatFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.streamInfo.samplingRate = g_fuzzUtils.GetData(); + config.streamInfo.format = static_cast(SAMPLE_F32LE + 1); + audioServer->CheckStreamInfoFormat(config); + config.streamInfo.format = g_fuzzUtils.GetData(); + config.streamInfo.encoding = static_cast(ENCODING_EAC3 + 1); + audioServer->CheckStreamInfoFormat(config); + config.streamInfo.encoding = g_fuzzUtils.GetData(); + config.streamInfo.channelLayout = static_cast(CH_LAYOUT_HOA_ORDER3_FUMA + 1); + audioServer->CheckStreamInfoFormat(config); + config.streamInfo.channelLayout = g_fuzzUtils.GetData(); + config.audioMode = AUDIO_MODE_PLAYBACK; + config.streamInfo.channels = static_cast(CHANNEL_16 + 1); + audioServer->CheckStreamInfoFormat(config); + config.audioMode = AUDIO_MODE_RECORD; + config.streamInfo.channels = static_cast(CHANNEL_6 + 1); + audioServer->CheckStreamInfoFormat(config); + config.streamInfo.channels = g_fuzzUtils.GetData(); + audioServer->CheckStreamInfoFormat(config); +} + +void CheckRecorderFormatFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.capturerInfo.sourceType = static_cast(SOURCE_TYPE_LIVE + 1); + audioServer->CheckRecorderFormat(config); + config.capturerInfo.capturerFlags = AUDIO_FLAG_MMAP; + audioServer->CheckRecorderFormat(config); +} + +void CheckConfigFormatFuzzTest() +{ + std::shared_ptr audioServer = std::make_shared(SYSTEM_ABILITY_ID, RUN_ON_CREATE); + if (audioServer == nullptr) { + return; + } + AudioProcessConfig config; + config.audioMode = g_fuzzUtils.GetData(); + audioServer->CheckConfigFormat(config); + config.audioMode = static_cast(AUDIO_MODE_RECORD + 1); + audioServer->CheckConfigFormat(config); +} + +vector g_testFuncs = { + AudioServerSetReleaseFlagFuzzTest, + RemoveRendererDataTransferCallbackFuzzTest, + RegisterDataTransferCallbackFuzzTest, + UnregisterDataTransferMonitorParamFuzzTest, + OnDataTransferStateChangeFuzzTest, + GetPcmDumpParameterFuzzTest, + InnerCheckCaptureLimitFuzzTest, + SetParameterCallbackFuzzTest, + SetWakeupSourceCallbackFuzzTest, + CheckInnerRecorderPermissionFuzzTest, + SetForegroundListFuzzTest, + SendInterruptEventToAudioServerFuzzTest, + CheckVoiceCallRecorderPermissionFuzzTest, + NotifyStreamVolumeChangedFuzzTest, + ResetRouteForDisconnectFuzzTest, + GetMaxAmplitudeFuzzTest, + ResetAudioEndpointFuzzTest, + ReportEventFuzzTest, + GetOfflineAudioEffectChainsFuzzTest, + GetAllSinkInputsFuzzTest, + DestroyHdiPortFuzzTest, + SetBtHdiInvalidStateFuzzTest, + ForceStopAudioStreamFuzzTest, + GetExtraParametersInnerFuzzTest, + GetAudioParameterInnerFuzzTest, + SetAudioMonoStateFuzzTest, + SetAudioBalanceValueFuzzTest, + ResetRecordConfigFuzzTest, + CheckRendererFormatFuzzTest, + CheckStreamInfoFormatFuzzTest, + CheckRecorderFormatFuzzTest, + CheckConfigFormatFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/audioserversup_fuzzer/project.xml b/test/fuzztest/audioserversup_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..66e1dcac475475fb101b6f8670ec699e6e9696aa --- /dev/null +++ b/test/fuzztest/audioserversup_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + diff --git a/test/fuzztest/audioservicesup_fuzzer/BUILD.gn b/test/fuzztest/audioservicesup_fuzzer/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..2b3adc5bf42a59470322ccac7de84560d2c9b44f --- /dev/null +++ b/test/fuzztest/audioservicesup_fuzzer/BUILD.gn @@ -0,0 +1,59 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/config/features.gni") +import("//build/test.gni") +import("../../../config.gni") + +ohos_fuzztest("AudioServiceSupFuzzTest") { + module_out_path = "audio_framework/audio_framework_route" + fuzz_config_file = "../audioservicesup_fuzzer" + + include_dirs = [ "../../../services/audio_service/server/include" ] + + cflags = [ + "-g", + "-O0", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fno-access-control", + ] + + sources = [ "audio_service_sup_fuzzer.cpp" ] + + configs = [ "../../../services/audio_service:audio_service_config" ] + cflags_cc = [ "-std=c++20" ] + + deps = [ + "../../../services/audio_service/idl:audio_framework_interface", + "../../../services/audio_service:audio_process_service_static", + ] + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "ipc:ipc_single", + ] + + defines = [] + if (audio_framework_feature_inner_capturer) { + defines += [ "HAS_FEATURE_INNERCAPTURER" ] + } + if (audio_framework_feature_low_latency) { + defines += [ "SUPPORT_LOW_LATENCY" ] + } +} + +group("fuzztest") { + testonly = true + deps = [ ":AudioServiceSupFuzzTest" ] +} diff --git a/test/fuzztest/audioservicesup_fuzzer/audio_service_sup_fuzzer.cpp b/test/fuzztest/audioservicesup_fuzzer/audio_service_sup_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fa42658a9d01c8b97254a571d1b63ac52fcbd375 --- /dev/null +++ b/test/fuzztest/audioservicesup_fuzzer/audio_service_sup_fuzzer.cpp @@ -0,0 +1,143 @@ +/* +* Copyright (c) 2025 Huawei Device Co., Ltd. +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include + +#include "audio_log.h" +#include "audio_service.h" +#include "../fuzz_utils.h" + +namespace OHOS { +namespace AudioStandard { +using namespace std; + +FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance(); + +typedef void (*TestFuncs)(); + +void DisableLoopbackFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + audioService->DisableLoopback(); +} + +void SendInterruptEventToAudioServiceFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); +} + +void UpdateResumeInterruptEventMapFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->resumeInterruptEventMap_[sessionId] = interruptEvent; + interruptEvent.hintType = INTERRUPT_HINT_RESUME; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); +} + +void UpdatePauseInterruptEventMapFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->pauseInterruptEventMap_[sessionId] = interruptEvent; + interruptEvent.hintType = INTERRUPT_HINT_PAUSE; + audioService->SendInterruptEventToAudioService(sessionId, interruptEvent); +} + +void RemoveResumeInterruptEventMapFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->resumeInterruptEventMap_[sessionId] = interruptEvent; + audioService->RemoveResumeInterruptEventMap(sessionId); +} + +void IsStreamInterruptResumeFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->resumeInterruptEventMap_[sessionId] = interruptEvent; + audioService->IsStreamInterruptResume(sessionId); +} + +void RemovePauseInterruptEventMapFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->pauseInterruptEventMap_[sessionId] = interruptEvent; + audioService->RemovePauseInterruptEventMap(sessionId); +} + +void IsStreamInterruptPauseFuzzTest() +{ + shared_ptr audioService = make_shared(); + if (audioService == nullptr) { + return; + } + uint32_t sessionId = g_fuzzUtils.GetData(); + InterruptEventInternal interruptEvent; + audioService->pauseInterruptEventMap_[sessionId] = interruptEvent; + audioService->IsStreamInterruptPause(sessionId); +} + +vector g_testFuncs = { + DisableLoopbackFuzzTest, + SendInterruptEventToAudioServiceFuzzTest, + UpdateResumeInterruptEventMapFuzzTest, + UpdatePauseInterruptEventMapFuzzTest, + RemoveResumeInterruptEventMapFuzzTest, + IsStreamInterruptResumeFuzzTest, + RemovePauseInterruptEventMapFuzzTest, + IsStreamInterruptPauseFuzzTest, +}; + +} // namespace AudioStandard +} // namesapce OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) +{ + OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs); + return 0; +} diff --git a/test/fuzztest/audioservicesup_fuzzer/project.xml b/test/fuzztest/audioservicesup_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..12af881228dc64359f27a247a1848e7f20449391 --- /dev/null +++ b/test/fuzztest/audioservicesup_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 30 + + 4096 + +