1 /*
2 * Copyright (c) 2024-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 "audio_log.h"
17 #include "audio_zone.h"
18 #include "audio_zone_client_manager.h"
19 #include "audio_zone_service.h"
20
21 using namespace std;
22
23 namespace OHOS {
24 namespace AudioStandard {
25
26 static const uint8_t* RAW_DATA = nullptr;
27 static size_t g_dataSize = 0;
28 static size_t g_pos;
29 const size_t THRESHOLD = 10;
30 typedef void (*TestPtr)();
31
32 template<class T>
GetArrLength(T & arr)33 uint32_t GetArrLength(T& arr)
34 {
35 if (arr == nullptr) {
36 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
37 return 0;
38 }
39 return sizeof(arr) / sizeof(arr[0]);
40 }
41
42 template<class T>
GetData()43 T GetData()
44 {
45 T object {};
46 size_t objectSize = sizeof(object);
47 if (g_dataSize < g_pos) {
48 return object;
49 }
50 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
51 return object;
52 }
53 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
54 if (ret != EOK) {
55 return {};
56 }
57 g_pos += objectSize;
58 return object;
59 }
60
AudioZoneClientManagerGetInstanceFuzzTest()61 void AudioZoneClientManagerGetInstanceFuzzTest()
62 {
63 std::shared_ptr<AudioPolicyServerHandler> handler;
64 AudioZoneClientManager audioZoneClientManager(handler);
65 audioZoneClientManager.GetInstance();
66 }
67
AudioZoneClientManagerRegisterAudioZoneClientFuzzTest()68 void AudioZoneClientManagerRegisterAudioZoneClientFuzzTest()
69 {
70 std::shared_ptr<AudioPolicyServerHandler> handler;
71 AudioZoneClientManager audioZoneClientManager(handler);
72 pid_t clientPid = GetData<pid_t>();
73 sptr<IStandardAudioZoneClient> client = nullptr;
74 audioZoneClientManager.RegisterAudioZoneClient(clientPid, client);
75 }
76
AudioZoneClientManagerUnRegisterAudioZoneClientFuzzTest()77 void AudioZoneClientManagerUnRegisterAudioZoneClientFuzzTest()
78 {
79 std::shared_ptr<AudioPolicyServerHandler> handler;
80 AudioZoneClientManager audioZoneClientManager(handler);
81 pid_t clientPid = GetData<pid_t>();
82 audioZoneClientManager.UnRegisterAudioZoneClient(clientPid);
83 }
84
AudioZoneClientManagerDispatchEventFuzzTest()85 void AudioZoneClientManagerDispatchEventFuzzTest()
86 {
87 std::shared_ptr<AudioPolicyServerHandler> handler;
88 AudioZoneClientManager audioZoneClientManager(handler);
89 std::shared_ptr<AudioZoneEvent> event;
90 audioZoneClientManager.DispatchEvent(event);
91 }
92
AudioZoneClientManagerSendZoneAddEventFuzzTest()93 void AudioZoneClientManagerSendZoneAddEventFuzzTest()
94 {
95 std::shared_ptr<AudioPolicyServerHandler> handler;
96 AudioZoneClientManager audioZoneClientManager(handler);
97 pid_t clientPid = GetData<pid_t>();
98 std::shared_ptr<AudioZoneDescriptor> descriptor;
99 audioZoneClientManager.SendZoneAddEvent(clientPid, descriptor);
100 }
101
AudioZoneClientManagerSendZoneRemoveEventFuzzTest()102 void AudioZoneClientManagerSendZoneRemoveEventFuzzTest()
103 {
104 std::shared_ptr<AudioPolicyServerHandler> handler;
105 AudioZoneClientManager audioZoneClientManager(handler);
106 pid_t clientPid = GetData<pid_t>();
107 int32_t zoneId = GetData<int32_t>();
108 audioZoneClientManager.SendZoneRemoveEvent(clientPid, zoneId);
109 }
110
AudioZoneClientManagerSendZoneChangeEventFuzzTest()111 void AudioZoneClientManagerSendZoneChangeEventFuzzTest()
112 {
113 std::vector<AudioZoneChangeReason> audioZoneChangeReason {
114 AudioZoneChangeReason::UNKNOWN,
115 AudioZoneChangeReason::BIND_NEW_DEVICE,
116 AudioZoneChangeReason::BIND_NEW_APP,
117 AudioZoneChangeReason::UNBIND_APP
118 };
119 AudioZoneChangeReason reason =
120 static_cast<AudioZoneChangeReason>(GetData<int32_t>() % audioZoneChangeReason.size());
121 std::shared_ptr<AudioPolicyServerHandler> handler;
122 AudioZoneClientManager audioZoneClientManager(handler);
123 pid_t clientPid = GetData<pid_t>();
124 std::shared_ptr<AudioZoneDescriptor> descriptor;
125 audioZoneClientManager.SendZoneChangeEvent(clientPid, descriptor, reason);
126 }
127
AudioZoneClientManagerSendZoneInterruptEventFuzzTest()128 void AudioZoneClientManagerSendZoneInterruptEventFuzzTest()
129 {
130 std::vector<AudioZoneInterruptReason> audioZoneInterruptReason {
131 AudioZoneInterruptReason::UNKNOWN,
132 AudioZoneInterruptReason::LOCAL_INTERRUPT,
133 AudioZoneInterruptReason::REMOTE_INJECT,
134 AudioZoneInterruptReason::RELEASE_AUDIO_ZONE,
135 AudioZoneInterruptReason::BIND_APP_TO_ZONE,
136 AudioZoneInterruptReason::UNBIND_APP_FROM_ZONE,
137 };
138 std::shared_ptr<AudioPolicyServerHandler> handler;
139 AudioZoneClientManager audioZoneClientManager(handler);
140 pid_t clientPid = GetData<pid_t>();
141 int32_t zoneId = GetData<int32_t>();
142 std::string deviceTag = "test";
143 AudioZoneInterruptReason reason =
144 static_cast<AudioZoneInterruptReason>(GetData<int32_t>() % audioZoneInterruptReason.size());
145 std::list<std::pair<AudioInterrupt, AudioFocuState>> interrupts;
146 audioZoneClientManager.SendZoneInterruptEvent(clientPid, zoneId, deviceTag, interrupts, reason);
147 }
148
AudioZoneClientManagerSetSystemVolumeLevelFuzzTest()149 void AudioZoneClientManagerSetSystemVolumeLevelFuzzTest()
150 {
151 std::shared_ptr<AudioPolicyServerHandler> handler;
152 AudioZoneClientManager audioZoneClientManager(handler);
153 pid_t clientPid = GetData<pid_t>();
154 int32_t zoneId = GetData<int32_t>();
155 int32_t volumeLevel = GetData<int32_t>();
156 int32_t volumeFlag = GetData<int32_t>();
157 AudioVolumeType volumeType = GetData<AudioVolumeType>();
158 audioZoneClientManager.SetSystemVolumeLevel(clientPid, zoneId, volumeType, volumeLevel, volumeFlag);
159 }
160
AudioZoneClientManagerGetSystemVolumeLevelFuzzTest()161 void AudioZoneClientManagerGetSystemVolumeLevelFuzzTest()
162 {
163 std::shared_ptr<AudioPolicyServerHandler> handler;
164 AudioZoneClientManager audioZoneClientManager(handler);
165 pid_t clientPid = GetData<pid_t>();
166 int32_t zoneId = GetData<int32_t>();
167 AudioVolumeType volumeType = GetData<AudioVolumeType>();
168 audioZoneClientManager.GetSystemVolumeLevel(clientPid, zoneId, volumeType);
169 }
170
171 TestPtr g_testPtrs[] = {
172 AudioZoneClientManagerGetInstanceFuzzTest,
173 AudioZoneClientManagerRegisterAudioZoneClientFuzzTest,
174 AudioZoneClientManagerUnRegisterAudioZoneClientFuzzTest,
175 AudioZoneClientManagerDispatchEventFuzzTest,
176 AudioZoneClientManagerSendZoneAddEventFuzzTest,
177 AudioZoneClientManagerSendZoneRemoveEventFuzzTest,
178 AudioZoneClientManagerSendZoneChangeEventFuzzTest,
179 AudioZoneClientManagerSendZoneInterruptEventFuzzTest,
180 AudioZoneClientManagerSetSystemVolumeLevelFuzzTest,
181 AudioZoneClientManagerGetSystemVolumeLevelFuzzTest,
182 };
183
FuzzTest(const uint8_t * rawData,size_t size)184 void FuzzTest(const uint8_t* rawData, size_t size)
185 {
186 if (rawData == nullptr) {
187 return;
188 }
189
190 RAW_DATA = rawData;
191 g_dataSize = size;
192 g_pos = 0;
193
194 uint32_t code = GetData<uint32_t>();
195 uint32_t len = GetArrLength(g_testPtrs);
196 if (len > 0) {
197 g_testPtrs[code % len]();
198 } else {
199 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
200 }
201 return;
202 }
203
204 } // namespace AudioStandard
205 } // namesapce OHOS
206
207 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)208 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
209 {
210 if (size < OHOS::AudioStandard::THRESHOLD) {
211 return 0;
212 }
213 OHOS::AudioStandard::FuzzTest(data, size);
214 return 0;
215 }