1 /*
2 * Copyright (c) 2022 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 "audio_info.h"
20 #include "audio_policy_server.h"
21 #include "audio_manager_listener_stub.h"
22 #include "message_parcel.h"
23
24 using namespace std;
25
26 namespace OHOS {
27 namespace AudioStandard {
28 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy";
29 const int32_t SYSTEM_ABILITY_ID = 3009;
30 const bool RUN_ON_CREATE = false;
31 const int32_t LIMITSIZE = 4;
32
AudioVolumeFuzzTest(const uint8_t * rawData,size_t size)33 void AudioVolumeFuzzTest(const uint8_t *rawData, size_t size)
34 {
35 if (rawData == nullptr || size < LIMITSIZE) {
36 return;
37 }
38 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
39 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
40
41 AudioStreamType streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
42 int32_t volume = *reinterpret_cast<const int32_t *>(rawData);
43 int32_t streamId = *reinterpret_cast<const int32_t *>(rawData);
44 bool mute = *reinterpret_cast<const bool *>(rawData);
45 AudioPolicyServerPtr->SetSystemVolumeLevel(streamType, volume);
46 AudioPolicyServerPtr->GetSystemVolumeLevel(streamType);
47 AudioPolicyServerPtr->SetLowPowerVolume(streamId, volume);
48 AudioPolicyServerPtr->GetLowPowerVolume(streamId);
49 AudioPolicyServerPtr->GetSingleStreamVolume(streamId);
50 AudioPolicyServerPtr->SetStreamMute(streamType, mute);
51 AudioPolicyServerPtr->GetStreamMute(streamType);
52 AudioPolicyServerPtr->IsStreamActive(streamType);
53 }
54
AudioDeviceFuzzTest(const uint8_t * rawData,size_t size)55 void AudioDeviceFuzzTest(const uint8_t *rawData, size_t size)
56 {
57 if (rawData == nullptr || size < LIMITSIZE) {
58 return;
59 }
60 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
61 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
62
63 MessageParcel data;
64 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
65 data.WriteBuffer(rawData, size);
66 data.RewindRead(0);
67
68 InternalDeviceType deviceType = *reinterpret_cast<const InternalDeviceType *>(rawData);
69 bool active = *reinterpret_cast<const bool *>(rawData);
70 AudioPolicyServerPtr->SetDeviceActive(deviceType, active);
71 AudioPolicyServerPtr->IsDeviceActive(deviceType);
72
73 AudioRingerMode ringMode = *reinterpret_cast<const AudioRingerMode *>(rawData);
74 AudioPolicyServerPtr->SetRingerMode(ringMode);
75
76 #ifdef FEATURE_DTMF_TONE
77 int32_t ltonetype = *reinterpret_cast<const int32_t *>(rawData);
78 AudioPolicyServerPtr->GetToneConfig(ltonetype);
79 #endif
80
81 AudioScene audioScene = *reinterpret_cast<const AudioScene *>(rawData);
82 AudioPolicyServerPtr->SetAudioScene(audioScene);
83
84 bool mute = *reinterpret_cast<const bool *>(rawData);
85 AudioPolicyServerPtr->SetMicrophoneMute(mute);
86
87 int32_t clientId = *reinterpret_cast<const int32_t *>(rawData);
88 sptr<IRemoteObject> object = data.ReadRemoteObject();
89 AudioPolicyServerPtr->SetRingerModeCallback(clientId, object);
90 AudioPolicyServerPtr->UnsetRingerModeCallback(clientId);
91
92 DeviceFlag flag = *reinterpret_cast<const DeviceFlag *>(rawData);
93 AudioPolicyServerPtr->SetDeviceChangeCallback(clientId, flag, object);
94 AudioPolicyServerPtr->UnsetDeviceChangeCallback(clientId, flag);
95 }
96
AudioInterruptFuzzTest(const uint8_t * rawData,size_t size)97 void AudioInterruptFuzzTest(const uint8_t *rawData, size_t size)
98 {
99 if (rawData == nullptr || size < LIMITSIZE) {
100 return;
101 }
102 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
103 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
104
105 MessageParcel data;
106 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
107 data.WriteBuffer(rawData, size);
108 data.RewindRead(0);
109
110 sptr<IRemoteObject> object = data.ReadRemoteObject();
111 uint32_t sessionID = *reinterpret_cast<const uint32_t *>(rawData);
112 AudioPolicyServerPtr->SetAudioInterruptCallback(sessionID, object);
113 AudioPolicyServerPtr->UnsetAudioInterruptCallback(sessionID);
114
115 int32_t clientId = *reinterpret_cast<const uint32_t *>(rawData);
116 AudioPolicyServerPtr->SetAudioManagerInterruptCallback(clientId, object);
117
118 AudioInterrupt audioInterrupt;
119 audioInterrupt.contentType = *reinterpret_cast<const ContentType *>(rawData);
120 audioInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
121 audioInterrupt.audioFocusType.streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
122 AudioPolicyServerPtr->RequestAudioFocus(clientId, audioInterrupt);
123 AudioPolicyServerPtr->AbandonAudioFocus(clientId, audioInterrupt);
124
125 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList = {};
126 std::pair<AudioInterrupt, AudioFocuState> focusInfo = {};
127 focusInfo.first.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
128 focusInfo.first.contentType = *reinterpret_cast<const ContentType *>(rawData);
129 focusInfo.first.audioFocusType.streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
130 focusInfo.first.audioFocusType.sourceType = *reinterpret_cast<const SourceType *>(rawData);
131 focusInfo.first.audioFocusType.isPlay = *reinterpret_cast<const bool *>(rawData);
132 focusInfo.first.sessionID = *reinterpret_cast<const int32_t *>(rawData);
133 focusInfo.first.pauseWhenDucked = *reinterpret_cast<const bool *>(rawData);
134 focusInfo.first.pid = *reinterpret_cast<const int32_t *>(rawData);
135 focusInfo.first.mode = *reinterpret_cast<const InterruptMode *>(rawData);
136 focusInfo.second = *reinterpret_cast<const AudioFocuState *>(rawData);
137 focusInfoList.push_back(focusInfo);
138 AudioPolicyServerPtr->GetAudioFocusInfoList(focusInfoList);
139
140 AudioPolicyServerPtr->RegisterFocusInfoChangeCallback(clientId, object);
141 AudioPolicyServerPtr->UnregisterFocusInfoChangeCallback(clientId);
142 }
143
AudioPolicyFuzzTest(const uint8_t * rawData,size_t size)144 void AudioPolicyFuzzTest(const uint8_t *rawData, size_t size)
145 {
146 if (rawData == nullptr || size < LIMITSIZE) {
147 return;
148 }
149 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
150 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
151
152 MessageParcel data;
153 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
154 data.WriteBuffer(rawData, size);
155 data.RewindRead(0);
156
157 sptr<IRemoteObject> object = data.ReadRemoteObject();
158 int32_t clientPid = *reinterpret_cast<const int32_t *>(rawData);
159 AudioPolicyServerPtr->SetVolumeKeyEventCallback(clientPid, object);
160 AudioPolicyServerPtr->UnsetVolumeKeyEventCallback(clientPid);
161
162 uint32_t sessionID = *reinterpret_cast<const uint32_t *>(rawData);
163 AudioPolicyServerPtr->OnSessionRemoved(sessionID);
164
165 AudioPolicyServerPtr->RegisterAudioRendererEventListener(clientPid, object);
166 AudioPolicyServerPtr->UnregisterAudioRendererEventListener(clientPid);
167 AudioPolicyServerPtr->RegisterAudioCapturerEventListener(clientPid, object);
168 AudioPolicyServerPtr->UnregisterAudioCapturerEventListener(clientPid);
169
170 AudioPolicyServer::DeathRecipientId id =
171 *reinterpret_cast<const AudioPolicyServer::DeathRecipientId *>(rawData);
172 AudioPolicyServerPtr->RegisterClientDeathRecipient(object, id);
173
174 int pid = *reinterpret_cast<const int *>(rawData);
175 AudioPolicyServerPtr->RegisteredTrackerClientDied(pid);
176
177 AudioStreamInfo audioStreamInfo = {};
178 audioStreamInfo.samplingRate = *reinterpret_cast<const AudioSamplingRate *>(rawData);
179 audioStreamInfo.channels = *reinterpret_cast<const AudioChannel *>(rawData);
180 audioStreamInfo.format = *reinterpret_cast<const AudioSampleFormat *>(rawData);
181 audioStreamInfo.encoding = *reinterpret_cast<const AudioEncodingType *>(rawData);
182 AudioPolicyServerPtr->IsAudioRendererLowLatencySupported(audioStreamInfo);
183
184 int32_t clientUid = *reinterpret_cast<const int32_t *>(rawData);
185 StreamSetState streamSetState = *reinterpret_cast<const StreamSetState *>(rawData);
186 AudioStreamType audioStreamType = *reinterpret_cast<const AudioStreamType *>(rawData);
187 AudioPolicyServerPtr->UpdateStreamState(clientUid, streamSetState, audioStreamType);
188 }
189
AudioVolumeKeyCallbackStub(const uint8_t * rawData,size_t size)190 void AudioVolumeKeyCallbackStub(const uint8_t *rawData, size_t size)
191 {
192 if (rawData == nullptr || size < LIMITSIZE) {
193 return;
194 }
195 sptr<AudioVolumeKeyEventCallbackStub> listener =
196 new(std::nothrow) AudioVolumeKeyEventCallbackStub();
197 VolumeEvent volumeEvent = {};
198 volumeEvent.volumeType = *reinterpret_cast<const AudioStreamType *>(rawData);
199 volumeEvent.volume = *reinterpret_cast<const int32_t *>(rawData);
200 volumeEvent.updateUi = *reinterpret_cast<const bool *>(rawData);
201 volumeEvent.volumeGroupId = *reinterpret_cast<const int32_t *>(rawData);
202 std::string id(reinterpret_cast<const char*>(rawData), size - 1);
203 volumeEvent.networkId = id;
204
205 MessageParcel data;
206 data.WriteInt32(static_cast<int32_t>(volumeEvent.volumeType));
207 data.WriteInt32(volumeEvent.volume);
208 data.WriteBool(volumeEvent.updateUi);
209 data.WriteInt32(volumeEvent.volumeGroupId);
210 data.WriteString(volumeEvent.networkId);
211 MessageParcel reply;
212 MessageOption option;
213 listener->OnRemoteRequest(AudioVolumeKeyEventCallbackStub::ON_VOLUME_KEY_EVENT, data, reply, option);
214 }
215 } // namespace AudioStandard
216 } // namesapce OHOS
217
218 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)219 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
220 {
221 /* Run your code on data */
222 OHOS::AudioStandard::AudioVolumeFuzzTest(data, size);
223 OHOS::AudioStandard::AudioDeviceFuzzTest(data, size);
224 OHOS::AudioStandard::AudioInterruptFuzzTest(data, size);
225 OHOS::AudioStandard::AudioPolicyFuzzTest(data, size);
226 OHOS::AudioStandard::AudioVolumeKeyCallbackStub(data, size);
227 return 0;
228 }
229
230