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 "oh_audio_buffer.h"
30 #include "../fuzz_utils.h"
31
32 namespace OHOS {
33 namespace AudioStandard {
34 using namespace std;
35
36 FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
37 const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10;
38 const int32_t NUM_1 = 1;
39 const int32_t NUM_1000 = 1000;
40 const int32_t NUM_1024 = 1024;
41
42 typedef void (*TestFuncs)();
43
44 class AudioSharedMemoryFuzz : public AudioSharedMemory {
45 public:
46 explicit AudioSharedMemoryFuzz() = default;
47 virtual ~AudioSharedMemoryFuzz() = default;
GetBase()48 uint8_t *GetBase() { return nullptr; };
GetSize()49 size_t GetSize() { return 0; };
GetFd()50 int GetFd() { return 0; };
GetName()51 std::string GetName() { return ""; };
52 };
53
MarshallingFuzzTest()54 void MarshallingFuzzTest()
55 {
56 shared_ptr<AudioSharedMemoryFuzz> audioSharedMemory =
57 std::make_shared<AudioSharedMemoryFuzz>();
58 if (audioSharedMemory == nullptr) {
59 return;
60 }
61 Parcel parcel;
62 audioSharedMemory->Marshalling(parcel);
63 }
64
UnmarshallingFuzzTest()65 void UnmarshallingFuzzTest()
66 {
67 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
68 AudioBufferHolder selectedAudioBufferHolder =
69 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
70 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
71 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
72 shared_ptr<AudioSharedMemoryFuzz> audioSharedMemory =
73 std::make_shared<AudioSharedMemoryFuzz>();
74 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
75 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
76 if (audioSharedMemory == nullptr) {
77 return;
78 }
79 if (ohAudioBufferBase == nullptr) {
80 return;
81 }
82 Parcel parcel;
83 audioSharedMemory->Marshalling(parcel);
84 audioSharedMemory->Unmarshalling(parcel);
85 ohAudioBufferBase->Marshalling(parcel);
86 ohAudioBufferBase->Unmarshalling(parcel);
87 }
88
GetReadableDataFramesFuzzTest()89 void GetReadableDataFramesFuzzTest()
90 {
91 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
92 AudioBufferHolder selectedAudioBufferHolder =
93 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
94 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
95 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
96 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
97 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
98 if (ohAudioBufferBase == nullptr) {
99 return;
100 }
101 auto basicInfo = std::make_shared<BasicBufferInfo>();
102 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
103 ohAudioBufferBase->GetReadableDataFrames();
104 }
105
SharedMemoryWriteToParcelFuzzTest()106 void SharedMemoryWriteToParcelFuzzTest()
107 {
108 shared_ptr<AudioSharedMemoryFuzz> audioSharedMemory =
109 std::make_shared<AudioSharedMemoryFuzz>();
110 if (audioSharedMemory == nullptr) {
111 return;
112 }
113 MessageParcel parcel;
114 audioSharedMemory->WriteToParcel(audioSharedMemory, parcel);
115 audioSharedMemory->ReadFromParcel(parcel);
116 }
117
BufferBaseReadFromParcelFuzzTest()118 void BufferBaseReadFromParcelFuzzTest()
119 {
120 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
121 AudioBufferHolder selectedAudioBufferHolder =
122 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
123 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
124 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
125 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
126 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
127 if (ohAudioBufferBase == nullptr) {
128 return;
129 }
130 MessageParcel parcel;
131 ohAudioBufferBase->bufferHolder_ = selectedAudioBufferHolder;
132 shared_ptr<AudioSharedMemoryFuzz> dataMem = std::make_shared<AudioSharedMemoryFuzz>();
133 shared_ptr<AudioSharedMemoryFuzz> statusMem = std::make_shared<AudioSharedMemoryFuzz>();
134 ohAudioBufferBase->dataMem_ = dataMem;
135 ohAudioBufferBase->statusInfoMem_ = statusMem;
136 ohAudioBufferBase->WriteToParcel(ohAudioBufferBase, parcel);
137 ohAudioBufferBase->ReadFromParcel(parcel);
138 }
139
GetInitializationInfoFuzzTest()140 void GetInitializationInfoFuzzTest()
141 {
142 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
143 AudioBufferHolder selectedAudioBufferHolder =
144 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
145 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
146 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
147 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
148 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
149 if (ohAudioBufferBase == nullptr) {
150 return;
151 }
152 shared_ptr<AudioSharedMemoryFuzz> dataMem = std::make_shared<AudioSharedMemoryFuzz>();
153 shared_ptr<AudioSharedMemoryFuzz> statusMem = std::make_shared<AudioSharedMemoryFuzz>();
154 ohAudioBufferBase->dataMem_ = dataMem;
155 ohAudioBufferBase->statusInfoMem_ = statusMem;
156 ohAudioBufferBase->GetInitializationInfo();
157 }
158
SetStopFlagFuzzTest()159 void SetStopFlagFuzzTest()
160 {
161 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
162 AudioBufferHolder selectedAudioBufferHolder =
163 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
164 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
165 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
166 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
167 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
168 if (ohAudioBufferBase == nullptr) {
169 return;
170 }
171 bool isNeedStop = g_fuzzUtils.GetData<bool>();
172 auto basicInfo = std::make_shared<BasicBufferInfo>();
173 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
174 ohAudioBufferBase->SetStopFlag(isNeedStop);
175 ohAudioBufferBase->GetStopFlag();
176 }
177
GetSessionIdFuzzTest()178 void GetSessionIdFuzzTest()
179 {
180 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
181 AudioBufferHolder selectedAudioBufferHolder =
182 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
183 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
184 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
185 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
186 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
187 if (ohAudioBufferBase == nullptr) {
188 return;
189 }
190 ohAudioBufferBase->SetSessionId(g_fuzzUtils.GetData<uint32_t>());
191 ohAudioBufferBase->GetSessionId();
192 }
193
GetSizeParameterFuzzTest()194 void GetSizeParameterFuzzTest()
195 {
196 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
197 AudioBufferHolder selectedAudioBufferHolder =
198 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
199 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
200 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
201 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
202 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
203 if (ohAudioBufferBase == nullptr) {
204 return;
205 }
206 ohAudioBufferBase->GetSizeParameter(totalSizeInFrame, byteSizePerFrame);
207 }
208
GetUnderrunCountFuzzTest()209 void GetUnderrunCountFuzzTest()
210 {
211 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
212 AudioBufferHolder selectedAudioBufferHolder =
213 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
214 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
215 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
216 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
217 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
218 if (ohAudioBufferBase == nullptr) {
219 return;
220 }
221 auto basicInfo = std::make_shared<BasicBufferInfo>();
222 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
223 if (ohAudioBufferBase->basicBufferInfo_ == nullptr) {
224 return;
225 }
226 ohAudioBufferBase->basicBufferInfo_->underrunCount = g_fuzzUtils.GetData<uint32_t>();
227 ohAudioBufferBase->GetUnderrunCount();
228 }
229
GetHandleInfoFuzzTest()230 void GetHandleInfoFuzzTest()
231 {
232 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
233 AudioBufferHolder selectedAudioBufferHolder =
234 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
235 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
236 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
237 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
238 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
239 if (ohAudioBufferBase == nullptr) {
240 return;
241 }
242 auto basicInfo = std::make_shared<BasicBufferInfo>();
243 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
244 auto frames = g_fuzzUtils.GetData<uint64_t>();
245 auto nanoTime = g_fuzzUtils.GetData<int64_t>();
246 ohAudioBufferBase->SetHandleInfo(frames, nanoTime);
247 ohAudioBufferBase->GetHandleInfo(frames, nanoTime);
248 }
249
SetStreamVolumeFuzzTest()250 void SetStreamVolumeFuzzTest()
251 {
252 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
253 AudioBufferHolder selectedAudioBufferHolder =
254 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
255 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
256 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
257 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
258 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
259 if (ohAudioBufferBase == nullptr) {
260 return;
261 }
262 auto basicInfo = std::make_shared<BasicBufferInfo>();
263 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
264 ohAudioBufferBase->SetStreamVolume(g_fuzzUtils.GetData<float>());
265 }
266
SetMuteFactorFuzzTest()267 void SetMuteFactorFuzzTest()
268 {
269 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
270 AudioBufferHolder selectedAudioBufferHolder =
271 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
272 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
273 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
274 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
275 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
276 if (ohAudioBufferBase == nullptr) {
277 return;
278 }
279 auto basicInfo = std::make_shared<BasicBufferInfo>();
280 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
281 ohAudioBufferBase->SetMuteFactor(g_fuzzUtils.GetData<float>());
282 ohAudioBufferBase->GetMuteFactor();
283 }
284
SetDuckFactorFuzzTest()285 void SetDuckFactorFuzzTest()
286 {
287 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
288 AudioBufferHolder selectedAudioBufferHolder =
289 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
290 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
291 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
292 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
293 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
294 if (ohAudioBufferBase == nullptr) {
295 return;
296 }
297 auto basicInfo = std::make_shared<BasicBufferInfo>();
298 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
299 ohAudioBufferBase->SetDuckFactor(g_fuzzUtils.GetData<float>());
300 ohAudioBufferBase->GetDuckFactor();
301 }
302
GetBasePosInFrameFuzzTest()303 void GetBasePosInFrameFuzzTest()
304 {
305 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
306 AudioBufferHolder selectedAudioBufferHolder =
307 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
308 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
309 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
310 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
311 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
312 if (ohAudioBufferBase == nullptr) {
313 return;
314 }
315 auto basicInfo = std::make_shared<BasicBufferInfo>();
316 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
317 ohAudioBufferBase->GetBasePosInFrame();
318 }
319
SetCurWriteFrameFuzzTest()320 void SetCurWriteFrameFuzzTest()
321 {
322 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
323 AudioBufferHolder selectedAudioBufferHolder =
324 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
325 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
326 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
327 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
328 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
329 if (ohAudioBufferBase == nullptr) {
330 return;
331 }
332 auto basicInfo = std::make_shared<BasicBufferInfo>();
333 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
334 if (ohAudioBufferBase->basicBufferInfo_ == nullptr) {
335 return;
336 }
337 ohAudioBufferBase->basicBufferInfo_->basePosInFrame = g_fuzzUtils.GetData<uint64_t>();
338 ohAudioBufferBase->basicBufferInfo_->curWriteFrame = g_fuzzUtils.GetData<uint64_t>();
339 ohAudioBufferBase->SetCurWriteFrame(g_fuzzUtils.GetData<uint64_t>());
340 ohAudioBufferBase->SetCurReadFrame(g_fuzzUtils.GetData<uint64_t>());
341 }
342
GetOffsetByFrameFuzzTest()343 void GetOffsetByFrameFuzzTest()
344 {
345 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
346 AudioBufferHolder selectedAudioBufferHolder =
347 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
348 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
349 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
350 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
351 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
352 if (ohAudioBufferBase == nullptr) {
353 return;
354 }
355 auto basicInfo = std::make_shared<BasicBufferInfo>();
356 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
357 if (ohAudioBufferBase->basicBufferInfo_ == nullptr) {
358 return;
359 }
360 ohAudioBufferBase->basicBufferInfo_->basePosInFrame = g_fuzzUtils.GetData<uint64_t>();
361 size_t offset = g_fuzzUtils.GetData<size_t>();
362 ohAudioBufferBase->GetOffsetByFrame(g_fuzzUtils.GetData<uint64_t>(), offset);
363 }
364
GetOffsetByFrameForWriteFuzzTest()365 void GetOffsetByFrameForWriteFuzzTest()
366 {
367 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
368 AudioBufferHolder selectedAudioBufferHolder =
369 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
370 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
371 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
372 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
373 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
374 if (ohAudioBufferBase == nullptr) {
375 return;
376 }
377 auto basicInfo = std::make_shared<BasicBufferInfo>();
378 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
379 if (ohAudioBufferBase->basicBufferInfo_ == nullptr) {
380 return;
381 }
382 ohAudioBufferBase->basicBufferInfo_->basePosInFrame = g_fuzzUtils.GetData<uint64_t>();
383 ohAudioBufferBase->basicBufferInfo_->curReadFrame = g_fuzzUtils.GetData<uint64_t>();
384 size_t offset = g_fuzzUtils.GetData<size_t>();
385 ohAudioBufferBase->GetOffsetByFrameForWrite(g_fuzzUtils.GetData<uint64_t>(), offset);
386 ohAudioBufferBase->GetOffsetByFrameForRead(g_fuzzUtils.GetData<uint64_t>(), offset);
387 }
388
GetBufferByOffsetFuzzTest()389 void GetBufferByOffsetFuzzTest()
390 {
391 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
392 AudioBufferHolder selectedAudioBufferHolder =
393 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
394 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
395 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
396 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
397 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
398 if (ohAudioBufferBase == nullptr) {
399 return;
400 }
401 RingBufferWrapper buffer;
402 size_t offset = g_fuzzUtils.GetData<size_t>();
403 size_t dataLength = g_fuzzUtils.GetData<size_t>();
404 ohAudioBufferBase->GetBufferByOffset(offset, dataLength, buffer);
405 }
406
TryGetContinuousBufferByOffsetFuzzTest()407 void TryGetContinuousBufferByOffsetFuzzTest()
408 {
409 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
410 AudioBufferHolder selectedAudioBufferHolder =
411 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
412 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
413 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
414 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
415 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
416 if (ohAudioBufferBase == nullptr) {
417 return;
418 }
419 BufferDesc bufferDesc;
420 size_t offset = g_fuzzUtils.GetData<size_t>();
421 size_t dataLength = g_fuzzUtils.GetData<size_t>();
422 ohAudioBufferBase->TryGetContinuousBufferByOffset(offset, dataLength, bufferDesc);
423 }
424
GetBufferByFrameFuzzTest()425 void GetBufferByFrameFuzzTest()
426 {
427 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
428 AudioBufferHolder selectedAudioBufferHolder =
429 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
430 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
431 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
432 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
433 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
434 if (ohAudioBufferBase == nullptr) {
435 return;
436 }
437 RingBufferWrapper buffer;
438 auto basicInfo = std::make_shared<BasicBufferInfo>();
439 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
440 if (ohAudioBufferBase->basicBufferInfo_ == nullptr) {
441 return;
442 }
443 ohAudioBufferBase->totalSizeInFrame_ = g_fuzzUtils.GetData<uint32_t>();
444 uint64_t beginPosInFrame = g_fuzzUtils.GetData<uint64_t>();
445 uint64_t sizeInFrame = g_fuzzUtils.GetData<uint64_t>();
446 byteSizePerFrame = (byteSizePerFrame % NUM_1024) + NUM_1;
447 const uint32_t maxFrames = NUM_1000;
448 totalSizeInFrame = totalSizeInFrame % maxFrames;
449 uint32_t totalSizeInByte = totalSizeInFrame * byteSizePerFrame;
450 ohAudioBufferBase->totalSizeInByte_ = totalSizeInByte;
451 auto dataBuffer = std::make_unique<uint8_t[]>(totalSizeInByte);
452 ohAudioBufferBase->dataBase_ = dataBuffer.get();
453 ohAudioBufferBase->GetBufferByFrame(beginPosInFrame, sizeInFrame, buffer);
454 ohAudioBufferBase->basicBufferInfo_->curWriteFrame = beginPosInFrame;
455 ohAudioBufferBase->GetAllWritableBuffer(buffer);
456 ohAudioBufferBase->basicBufferInfo_->curReadFrame = beginPosInFrame;
457 ohAudioBufferBase->GetAllReadableBuffer(buffer);
458 }
459
GetLastWrittenTimeFuzzTest()460 void GetLastWrittenTimeFuzzTest()
461 {
462 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
463 AudioBufferHolder selectedAudioBufferHolder =
464 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
465 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
466 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
467 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
468 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
469 if (ohAudioBufferBase == nullptr) {
470 return;
471 }
472 ohAudioBufferBase->SetLastWrittenTime(g_fuzzUtils.GetData<int64_t>());
473 ohAudioBufferBase->GetLastWrittenTime();
474 }
475
GetSyncReadFrameFuzzTest()476 void GetSyncReadFrameFuzzTest()
477 {
478 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
479 AudioBufferHolder selectedAudioBufferHolder =
480 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
481 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
482 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
483 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
484 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
485 if (ohAudioBufferBase == nullptr) {
486 return;
487 }
488 uint32_t readFrame = g_fuzzUtils.GetData<uint32_t>();
489 ohAudioBufferBase->SetSyncReadFrame(readFrame);
490 ohAudioBufferBase->GetSyncReadFrame();
491 }
492
GetSyncWriteFrameFuzzTest()493 void GetSyncWriteFrameFuzzTest()
494 {
495 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
496 AudioBufferHolder selectedAudioBufferHolder =
497 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
498 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
499 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
500 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
501 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
502 if (ohAudioBufferBase == nullptr) {
503 return;
504 }
505 uint32_t writeFrame = g_fuzzUtils.GetData<uint32_t>();
506 ohAudioBufferBase->SetSyncWriteFrame(writeFrame);
507 ohAudioBufferBase->GetSyncWriteFrame();
508 }
509
GetRestoreInfoFuzzTest()510 void GetRestoreInfoFuzzTest()
511 {
512 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
513 AudioBufferHolder selectedAudioBufferHolder =
514 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
515 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
516 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
517 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
518 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
519 if (ohAudioBufferBase == nullptr) {
520 return;
521 }
522 RestoreInfo restoreInfo;
523 auto basicInfo = std::make_shared<BasicBufferInfo>();
524 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
525 ohAudioBufferBase->SetRestoreInfo(restoreInfo);
526 ohAudioBufferBase->GetRestoreInfo(restoreInfo);
527 }
528
GetTimeStampInfoFuzzTest()529 void GetTimeStampInfoFuzzTest()
530 {
531 int32_t count = static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT)+ NUM_1;
532 AudioBufferHolder selectedAudioBufferHolder =
533 static_cast<AudioBufferHolder>(g_fuzzUtils.GetData<uint8_t>() % count);
534 uint32_t totalSizeInFrame = g_fuzzUtils.GetData<uint32_t>();
535 uint32_t byteSizePerFrame = g_fuzzUtils.GetData<uint32_t>();
536 shared_ptr<OHAudioBufferBase> ohAudioBufferBase =
537 std::make_shared<OHAudioBufferBase>(selectedAudioBufferHolder, totalSizeInFrame, byteSizePerFrame);
538 if (ohAudioBufferBase == nullptr) {
539 return;
540 }
541 uint64_t position = g_fuzzUtils.GetData<uint64_t>();
542 uint64_t timeStamp = g_fuzzUtils.GetData<uint64_t>();
543 auto basicInfo = std::make_shared<BasicBufferInfo>();
544 ohAudioBufferBase->basicBufferInfo_ = basicInfo.get();
545 ohAudioBufferBase->SetTimeStampInfo(position, timeStamp);
546 ohAudioBufferBase->GetTimeStampInfo(position, timeStamp);
547 }
548
549 vector<TestFuncs> g_testFuncs = {
550 MarshallingFuzzTest,
551 UnmarshallingFuzzTest,
552 GetReadableDataFramesFuzzTest,
553 SharedMemoryWriteToParcelFuzzTest,
554 BufferBaseReadFromParcelFuzzTest,
555 GetInitializationInfoFuzzTest,
556 SetStopFlagFuzzTest,
557 GetSessionIdFuzzTest,
558 GetSizeParameterFuzzTest,
559 GetUnderrunCountFuzzTest,
560 GetHandleInfoFuzzTest,
561 SetStreamVolumeFuzzTest,
562 SetMuteFactorFuzzTest,
563 SetDuckFactorFuzzTest,
564 GetBasePosInFrameFuzzTest,
565 SetCurWriteFrameFuzzTest,
566 GetOffsetByFrameFuzzTest,
567 GetOffsetByFrameForWriteFuzzTest,
568 GetBufferByOffsetFuzzTest,
569 TryGetContinuousBufferByOffsetFuzzTest,
570 GetBufferByFrameFuzzTest,
571 GetLastWrittenTimeFuzzTest,
572 GetSyncReadFrameFuzzTest,
573 GetSyncWriteFrameFuzzTest,
574 GetRestoreInfoFuzzTest,
575 GetTimeStampInfoFuzzTest
576 };
577 } // namespace AudioStandard
578 } // namesapce OHOS
579
580 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)581 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
582 {
583 if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) {
584 return 0;
585 }
586
587 OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs);
588 return 0;
589 }
590