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 "message_parcel.h"
22
23 using namespace std;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy";
28 const int32_t SYSTEM_ABILITY_ID = 3009;
29 const bool RUN_ON_CREATE = false;
30 const int32_t LIMITSIZE = 4;
31
AudioVolumeFuzzTest(const uint8_t * rawData,size_t size)32 void AudioVolumeFuzzTest(const uint8_t *rawData, size_t size)
33 {
34 if (rawData == nullptr || size < LIMITSIZE) {
35 return;
36 }
37 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
38 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
39
40 AudioStreamType streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
41 float volume = *reinterpret_cast<const float *>(rawData);
42 int32_t streamId = *reinterpret_cast<const int32_t *>(rawData);
43 bool mute = *reinterpret_cast<const bool *>(rawData);
44 AudioPolicyServerPtr->SetStreamVolume(streamType, volume);
45 AudioPolicyServerPtr->GetStreamVolume(streamType);
46 AudioPolicyServerPtr->SetLowPowerVolume(streamId, volume);
47 AudioPolicyServerPtr->GetLowPowerVolume(streamId);
48 AudioPolicyServerPtr->GetSingleStreamVolume(streamId);
49 AudioPolicyServerPtr->SetStreamMute(streamType, mute);
50 AudioPolicyServerPtr->GetStreamMute(streamType);
51 AudioPolicyServerPtr->IsStreamActive(streamType);
52 }
53
AudioDeviceFuzzTest(const uint8_t * rawData,size_t size)54 void AudioDeviceFuzzTest(const uint8_t *rawData, size_t size)
55 {
56 if (rawData == nullptr || size < LIMITSIZE) {
57 return;
58 }
59 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
60 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
61
62 MessageParcel data;
63 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
64 data.WriteBuffer(rawData, size);
65 data.RewindRead(0);
66
67 InternalDeviceType deviceType = *reinterpret_cast<const InternalDeviceType *>(rawData);
68 bool active = *reinterpret_cast<const bool *>(rawData);
69 AudioPolicyServerPtr->SetDeviceActive(deviceType, active);
70 AudioPolicyServerPtr->IsDeviceActive(deviceType);
71
72 AudioRingerMode ringMode = *reinterpret_cast<const AudioRingerMode *>(rawData);
73 AudioPolicyServerPtr->SetRingerMode(ringMode);
74
75 int32_t ltonetype = *reinterpret_cast<const int32_t *>(rawData);
76 AudioPolicyServerPtr->GetToneConfig(ltonetype);
77
78 AudioScene audioScene = *reinterpret_cast<const AudioScene *>(rawData);
79 AudioPolicyServerPtr->SetAudioScene(audioScene);
80
81 bool mute = *reinterpret_cast<const bool *>(rawData);
82 AudioPolicyServerPtr->SetMicrophoneMute(mute);
83
84 int32_t clientId = *reinterpret_cast<const int32_t *>(rawData);
85 sptr<IRemoteObject> object = data.ReadRemoteObject();
86 AudioPolicyServerPtr->SetRingerModeCallback(clientId, object);
87 AudioPolicyServerPtr->UnsetRingerModeCallback(clientId);
88
89 DeviceFlag flag = *reinterpret_cast<const DeviceFlag *>(rawData);
90 AudioPolicyServerPtr->SetDeviceChangeCallback(clientId, flag, object);
91 AudioPolicyServerPtr->UnsetDeviceChangeCallback(clientId);
92 }
93
AudioInterruptFuzzTest(const uint8_t * rawData,size_t size)94 void AudioInterruptFuzzTest(const uint8_t *rawData, size_t size)
95 {
96 if (rawData == nullptr || size < LIMITSIZE) {
97 return;
98 }
99 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
100 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
101
102 MessageParcel data;
103 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
104 data.WriteBuffer(rawData, size);
105 data.RewindRead(0);
106
107 sptr<IRemoteObject> object = data.ReadRemoteObject();
108 uint32_t sessionID = *reinterpret_cast<const uint32_t *>(rawData);
109 AudioPolicyServerPtr->SetAudioInterruptCallback(sessionID, object);
110 AudioPolicyServerPtr->UnsetAudioInterruptCallback(sessionID);
111
112 uint32_t clientID = *reinterpret_cast<const uint32_t *>(rawData);
113 AudioPolicyServerPtr->SetAudioManagerInterruptCallback(clientID, object);
114
115 AudioInterrupt audioInterrupt;
116 audioInterrupt.contentType = *reinterpret_cast<const ContentType *>(rawData);
117 audioInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
118 audioInterrupt.streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
119 AudioPolicyServerPtr->RequestAudioFocus(clientID, audioInterrupt);
120 AudioPolicyServerPtr->AbandonAudioFocus(clientID, audioInterrupt);
121 }
122
AudioPolicyFuzzTest(const uint8_t * rawData,size_t size)123 void AudioPolicyFuzzTest(const uint8_t *rawData, size_t size)
124 {
125 if (rawData == nullptr || size < LIMITSIZE) {
126 return;
127 }
128 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
129 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
130
131 MessageParcel data;
132 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
133 data.WriteBuffer(rawData, size);
134 data.RewindRead(0);
135
136 sptr<IRemoteObject> object = data.ReadRemoteObject();
137 int32_t clientPid = *reinterpret_cast<const int32_t *>(rawData);
138 AudioPolicyServerPtr->SetVolumeKeyEventCallback(clientPid, object);
139 AudioPolicyServerPtr->UnsetVolumeKeyEventCallback(clientPid);
140
141 uint32_t sessionID = *reinterpret_cast<const uint32_t *>(rawData);
142 AudioPolicyServerPtr->OnSessionRemoved(sessionID);
143
144 int32_t clientUID = *reinterpret_cast<const int32_t *>(rawData);
145 AudioPolicyServerPtr->RegisterAudioRendererEventListener(clientUID, object);
146 AudioPolicyServerPtr->UnregisterAudioRendererEventListener(clientUID);
147 AudioPolicyServerPtr->RegisterAudioCapturerEventListener(clientUID, object);
148 AudioPolicyServerPtr->UnregisterAudioCapturerEventListener(clientUID);
149
150 AudioPolicyServer::DeathRecipientId id =
151 *reinterpret_cast<const AudioPolicyServer::DeathRecipientId *>(rawData);
152 AudioPolicyServerPtr->RegisterClientDeathRecipient(object, id);
153
154 int pid = *reinterpret_cast<const int *>(rawData);
155 AudioPolicyServerPtr->RegisteredTrackerClientDied(pid);
156
157 AudioStreamInfo audioStreamInfo = {};
158 audioStreamInfo.samplingRate = *reinterpret_cast<const AudioSamplingRate *>(rawData);
159 audioStreamInfo.channels = *reinterpret_cast<const AudioChannel *>(rawData);
160 audioStreamInfo.format = *reinterpret_cast<const AudioSampleFormat *>(rawData);
161 audioStreamInfo.encoding = *reinterpret_cast<const AudioEncodingType *>(rawData);
162 AudioPolicyServerPtr->IsAudioRendererLowLatencySupported(audioStreamInfo);
163
164 int32_t clientUid = *reinterpret_cast<const int32_t *>(rawData);
165 StreamSetState streamSetState = *reinterpret_cast<const StreamSetState *>(rawData);
166 AudioStreamType audioStreamType = *reinterpret_cast<const AudioStreamType *>(rawData);
167 AudioPolicyServerPtr->UpdateStreamState(clientUid, streamSetState, audioStreamType);
168 }
169 } // namespace AudioStandard
170 } // namesapce OHOS
171
172 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)173 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
174 {
175 /* Run your code on data */
176 OHOS::AudioStandard::AudioVolumeFuzzTest(data, size);
177 OHOS::AudioStandard::AudioDeviceFuzzTest(data, size);
178 OHOS::AudioStandard::AudioInterruptFuzzTest(data, size);
179 OHOS::AudioStandard::AudioPolicyFuzzTest(data, size);
180 return 0;
181 }
182
183