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 "renderer_in_server.h"
20 #include "audio_info.h"
21 #include "i_stream_listener.h"
22 #include "ring_buffer_wrapper.h"
23 #include "../fuzz_utils.h"
24
25 namespace OHOS {
26 namespace AudioStandard {
27 using namespace std;
28 FuzzUtils &g_fuzzUtils = FuzzUtils::GetInstance();
29 const size_t FUZZ_INPUT_SIZE_THRESHOLD = 10;
30
31 typedef void (*TestFuncs)();
32
HandleOperationStartedFuzzTest()33 void HandleOperationStartedFuzzTest()
34 {
35 AudioProcessConfig config;
36 std::weak_ptr<IStreamListener> weakListener = std::weak_ptr<IStreamListener>();
37 auto sharedListener = weakListener.lock();
38 CHECK_AND_RETURN(sharedListener != nullptr);
39 auto RendererInServerPtr = std::make_shared<RendererInServer>(config, weakListener);
40 CHECK_AND_RETURN(RendererInServerPtr != nullptr);
41
42 RendererInServerPtr->standByEnable_ = g_fuzzUtils.GetData<bool>();
43 RendererInServerPtr->HandleOperationStarted();
44 }
45
ReConfigDupStreamCallbackFuzzTest()46 void ReConfigDupStreamCallbackFuzzTest()
47 {
48 AudioProcessConfig config;
49 std::weak_ptr<IStreamListener> weakListener = std::weak_ptr<IStreamListener>();
50 auto sharedListener = weakListener.lock();
51 CHECK_AND_RETURN(sharedListener != nullptr);
52 auto RendererInServerPtr = std::make_shared<RendererInServer>(config, weakListener);
53 CHECK_AND_RETURN(RendererInServerPtr != nullptr);
54
55 RendererInServerPtr->dupTotalSizeInFrame_ = g_fuzzUtils.GetData<size_t>();
56 RendererInServerPtr->ReConfigDupStreamCallback();
57 }
58
DequeueBufferFuzzTest()59 void DequeueBufferFuzzTest()
60 {
61 AudioProcessConfig config;
62 std::weak_ptr<IStreamListener> weakListener = std::weak_ptr<IStreamListener>();
63 auto sharedListener = weakListener.lock();
64 CHECK_AND_RETURN(sharedListener != nullptr);
65 auto RendererInServerPtr = std::make_shared<RendererInServer>(config, weakListener);
66 CHECK_AND_RETURN(RendererInServerPtr != nullptr);
67
68 size_t length = g_fuzzUtils.GetData<size_t>();
69 RendererInServerPtr->DequeueBuffer(length);
70 }
71
WriteMuteDataSysEventFuzzTest()72 void WriteMuteDataSysEventFuzzTest()
73 {
74 AudioProcessConfig config;
75 std::weak_ptr<IStreamListener> weakListener = std::weak_ptr<IStreamListener>();
76 auto sharedListener = weakListener.lock();
77 CHECK_AND_RETURN(sharedListener != nullptr);
78 auto RendererInServerPtr = std::make_shared<RendererInServer>(config, weakListener);
79 CHECK_AND_RETURN(RendererInServerPtr != nullptr);
80
81 BufferDesc bufferDesc;
82 bufferDesc.bufLength = g_fuzzUtils.GetData<size_t>();
83 RendererInServerPtr->isInSilentState_ = g_fuzzUtils.GetData<bool>();
84 RendererInServerPtr->WriteMuteDataSysEvent(bufferDesc);
85 }
86
DoFadingOutFuzzTest()87 void DoFadingOutFuzzTest()
88 {
89 AudioProcessConfig config;
90 std::weak_ptr<IStreamListener> weakListener = std::weak_ptr<IStreamListener>();
91 auto sharedListener = weakListener.lock();
92 CHECK_AND_RETURN(sharedListener != nullptr);
93 auto RendererInServerPtr = std::make_shared<RendererInServer>(config, weakListener);
94 CHECK_AND_RETURN(RendererInServerPtr != nullptr);
95
96 RingBufferWrapper bufferDesc;
97 RendererInServerPtr->DoFadingOut(bufferDesc);
98 }
99
PrepareOutputBufferFuzzTest()100 void PrepareOutputBufferFuzzTest()
101 {
102 AudioProcessConfig config;
103 std::weak_ptr<IStreamListener> weakListener = std::weak_ptr<IStreamListener>();
104 auto sharedListener = weakListener.lock();
105 CHECK_AND_RETURN(sharedListener != nullptr);
106 auto RendererInServerPtr = std::make_shared<RendererInServer>(config, weakListener);
107 CHECK_AND_RETURN(RendererInServerPtr != nullptr);
108
109 RingBufferWrapper bufferDesc;
110 RendererInServerPtr->PrepareOutputBuffer(bufferDesc);
111 }
112
GetAvailableSizeFuzzTest()113 void GetAvailableSizeFuzzTest()
114 {
115 AudioProcessConfig config;
116 std::weak_ptr<IStreamListener> weakListener = std::weak_ptr<IStreamListener>();
117 auto sharedListener = weakListener.lock();
118 CHECK_AND_RETURN(sharedListener != nullptr);
119 auto RendererInServerPtr = std::make_shared<RendererInServer>(config, weakListener);
120 CHECK_AND_RETURN(RendererInServerPtr != nullptr);
121
122 size_t length = g_fuzzUtils.GetData<size_t>();
123 RendererInServerPtr->GetAvailableSize(length);
124 }
125
126 vector<TestFuncs> g_testFuncs = {
127 HandleOperationStartedFuzzTest,
128 ReConfigDupStreamCallbackFuzzTest,
129 DequeueBufferFuzzTest,
130 WriteMuteDataSysEventFuzzTest,
131 DoFadingOutFuzzTest,
132 PrepareOutputBufferFuzzTest,
133 GetAvailableSizeFuzzTest,
134 };
135 } // namespace AudioStandard
136 } // namesapce OHOS
137
138 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)139 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
140 {
141 if (size < OHOS::AudioStandard::FUZZ_INPUT_SIZE_THRESHOLD) {
142 return 0;
143 }
144
145 OHOS::AudioStandard::g_fuzzUtils.fuzzTest(data, size, OHOS::AudioStandard::g_testFuncs);
146 return 0;
147 }