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 #include "audio_spatialization_service.h"
44 #include "../fuzz_utils.h"
45
46 namespace OHOS {
47 namespace AudioStandard {
48 using namespace std;
49
50 FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
51 const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10;
52 typedef void (*TestFuncs)();
53
AudioInterruptZoneManagerGetAudioFocusInfoListFuzzTest()54 void AudioInterruptZoneManagerGetAudioFocusInfoListFuzzTest()
55 {
56 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
57 if (audioInterruptZoneManager == nullptr) {
58 return;
59 }
60 AudioInterruptService service;
61 audioInterruptZoneManager->service_ = &service;
62 if (audioInterruptZoneManager->service_ == nullptr) {
63 return;
64 }
65 std::shared_ptr<AudioInterruptZone> audioInterruptZone = make_shared<AudioInterruptZone>();
66 int32_t zoneId = g_fuzzUtils.GetData<int32_t>();
67 audioInterruptZoneManager->service_->zonesMap_.insert({zoneId, audioInterruptZone});
68 std::string deviceTag = "0";
69 AudioFocusList focusInfoList;
70 audioInterruptZoneManager->GetAudioFocusInfoList(zoneId, deviceTag, focusInfoList);
71 }
72
AudioInterruptZoneManagerForceStopAudioFocusInZoneFuzzTest()73 void AudioInterruptZoneManagerForceStopAudioFocusInZoneFuzzTest()
74 {
75 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
76 if (audioInterruptZoneManager == nullptr) {
77 return;
78 }
79 AudioInterruptService service;
80 audioInterruptZoneManager->service_ = &service;
81 if (audioInterruptZoneManager->service_ == nullptr) {
82 return;
83 }
84 audioInterruptZoneManager->service_->sessionService_ = std::make_shared<AudioSessionService>();
85 audioInterruptZoneManager->service_->handler_ = std::make_shared<AudioPolicyServerHandler>();
86 int32_t zoneId = g_fuzzUtils.GetData<int32_t>();
87 AudioInterrupt interrupt;
88 interrupt.streamId = g_fuzzUtils.GetData<uint32_t>();
89 interrupt.pid = g_fuzzUtils.GetData<int32_t>();
90 audioInterruptZoneManager->ForceStopAudioFocusInZone(zoneId, interrupt);
91 }
92
AudioInterruptZoneManagerForceStopAllAudioFocusInZoneFuzzTest()93 void AudioInterruptZoneManagerForceStopAllAudioFocusInZoneFuzzTest()
94 {
95 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
96 std::shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
97 if (audioInterruptZoneManager == nullptr || zone == nullptr) {
98 return;
99 }
100 AudioInterruptService service;
101 audioInterruptZoneManager->service_ = &service;
102 AudioInterrupt interrupt;
103 AudioFocuState state = ACTIVE;
104 AudioFocuState stateByGetData = g_fuzzUtils.GetData<AudioFocuState>();
105 zone->audioFocusInfoList.push_back(std::make_pair(interrupt, state));
106 zone->audioFocusInfoList.push_back(std::make_pair(interrupt, stateByGetData));
107
108 audioInterruptZoneManager->ForceStopAllAudioFocusInZone(zone);
109 }
110
AudioInterruptZoneManagerInjectInterruptToAudioZoneFuzzTest()111 void AudioInterruptZoneManagerInjectInterruptToAudioZoneFuzzTest()
112 {
113 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
114 if (audioInterruptZoneManager == nullptr) {
115 return;
116 }
117 AudioInterruptService service;
118 audioInterruptZoneManager->service_ = &service;
119 if (audioInterruptZoneManager->service_ == nullptr) {
120 return;
121 }
122 int32_t zoneId = g_fuzzUtils.GetData<int32_t>();
123 audioInterruptZoneManager->service_->zonesMap_.insert({zoneId, std::make_shared<AudioInterruptZone>()});
124 std::string deviceTag = "test_device_tag";
125 AudioInterrupt interrupt;
126 AudioFocuState stateByGetData = g_fuzzUtils.GetData<AudioFocuState>();
127 AudioFocusList interrupts;
128 interrupts.push_back(std::make_pair(interrupt, stateByGetData));
129 audioInterruptZoneManager->InjectInterruptToAudioZone(zoneId, deviceTag, interrupts);
130 }
131
AudioInterruptZoneManagerQueryAudioFocusFromZoneFuzzTest()132 void AudioInterruptZoneManagerQueryAudioFocusFromZoneFuzzTest()
133 {
134 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
135 shared_ptr<AudioInterruptZone> audioInterruptZone = make_shared<AudioInterruptZone>();
136 if (audioInterruptZoneManager == nullptr || audioInterruptZone == nullptr) {
137 return;
138 }
139 AudioInterruptService service;
140 audioInterruptZoneManager->service_ = &service;
141 if (audioInterruptZoneManager->service_ == nullptr) {
142 return;
143 }
144 int32_t zoneId = g_fuzzUtils.GetData<int32_t>();
145 std::string deviceTag = "test_device_tag";
146 AudioInterrupt interrupt;
147 interrupt.deviceTag = deviceTag;
148 AudioFocuState stateByGetData = g_fuzzUtils.GetData<AudioFocuState>();
149 audioInterruptZone->audioFocusInfoList.push_back(std::make_pair(interrupt, stateByGetData));
150 audioInterruptZoneManager->service_->zonesMap_.insert({zoneId, audioInterruptZone});
151
152 audioInterruptZoneManager->QueryAudioFocusFromZone(zoneId, deviceTag);
153 }
154
AudioInterruptZoneManagerTryActiveAudioFocusForZoneFuzzTest()155 void AudioInterruptZoneManagerTryActiveAudioFocusForZoneFuzzTest()
156 {
157 auto audioInterruptZoneManager = std::make_shared<AudioInterruptZoneManager>();
158 shared_ptr<AudioInterruptZone> audioInterruptZone = make_shared<AudioInterruptZone>();
159 if (audioInterruptZoneManager == nullptr || audioInterruptZone == nullptr) {
160 return;
161 }
162 AudioInterruptService service;
163 audioInterruptZoneManager->service_ = &service;
164 if (audioInterruptZoneManager->service_ == nullptr) {
165 return;
166 }
167 int32_t zoneId = g_fuzzUtils.GetData<int32_t>();
168 AudioInterrupt interrupt;
169 AudioFocuState stateByGetData = g_fuzzUtils.GetData<AudioFocuState>();
170 audioInterruptZone->audioFocusInfoList.push_back(std::make_pair(interrupt, stateByGetData));
171 audioInterruptZoneManager->service_->zonesMap_.insert({zoneId, audioInterruptZone});
172 AudioFocusList activeFocusList;
173 activeFocusList.push_back(std::make_pair(interrupt, stateByGetData));
174 bool isClear = g_fuzzUtils.GetData<bool>();
175 if (isClear) {
176 activeFocusList.clear();
177 }
178
179 audioInterruptZoneManager->TryActiveAudioFocusForZone(zoneId, activeFocusList);
180 }
181
182 vector<TestFuncs> g_testFuncs = {
183 AudioInterruptZoneManagerGetAudioFocusInfoListFuzzTest,
184 AudioInterruptZoneManagerForceStopAudioFocusInZoneFuzzTest,
185 AudioInterruptZoneManagerForceStopAllAudioFocusInZoneFuzzTest,
186 AudioInterruptZoneManagerInjectInterruptToAudioZoneFuzzTest,
187 AudioInterruptZoneManagerQueryAudioFocusFromZoneFuzzTest,
188 AudioInterruptZoneManagerTryActiveAudioFocusForZoneFuzzTest,
189 };
190 } // namespace AudioStandard
191 } // namesapce OHOS
192
193 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)194 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
195 {
196 if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) {
197 return 0;
198 }
199
200 OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs);
201 return 0;
202 }
203