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_log.h"
21 #include "audio_info.h"
22 #include "audio_volume.h"
23
24 namespace OHOS {
25 namespace AudioStandard {
26 using namespace std;
27
28 static const uint8_t* RAW_DATA = nullptr;
29 static size_t g_dataSize = 0;
30 static size_t g_pos;
31 const size_t THRESHOLD = 10;
32 const uint8_t TESTSIZE = 27;
33 static int32_t NUM_2 = 2;
34
35 typedef void (*TestFuncs)();
36
37 template<class T>
GetData()38 T GetData()
39 {
40 T object {};
41 size_t objectSize = sizeof(object);
42 if (g_dataSize < g_pos) {
43 return object;
44 }
45 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
46 return object;
47 }
48 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
49 if (ret != EOK) {
50 return {};
51 }
52 g_pos += objectSize;
53 return object;
54 }
55
56 template<class T>
GetArrLength(T & arr)57 uint32_t GetArrLength(T& arr)
58 {
59 if (arr == nullptr) {
60 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
61 return 0;
62 }
63 return sizeof(arr) / sizeof(arr[0]);
64 }
65
66 const vector<AudioStreamType> AudioStreamTypeVec = {
67 STREAM_DEFAULT,
68 STREAM_VOICE_CALL,
69 STREAM_MUSIC,
70 STREAM_RING,
71 STREAM_MEDIA,
72 STREAM_VOICE_ASSISTANT,
73 STREAM_SYSTEM,
74 STREAM_ALARM,
75 STREAM_NOTIFICATION,
76 STREAM_BLUETOOTH_SCO,
77 STREAM_ENFORCED_AUDIBLE,
78 STREAM_DTMF,
79 STREAM_TTS,
80 STREAM_ACCESSIBILITY,
81 STREAM_RECORDING,
82 STREAM_MOVIE,
83 STREAM_GAME,
84 STREAM_SPEECH,
85 STREAM_SYSTEM_ENFORCED,
86 STREAM_ULTRASONIC,
87 STREAM_WAKEUP,
88 STREAM_VOICE_MESSAGE,
89 STREAM_NAVIGATION,
90 STREAM_INTERNAL_FORCE_STOP,
91 STREAM_SOURCE_VOICE_CALL,
92 STREAM_VOICE_COMMUNICATION,
93 STREAM_VOICE_RING,
94 STREAM_VOICE_CALL_ASSISTANT,
95 STREAM_CAMCORDER,
96 STREAM_APP,
97 STREAM_TYPE_MAX,
98 STREAM_ALL,
99 };
100
GetVolumeFuzzTest()101 void GetVolumeFuzzTest()
102 {
103 uint32_t sessionId = 1;
104 uint32_t index = GetData<uint32_t>() % AudioStreamTypeVec.size();
105 int32_t volumeType = AudioStreamTypeVec[index];
106 std::string deviceClass = "speaker";
107 AudioVolume::GetInstance()->SetVgsVolumeSupported(GetData<uint8_t>() % NUM_2);
108 struct VolumeValues volumes = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
109 float volume = AudioVolume::GetInstance()->GetVolume(sessionId, volumeType, deviceClass, &volumes);
110 }
111
GetDoNotDisturbStatusVolumeFuzzTest()112 void GetDoNotDisturbStatusVolumeFuzzTest()
113 {
114 uint32_t index = GetData<uint32_t>() % AudioStreamTypeVec.size();
115 int32_t volumeType = AudioStreamTypeVec[index];
116 int32_t appUid = GetData<int32_t>();
117 uint32_t sessionId = GetData<uint32_t>();
118 AudioVolume* audioVolumeTest = AudioVolume::GetInstance();
119 audioVolumeTest->isDoNotDisturbStatus_ = GetData<uint8_t>() % NUM_2;
120 bool isSystemApp = GetData<uint8_t>() % NUM_2;
121 bool isVKB = GetData<uint8_t>() % NUM_2;
122 StreamVolume streamVolume(0, 0, 0, 0, 0, isSystemApp, 0, isVKB);
123 audioVolumeTest->streamVolume_.insert({sessionId, streamVolume});
124 audioVolumeTest->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
125 }
126
SetDoNotDisturbStatusWhiteListVolumeFuzzTest()127 void SetDoNotDisturbStatusWhiteListVolumeFuzzTest()
128 {
129 std::vector<std::map<std::string, std::string>> doNotDisturbStatusWhiteList;
130 std::map<std::string, std::string> obj;
131 obj["123"] = "1";
132 doNotDisturbStatusWhiteList.push_back(obj);
133 int32_t doNotDisturbStatusVolume = GetData<int32_t>();
134 int32_t volumeType = GetData<int32_t>();
135 int32_t appUid = GetData<int32_t>();
136 int32_t sessionId = GetData<int32_t>();
137 AudioVolume::GetInstance()->SetDoNotDisturbStatusWhiteListVolume(doNotDisturbStatusWhiteList);
138 AudioVolume::GetInstance()->GetDoNotDisturbStatusVolume(volumeType, appUid, sessionId);
139 }
140
SetDoNotDisturbStatusFuzzTest()141 void SetDoNotDisturbStatusFuzzTest()
142 {
143 bool isDoNotDisturbStatus = GetData<uint8_t>() % NUM_2;
144 AudioVolume::GetInstance()->SetDoNotDisturbStatus(isDoNotDisturbStatus);
145 }
146
GetStreamVolumeFuzzTest()147 void GetStreamVolumeFuzzTest()
148 {
149 uint32_t sessionId = GetData<uint32_t>();
150 float lowPowerFactor = GetData<float>();
151 AudioVolume::GetInstance()->SetStreamVolumeLowPowerFactor(sessionId, lowPowerFactor);
152 AudioVolume::GetInstance()->GetStreamVolume(sessionId);
153 }
154
GetHistoryVolumeFuzzTest()155 void GetHistoryVolumeFuzzTest()
156 {
157 uint32_t sessionId = GetData<uint32_t>();
158 AudioVolume::GetInstance()->GetHistoryVolume(sessionId);
159 }
160
SetHistoryVolumeFuzzTest()161 void SetHistoryVolumeFuzzTest()
162 {
163 uint32_t sessionId = GetData<uint32_t>();
164 float volume = GetData<float>();
165 AudioVolume::GetInstance()->SetHistoryVolume(sessionId, volume);
166 AudioVolume::GetInstance()->GetHistoryVolume(sessionId);
167 }
168
SaveAdjustStreamVolumeInfoFuzzTest()169 void SaveAdjustStreamVolumeInfoFuzzTest()
170 {
171 auto audioVolume = std::make_shared<AudioVolume>();
172 if (audioVolume == nullptr) {
173 return;
174 }
175 float volume = GetData<float>();
176 uint32_t sessionId = GetData<uint32_t>();
177 std::string invocationTime = GetTime();
178 int32_t adjustStreamVolumeCount = static_cast<int32_t>(AdjustStreamVolume::DUCK_VOLUME_INFO) + 1;
179 AdjustStreamVolume adjustStreamVolume =
180 static_cast<AdjustStreamVolume>(GetData<uint8_t>() % adjustStreamVolumeCount);
181 uint32_t code = static_cast<uint32_t>(adjustStreamVolume);
182 audioVolume->SaveAdjustStreamVolumeInfo(volume, sessionId, invocationTime, code);
183 }
184
GetStreamVolumeInfoFuzzTest()185 void GetStreamVolumeInfoFuzzTest()
186 {
187 auto audioVolume = std::make_shared<AudioVolume>();
188 if (audioVolume == nullptr) {
189 return;
190 }
191 float volume = GetData<float>();
192 uint32_t sessionId = GetData<uint32_t>();
193 std::string invocationTime = GetTime();
194 uint32_t code = GetData<uint32_t>();
195 audioVolume->SaveAdjustStreamVolumeInfo(volume, sessionId, invocationTime, code);
196 int32_t adjustStreamVolumeCount = static_cast<int32_t>(AdjustStreamVolume::DUCK_VOLUME_INFO) + 1;
197 AdjustStreamVolume adjustStreamVolume =
198 static_cast<AdjustStreamVolume>(GetData<uint8_t>() % adjustStreamVolumeCount);
199 AdjustStreamVolume volumeType = static_cast<AdjustStreamVolume>(adjustStreamVolume);
200 audioVolume->GetStreamVolumeInfo(volumeType);
201 }
202
GetAppVolumeFuzzTest()203 void GetAppVolumeFuzzTest()
204 {
205 AudioVolume* audioVolumeTest = AudioVolume::GetInstance();
206 int32_t appUid = GetData<int32_t>();
207 int32_t adjustStreamVolumeCount = static_cast<int32_t>(AudioVolumeMode::AUDIOSTREAM_VOLUMEMODE_APP_INDIVIDUAL) + 1;
208 AudioVolumeMode mode = static_cast<AudioVolumeMode>(GetData<uint8_t>() % adjustStreamVolumeCount);
209 audioVolumeTest->appVolume_.clear();
210 audioVolumeTest->GetAppVolume(appUid, mode);
211 }
212
SetAppVolumeMuteFuzzTest()213 void SetAppVolumeMuteFuzzTest()
214 {
215 AudioVolume* audioVolumeTest = AudioVolume::GetInstance();
216 int32_t appUid = GetData<int32_t>();
217 bool isMuted = GetData<int32_t>() % NUM_2;
218 audioVolumeTest->appVolume_.clear();
219 audioVolumeTest->streamVolume_.clear();
220 audioVolumeTest->SetAppVolumeMute(appUid, isMuted);
221 }
222
SetAppVolumeFuzzTest()223 void SetAppVolumeFuzzTest()
224 {
225 AudioVolume* audioVolumeTest = AudioVolume::GetInstance();
226 int32_t appUid = GetData<int32_t>();
227 float volume = GetData<float>();
228 int32_t volumeLevel = GetData<int32_t>();
229 bool isMuted = GetData<int32_t>() % NUM_2;
230 AppVolume appVolume(appUid, volume, volumeLevel, isMuted);
231 appVolume.totalVolume_ = GetData<int32_t>();
232 audioVolumeTest->appVolume_.clear();
233 audioVolumeTest->streamVolume_.clear();
234 audioVolumeTest->SetAppVolume(appVolume);
235 }
236
SetDefaultAppVolumeFuzzTest()237 void SetDefaultAppVolumeFuzzTest()
238 {
239 AudioVolume* audioVolumeTest = AudioVolume::GetInstance();
240 int32_t level = GetData<int32_t>();
241 audioVolumeTest->SetDefaultAppVolume(level);
242 }
243
SetSystemVolume1FuzzTest()244 void SetSystemVolume1FuzzTest()
245 {
246 int32_t volumeType = GetData<int32_t>();
247 std::string deviceClass = "speaker";
248 float volume = GetData<float>();
249 int32_t volumeLevel = GetData<int32_t>();
250 bool isMuted = GetData<int32_t>() % NUM_2;
251 SystemVolume systemVolume(volumeType, deviceClass, volume, volumeLevel, isMuted);
252 AudioVolume::GetInstance()->SetSystemVolume(systemVolume);
253 }
254
SetSystemVolume2FuzzTest()255 void SetSystemVolume2FuzzTest()
256 {
257 int32_t volumeType = GetData<int32_t>();
258 std::string deviceClass = "speaker";
259 float volume = GetData<float>();
260 int32_t volumeLevel = GetData<int32_t>();
261 AudioVolume::GetInstance()->SetSystemVolume(volumeType, deviceClass, volume, volumeLevel);
262 }
263
SetSystemVolumeMuteFuzzTest()264 void SetSystemVolumeMuteFuzzTest()
265 {
266 int32_t volumeType = GetData<int32_t>();
267 std::vector<std::string> deviceClassVec = {"speaker", "test"};
268 uint32_t deviceClassCount = GetData<uint32_t>() % deviceClassVec.size();
269 std::string deviceClass = deviceClassVec[deviceClassCount];
270 bool isMuted = GetData<int32_t>() % NUM_2;
271 AudioVolume::GetInstance()->SetSystemVolumeMute(volumeType, deviceClass, isMuted);
272 }
273
ConvertStreamTypeStrToIntFuzzTest()274 void ConvertStreamTypeStrToIntFuzzTest()
275 {
276 std::vector<std::string> streamTypeVec = {"ring", "test"};
277 uint32_t streamTypeCount = GetData<uint32_t>() % streamTypeVec.size();
278 std::string streamType = streamTypeVec[streamTypeCount];
279 AudioVolume::GetInstance()->ConvertStreamTypeStrToInt(streamType);
280 }
281
IsSameVolumeFuzzTest()282 void IsSameVolumeFuzzTest()
283 {
284 float x = GetData<float>();
285 float y = GetData<float>();
286 AudioVolume::GetInstance()->IsSameVolume(x, y);
287 }
288
DumpFuzzTest()289 void DumpFuzzTest()
290 {
291 std::string dumpString = "abc";
292 AudioVolume::GetInstance()->Dump(dumpString);
293 }
294
MonitorFuzzTest()295 void MonitorFuzzTest()
296 {
297 auto audioVolume = std::make_shared<AudioVolume>();
298 if (audioVolume == nullptr) {
299 return;
300 }
301 uint32_t sessionId = GetData<uint32_t>();
302 int32_t streamType = GetData<int32_t>();
303 int32_t streamUsage = GetData<int32_t>();
304 int32_t uid = GetData<int32_t>();
305 int32_t pid = GetData<int32_t>();
306 bool isSystemApp = GetData<int32_t>() % NUM_2;
307 int32_t mode = GetData<int32_t>();
308 bool isVKB = GetData<int32_t>() % NUM_2;
309 StreamVolume streamVolume(sessionId, streamType, streamUsage, uid, pid, isSystemApp, mode, isVKB);
310 audioVolume->streamVolume_.insert({sessionId, streamVolume});
311 audioVolume->Monitor(sessionId, GetData<int32_t>() % NUM_2);
312 }
313
SetFadeoutStateFuzzTest()314 void SetFadeoutStateFuzzTest()
315 {
316 uint32_t streamIndex = GetData<uint32_t>();
317 int32_t fadePauseStateCount = static_cast<int32_t>(FadePauseState::INVALID_STATE) + 1;
318 uint32_t fadeoutState = static_cast<FadePauseState>(GetData<uint8_t>() % fadePauseStateCount);
319 AudioVolume::GetInstance()->SetFadeoutState(streamIndex, fadeoutState);
320 }
321
GetFadeoutStateFuzzTest()322 void GetFadeoutStateFuzzTest()
323 {
324 uint32_t streamIndex = GetData<uint32_t>();
325 AudioVolume::GetInstance()->fadeoutState_.clear();
326 AudioVolume::GetInstance()->GetFadeoutState(streamIndex);
327 }
328
RemoveFadeoutStateFuzzTest()329 void RemoveFadeoutStateFuzzTest()
330 {
331 uint32_t streamIndex = GetData<uint32_t>();
332 int32_t fadePauseStateCount = static_cast<int32_t>(FadePauseState::INVALID_STATE) + 1;
333 uint32_t fadeoutState = static_cast<FadePauseState>(GetData<uint8_t>() % fadePauseStateCount);
334 AudioVolume::GetInstance()->SetFadeoutState(streamIndex, fadeoutState);
335 AudioVolume::GetInstance()->RemoveFadeoutState(streamIndex);
336 }
337
SetStopFadeoutStateFuzzTest()338 void SetStopFadeoutStateFuzzTest()
339 {
340 uint32_t streamIndex = GetData<uint32_t>();
341 int32_t fadePauseStateCount = static_cast<int32_t>(FadePauseState::INVALID_STATE) + 1;
342 uint32_t fadeoutState = static_cast<FadePauseState>(GetData<uint8_t>() % fadePauseStateCount);
343 AudioVolume::GetInstance()->SetStopFadeoutState(streamIndex, fadeoutState);
344 }
345
GetStopFadeoutStateFuzzTest()346 void GetStopFadeoutStateFuzzTest()
347 {
348 auto audioVolume = std::make_shared<AudioVolume>();
349 if (audioVolume == nullptr) {
350 return;
351 }
352 uint32_t streamIndex = GetData<uint32_t>();
353 audioVolume->GetStopFadeoutState(streamIndex);
354 }
355
RemoveStopFadeoutStateFuzzTest()356 void RemoveStopFadeoutStateFuzzTest()
357 {
358 uint32_t streamIndex = GetData<uint32_t>();
359 int32_t fadePauseStateCount = static_cast<int32_t>(FadePauseState::INVALID_STATE) + 1;
360 uint32_t fadeoutState = static_cast<FadePauseState>(GetData<uint8_t>() % fadePauseStateCount);
361 AudioVolume::GetInstance()->SetStopFadeoutState(streamIndex, fadeoutState);
362 AudioVolume::GetInstance()->RemoveStopFadeoutState(streamIndex);
363 }
364
SetVgsVolumeSupportedFuzzTest()365 void SetVgsVolumeSupportedFuzzTest()
366 {
367 uint32_t sessionId = GetData<uint32_t>();
368 int32_t volumeType = GetData<int32_t>();
369 std::string deviceClass = "speaker";
370 AudioVolume::GetInstance()->SetVgsVolumeSupported(GetData<uint8_t>() % NUM_2);
371 }
372
373 TestFuncs g_testFuncs[TESTSIZE] = {
374 GetVolumeFuzzTest,
375 GetDoNotDisturbStatusVolumeFuzzTest,
376 SetDoNotDisturbStatusWhiteListVolumeFuzzTest,
377 SetDoNotDisturbStatusFuzzTest,
378 GetStreamVolumeFuzzTest,
379 GetHistoryVolumeFuzzTest,
380 SetHistoryVolumeFuzzTest,
381 SaveAdjustStreamVolumeInfoFuzzTest,
382 GetStreamVolumeInfoFuzzTest,
383 GetAppVolumeFuzzTest,
384 SetAppVolumeMuteFuzzTest,
385 SetAppVolumeFuzzTest,
386
387 SetDefaultAppVolumeFuzzTest,
388 SetSystemVolume1FuzzTest,
389 SetSystemVolume2FuzzTest,
390 SetSystemVolumeMuteFuzzTest,
391 ConvertStreamTypeStrToIntFuzzTest,
392 IsSameVolumeFuzzTest,
393 DumpFuzzTest,
394 MonitorFuzzTest,
395 SetFadeoutStateFuzzTest,
396 GetFadeoutStateFuzzTest,
397 RemoveFadeoutStateFuzzTest,
398 SetStopFadeoutStateFuzzTest,
399 GetStopFadeoutStateFuzzTest,
400 RemoveStopFadeoutStateFuzzTest,
401 SetVgsVolumeSupportedFuzzTest,
402 };
403
FuzzTest(const uint8_t * rawData,size_t size)404 void FuzzTest(const uint8_t* rawData, size_t size)
405 {
406 if (rawData == nullptr) {
407 return;
408 }
409
410 // initialize data
411 RAW_DATA = rawData;
412 g_dataSize = size;
413 g_pos = 0;
414
415 uint32_t code = GetData<uint32_t>();
416 uint32_t len = GetArrLength(g_testFuncs);
417 if (len > 0) {
418 g_testFuncs[code % len]();
419 } else {
420 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
421 }
422
423 return;
424 }
425 } // namespace AudioStandard
426 } // namesapce OHOS
427
428 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)429 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
430 {
431 if (size < OHOS::AudioStandard::THRESHOLD) {
432 return 0;
433 }
434
435 OHOS::AudioStandard::FuzzTest(data, size);
436 return 0;
437 }
438