1 /*
2 * Copyright (c) 2021 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
18 #include "audio_errors.h"
19 #include "audio_info.h"
20 #include "audio_system_manager.h"
21 #include "audio_routing_manager.h"
22 #include "audio_stream_manager.h"
23 #include "audio_manager_fuzzer.h"
24
25 using namespace std;
26
27 namespace OHOS {
28 namespace AudioStandard {
29 namespace {
30 std::string g_networkId = "LocalDevice";
31 }
32 const uint8_t TESTSIZE = 4;
33 typedef void (*TestPtr)(const uint8_t *, size_t);
34
OnRendererStateChange(const std::vector<std::shared_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)35 void AudioRendererStateCallbackFuzz::OnRendererStateChange(
36 const std::vector<std::shared_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos) {}
37
OnCapturerStateChange(const std::vector<std::shared_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)38 void AudioCapturerStateCallbackFuzz::OnCapturerStateChange(
39 const std::vector<std::shared_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos) {}
40 const int32_t LIMITSIZE = 4;
AudioManagerFuzzTest(const uint8_t * data,size_t size)41 void AudioManagerFuzzTest(const uint8_t* data, size_t size)
42 {
43 if ((data == nullptr) || (size < LIMITSIZE)) {
44 return;
45 }
46
47 AudioVolumeType type = *reinterpret_cast<const AudioVolumeType *>(data);
48 int32_t volume = *reinterpret_cast<const int32_t *>(data);
49 AudioSystemManager::GetInstance()->SetVolume(type, volume);
50 AudioSystemManager::GetInstance()->GetVolume(type);
51 AudioSystemManager::GetInstance()->GetMinVolume(type);
52 AudioSystemManager::GetInstance()->GetMaxVolume(type);
53 AudioSystemManager::GetInstance()->SetMute(type, true);
54 AudioSystemManager::GetInstance()->IsStreamMute(type);
55 AudioSystemManager::GetInstance()->SetRingerMode(*reinterpret_cast<const AudioRingerMode *>(data));
56 AudioSystemManager::GetInstance()->SetAudioScene(*reinterpret_cast<const AudioScene *>(data));
57
58 std::string key(reinterpret_cast<const char*>(data), size);
59 std::string value(reinterpret_cast<const char*>(data), size);
60 AudioSystemManager::GetInstance()->SetAudioParameter(key, value);
61
62 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList = {};
63 std::pair<AudioInterrupt, AudioFocuState> focusInfo = {};
64 focusInfo.first.streamUsage = *reinterpret_cast<const StreamUsage *>(data);
65 focusInfo.first.contentType = *reinterpret_cast<const ContentType *>(data);
66 focusInfo.first.audioFocusType.streamType = *reinterpret_cast<const AudioStreamType *>(data);
67 focusInfo.first.audioFocusType.sourceType = *reinterpret_cast<const SourceType *>(data);
68 focusInfo.first.audioFocusType.isPlay = *reinterpret_cast<const bool *>(data);
69 focusInfo.first.streamId = *reinterpret_cast<const int32_t *>(data);
70 focusInfo.first.pauseWhenDucked = *reinterpret_cast<const bool *>(data);
71 focusInfo.first.pid = *reinterpret_cast<const int32_t *>(data);
72 focusInfo.first.mode = *reinterpret_cast<const InterruptMode *>(data);
73 focusInfo.second = *reinterpret_cast<const AudioFocuState *>(data);
74 focusInfoList.push_back(focusInfo);
75 AudioSystemManager::GetInstance()->GetAudioFocusInfoList(focusInfoList);
76
77 shared_ptr<AudioFocusInfoChangeCallbackFuzz> focusInfoChangeCallbackFuzz =
78 std::make_shared<AudioFocusInfoChangeCallbackFuzz>();
79 AudioSystemManager::GetInstance()->RegisterFocusInfoChangeCallback(focusInfoChangeCallbackFuzz);
80 AudioSystemManager::GetInstance()->UnregisterFocusInfoChangeCallback();
81 }
82
AudioRoutingManagerFuzzTest(const uint8_t * data,size_t size)83 void AudioRoutingManagerFuzzTest(const uint8_t* data, size_t size)
84 {
85 if ((data == nullptr) || (size < LIMITSIZE)) {
86 return;
87 }
88
89 AudioRendererInfo rendererInfo = {};
90 rendererInfo.contentType = *reinterpret_cast<const ContentType *>(data);
91 rendererInfo.streamUsage = *reinterpret_cast<const StreamUsage *>(data);
92 rendererInfo.rendererFlags = *reinterpret_cast<const int32_t *>(data);
93 std::vector<std::shared_ptr<AudioDeviceDescriptor>> desc;
94
95 shared_ptr<AudioPreferredOutputDeviceChangeCallbackFuzz> preferredOutputCallbackFuzz =
96 std::make_shared<AudioPreferredOutputDeviceChangeCallbackFuzz>();
97 AudioRoutingManager::GetInstance()->GetPreferredOutputDeviceForRendererInfo(rendererInfo, desc);
98 AudioRoutingManager::GetInstance()->SetPreferredOutputDeviceChangeCallback(rendererInfo,
99 preferredOutputCallbackFuzz);
100 AudioRoutingManager::GetInstance()->UnsetPreferredOutputDeviceChangeCallback();
101
102 AudioCapturerInfo capturerInfo = {};
103 capturerInfo.sourceType = *reinterpret_cast<const SourceType *>(data);
104 capturerInfo.capturerFlags = *reinterpret_cast<const int32_t *>(data);
105 shared_ptr<AudioPreferredInputDeviceChangeCallbackFuzz> preferredInputCallbackFuzz =
106 std::make_shared<AudioPreferredInputDeviceChangeCallbackFuzz>();
107 AudioRoutingManager::GetInstance()->GetPreferredInputDeviceForCapturerInfo(capturerInfo, desc);
108 AudioRoutingManager::GetInstance()->SetPreferredInputDeviceChangeCallback(
109 capturerInfo, preferredInputCallbackFuzz);
110 AudioRoutingManager::GetInstance()->UnsetPreferredInputDeviceChangeCallback();
111 AudioRoutingManager::GetInstance()->GetAvailableMicrophones();
112 }
113
AudioStreamManagerFuzzTest(const uint8_t * data,size_t size)114 void AudioStreamManagerFuzzTest(const uint8_t* data, size_t size)
115 {
116 if ((data == nullptr) || (size < LIMITSIZE)) {
117 return;
118 }
119
120 int32_t clientPid = *reinterpret_cast<const int32_t *>(data);
121 shared_ptr<AudioRendererStateCallbackFuzz> audioRendererStateCallbackFuzz =
122 std::make_shared<AudioRendererStateCallbackFuzz>();
123 shared_ptr<AudioCapturerStateCallbackFuzz> audioCapturerStateCallbackFuzz =
124 std::make_shared<AudioCapturerStateCallbackFuzz>();
125 AudioStreamManager::GetInstance()->RegisterAudioRendererEventListener(clientPid, audioRendererStateCallbackFuzz);
126 AudioStreamManager::GetInstance()->UnregisterAudioRendererEventListener(clientPid);
127 AudioStreamManager::GetInstance()->RegisterAudioCapturerEventListener(clientPid, audioCapturerStateCallbackFuzz);
128 AudioStreamManager::GetInstance()->UnregisterAudioCapturerEventListener(clientPid);
129
130 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
131 AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
132
133 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
134 AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
135
136 std::shared_ptr<AudioStandard::AudioDeviceDescriptor> deviceDescriptor =
137 std::make_shared<AudioStandard::AudioDeviceDescriptor>();
138 deviceDescriptor->deviceType_ = *reinterpret_cast<const DeviceType *>(data);
139 deviceDescriptor->deviceRole_ = *reinterpret_cast<const DeviceRole *>(data);
140 AudioStreamManager::GetInstance()->GetHardwareOutputSamplingRate(deviceDescriptor);
141
142 AudioVolumeType volumeType = *reinterpret_cast<const AudioVolumeType *>(data);
143 AudioStreamManager::GetInstance()->IsStreamActive(volumeType);
144 }
145
AudioGroupManagerFuzzTest(const uint8_t * data,size_t size)146 void AudioGroupManagerFuzzTest(const uint8_t* data, size_t size)
147 {
148 if ((data == nullptr) || (size < LIMITSIZE)) {
149 return;
150 }
151
152 int32_t volume = *reinterpret_cast<const int32_t *>(data);
153 AudioVolumeType type = *reinterpret_cast<const AudioVolumeType *>(data);
154 VolumeAdjustType adjustType = *reinterpret_cast<const VolumeAdjustType *>(data);
155 DeviceType device = *reinterpret_cast<const DeviceType *>(data);
156 int32_t clientld = *reinterpret_cast<const int32_t *>(data);
157 int32_t deviceId = *reinterpret_cast<const int32_t *>(data);
158 AudioRingerMode ringMode = *reinterpret_cast<const AudioRingerMode *>(data);
159 shared_ptr<AudioRingerModeCallbackFuzz> ringerModeCallbackFuzz =
160 std::make_shared<AudioRingerModeCallbackFuzz>();
161 std::vector<sptr<VolumeGroupInfo>> infos;
162 AudioSystemManager::GetInstance()->GetVolumeGroups(g_networkId, infos);
163 if (infos.empty() || infos[0] == nullptr) {
164 return;
165 }
166 int32_t groupId = infos[0]->volumeGroupId_;
167 auto audioGroupMngr_ = AudioSystemManager::GetInstance()->GetGroupManager(groupId);
168 audioGroupMngr_->IsVolumeUnadjustable();
169 audioGroupMngr_->AdjustVolumeByStep(adjustType);
170 audioGroupMngr_->AdjustSystemVolumeByStep(type, adjustType);
171 audioGroupMngr_->GetSystemVolumeInDb(type, volume, device);
172 audioGroupMngr_->GetMaxAmplitude(deviceId);
173 audioGroupMngr_->SetRingerMode(ringMode);
174 audioGroupMngr_->GetRingerMode();
175 audioGroupMngr_->IsMicrophoneMute();
176 audioGroupMngr_->SetRingerModeCallback(clientld, ringerModeCallbackFuzz);
177 audioGroupMngr_->UnsetRingerModeCallback(clientld);
178 }
179 } // namespace AudioStandard
180 } // namesapce OHOS
181
182 OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = {
183 OHOS::AudioStandard::AudioManagerFuzzTest,
184 OHOS::AudioStandard::AudioRoutingManagerFuzzTest,
185 OHOS::AudioStandard::AudioStreamManagerFuzzTest,
186 OHOS::AudioStandard::AudioGroupManagerFuzzTest
187 };
188
189 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)190 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
191 {
192 /* Run your code on data */
193 if (data == nullptr || size <= 1) {
194 return 0;
195 }
196 uint8_t firstByte = *data % OHOS::AudioStandard::TESTSIZE;
197 if (firstByte >= OHOS::AudioStandard::TESTSIZE) {
198 return 0;
199 }
200 data = data + 1;
201 size = size - 1;
202 g_testPtrs[firstByte](data, size);
203 return 0;
204 }
205