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 shared_ptr<AudioPreferredOutputDeviceChangeCallbackFuzz> preferredOutputCallbackFuzz =
92 std::make_shared<AudioPreferredOutputDeviceChangeCallbackFuzz>();
93 AudioRoutingManager::GetInstance()->GetPreferredOutputDeviceForRendererInfo(rendererInfo, desc);
94 AudioRoutingManager::GetInstance()->SetPreferredOutputDeviceChangeCallback(rendererInfo,
95 preferredOutputCallbackFuzz);
96 AudioRoutingManager::GetInstance()->UnsetPreferredOutputDeviceChangeCallback();
97 }
98
AudioStreamManagerFuzzTest(const uint8_t * data,size_t size)99 void AudioStreamManagerFuzzTest(const uint8_t* data, size_t size)
100 {
101 if ((data == nullptr) || (size < LIMITSIZE)) {
102 return;
103 }
104
105 int32_t clientPid = *reinterpret_cast<const int32_t *>(data);
106 shared_ptr<AudioRendererStateCallbackFuzz> audioRendererStateCallbackFuzz =
107 std::make_shared<AudioRendererStateCallbackFuzz>();
108 shared_ptr<AudioCapturerStateCallbackFuzz> audioCapturerStateCallbackFuzz =
109 std::make_shared<AudioCapturerStateCallbackFuzz>();
110 AudioStreamManager::GetInstance()->RegisterAudioRendererEventListener(clientPid, audioRendererStateCallbackFuzz);
111 AudioStreamManager::GetInstance()->UnregisterAudioRendererEventListener(clientPid);
112 AudioStreamManager::GetInstance()->RegisterAudioCapturerEventListener(clientPid, audioCapturerStateCallbackFuzz);
113 AudioStreamManager::GetInstance()->UnregisterAudioCapturerEventListener(clientPid);
114
115 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
116 AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
117
118 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
119 AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
120 }
121
AudioGroupManagerFuzzTest(const uint8_t * data,size_t size)122 void AudioGroupManagerFuzzTest(const uint8_t* data, size_t size)
123 {
124 if ((data == nullptr) || (size < LIMITSIZE)) {
125 return;
126 }
127
128 int32_t volume = *reinterpret_cast<const int32_t *>(data);
129 AudioVolumeType type = *reinterpret_cast<const AudioVolumeType *>(data);
130 VolumeAdjustType adjustType = *reinterpret_cast<const VolumeAdjustType *>(data);
131 DeviceType device = *reinterpret_cast<const DeviceType *>(data);
132 std::vector<sptr<VolumeGroupInfo>> infos;
133 AudioSystemManager::GetInstance()->GetVolumeGroups(g_networkId, infos);
134 if (infos.empty() || infos[0] == nullptr) {
135 return;
136 }
137 int32_t groupId = infos[0]->volumeGroupId_;
138 auto audioGroupMngr_ = AudioSystemManager::GetInstance()->GetGroupManager(groupId);
139 audioGroupMngr_->IsVolumeUnadjustable();
140 audioGroupMngr_->AdjustVolumeByStep(adjustType);
141 audioGroupMngr_->AdjustSystemVolumeByStep(type, adjustType);
142 audioGroupMngr_->GetSystemVolumeInDb(type, volume, device);
143 }
144 } // namespace AudioStandard
145 } // namesapce OHOS
146
147 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)148 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
149 {
150 /* Run your code on data */
151 OHOS::AudioStandard::AudioManagerFuzzTest(data, size);
152 OHOS::AudioStandard::AudioRoutingManagerFuzzTest(data, size);
153 OHOS::AudioStandard::AudioStreamManagerFuzzTest(data, size);
154 OHOS::AudioStandard::AudioGroupManagerFuzzTest(data, size);
155 return 0;
156 }
157