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