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 "audiodevice_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #define private public
21 #include "addcalltoken_fuzzer.h"
22 #include "audio_control_manager.h"
23 #include "cs_call.h"
24
25 using namespace OHOS::Telephony;
26 namespace OHOS {
27 constexpr int32_t BOOL_NUM = 2;
28 constexpr int32_t CALL_TYPE_NUM = 4;
29 constexpr int32_t RING_STATE_NUM = 2;
30 constexpr int32_t DIAL_TYPE = 3;
31 constexpr int32_t VIDIO_TYPE_NUM = 2;
32 constexpr int32_t TEL_CALL_STATE_NUM = 9;
33 constexpr int32_t AUDIO_DEVICE_NUM = 6;
34 constexpr int32_t AUDIO_EVENT = 30;
35 constexpr int32_t AUDIO_SCENE_NUM = 4;
36 constexpr int32_t AUDIO_VOLUME_TYPE_NUM = 13;
37
AudioControlManagerFunc(const uint8_t * data,size_t size)38 void AudioControlManagerFunc(const uint8_t *data, size_t size)
39 {
40 if (!IsServiceInited()) {
41 return;
42 }
43
44 std::shared_ptr<AudioControlManager> audioControlManager = DelayedSingleton<AudioControlManager>::GetInstance();
45 DialParaInfo paraInfo;
46 paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
47 paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
48 paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
49 paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
50 sptr<CallBase> callObjectPtr = std::make_unique<CSCall>(paraInfo).release();
51 std::string message(reinterpret_cast<const char *>(data), size);
52 DisconnectedDetails details;
53 bool isMute = static_cast<bool>(size % BOOL_NUM);
54 RingState ringState = static_cast<RingState>(size % RING_STATE_NUM);
55 AudioDevice audioDevice = {
56 .deviceType = static_cast<AudioDeviceType>(size % AUDIO_DEVICE_NUM),
57 .address = { 0 },
58 };
59
60 audioControlManager->SetAudioDevice(audioDevice);
61 audioControlManager->CallDestroyed(details);
62 audioControlManager->NewCallCreated(callObjectPtr);
63 audioControlManager->IncomingCallActivated(callObjectPtr);
64 audioControlManager->IncomingCallHungUp(callObjectPtr, true, message);
65 audioControlManager->HandleNewActiveCall(callObjectPtr);
66 audioControlManager->StopRingtone();
67 audioControlManager->GetInitAudioDeviceType();
68 audioControlManager->SetMute(isMute);
69 audioControlManager->MuteRinger();
70 audioControlManager->GetCallList();
71 audioControlManager->GetCurrentActiveCall();
72 audioControlManager->IsEmergencyCallExists();
73 audioControlManager->GetAudioInterruptState();
74 audioControlManager->SetVolumeAudible();
75 audioControlManager->SetRingState(ringState);
76 audioControlManager->SetLocalRingbackNeeded(isMute);
77 audioControlManager->IsAudioActivated();
78 audioControlManager->StopCallTone();
79 audioControlManager->IsCurrentRinging();
80 audioControlManager->StopRingback();
81 audioControlManager->StopWaitingTone();
82 }
83
AudioDeviceManagerFunc(const uint8_t * data,size_t size)84 void AudioDeviceManagerFunc(const uint8_t *data, size_t size)
85 {
86 if (!IsServiceInited()) {
87 return;
88 }
89
90 std::shared_ptr<AudioDeviceManager> audioDeviceManager = DelayedSingleton<AudioDeviceManager>::GetInstance();
91 AudioDeviceType deviceType = static_cast<AudioDeviceType>(*data % AUDIO_DEVICE_NUM);
92 AudioEvent event = static_cast<AudioEvent>(*data % AUDIO_EVENT);
93
94 audioDeviceManager->Init();
95 audioDeviceManager->InitAudioDevice();
96 audioDeviceManager->ProcessEvent(event);
97 audioDeviceManager->SwitchDevice(event);
98 audioDeviceManager->SwitchDevice(deviceType);
99 audioDeviceManager->EnableBtSco();
100 audioDeviceManager->EnableWiredHeadset();
101 audioDeviceManager->EnableSpeaker();
102 audioDeviceManager->EnableEarpiece();
103 audioDeviceManager->DisableAll();
104 audioDeviceManager->IsBtScoDevEnable();
105 audioDeviceManager->IsSpeakerDevEnable();
106 audioDeviceManager->IsEarpieceDevEnable();
107 audioDeviceManager->IsWiredHeadsetDevEnable();
108 audioDeviceManager->GetCurrentAudioDevice();
109 audioDeviceManager->IsEarpieceAvailable();
110 audioDeviceManager->IsSpeakerAvailable();
111 audioDeviceManager->IsBtScoConnected();
112 audioDeviceManager->IsBtActived();
113 audioDeviceManager->IsWiredHeadsetConnected();
114 audioDeviceManager->SetCurrentAudioDevice(deviceType);
115 }
116
AudioProxyFunc(const uint8_t * data,size_t size)117 void AudioProxyFunc(const uint8_t *data, size_t size)
118 {
119 if (!IsServiceInited()) {
120 return;
121 }
122
123 std::shared_ptr<AudioProxy> audioProxy = DelayedSingleton<AudioProxy>::GetInstance();
124 std::shared_ptr<AudioControlManager> audioControlManager = DelayedSingleton<AudioControlManager>::GetInstance();
125 AudioStandard::AudioScene audioScene = static_cast<AudioStandard::AudioScene>(*data % AUDIO_SCENE_NUM);
126 AudioStandard::AudioVolumeType audioVolumeType =
127 static_cast<AudioStandard::AudioVolumeType>(*data % AUDIO_VOLUME_TYPE_NUM);
128 int32_t volume = static_cast<int32_t>(*data);
129 int32_t callId = static_cast<int32_t>(*data);
130 bool isMute = static_cast<bool>(*data % BOOL_NUM);
131
132 audioControlManager->GetCallBase(callId);
133 audioProxy->SetVolumeAudible();
134 audioProxy->IsMicrophoneMute();
135 audioProxy->SetMicrophoneMute(isMute);
136 audioProxy->SetEarpieceDevActive();
137 audioProxy->SetSpeakerDevActive(true);
138 audioProxy->SetBluetoothDevActive();
139 audioProxy->SetWiredHeadsetDevActive();
140 audioProxy->GetRingerMode();
141 audioProxy->GetVolume(audioVolumeType);
142 audioProxy->SetVolume(audioVolumeType, volume);
143 audioProxy->SetVolumeWithDevice(audioVolumeType, volume,
144 AudioStandard::DeviceType::DEVICE_TYPE_SPEAKER);
145 audioProxy->SetMaxVolume(audioVolumeType);
146 audioProxy->IsStreamActive(audioVolumeType);
147 audioProxy->IsStreamMute(audioVolumeType);
148 audioProxy->GetMaxVolume(audioVolumeType);
149 audioProxy->GetMinVolume(audioVolumeType);
150 audioProxy->SetAudioDeviceChangeCallback();
151 audioProxy->GetDefaultTonePath();
152 audioProxy->GetDefaultDtmfPath();
153 }
154
AudioSceneProcessorFunc(const uint8_t * data,size_t size)155 void AudioSceneProcessorFunc(const uint8_t *data, size_t size)
156 {
157 if (!IsServiceInited()) {
158 return;
159 }
160
161 std::shared_ptr<AudioSceneProcessor> audioSceneProcessor = DelayedSingleton<AudioSceneProcessor>::GetInstance();
162 std::shared_ptr<AudioControlManager> audioControlManager = DelayedSingleton<AudioControlManager>::GetInstance();
163 std::string phoneNum(reinterpret_cast<const char *>(data), size);
164
165 audioControlManager->IsNumberAllowed(phoneNum);
166 audioSceneProcessor->Init();
167 audioSceneProcessor->SwitchDialing();
168 audioSceneProcessor->SwitchCS();
169 audioSceneProcessor->SwitchIMS();
170 audioSceneProcessor->SwitchOTT();
171 audioSceneProcessor->SwitchHolding();
172 audioSceneProcessor->SwitchInactive();
173 }
174
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)175 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
176 {
177 if (data == nullptr || size == 0) {
178 return;
179 }
180 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioMicStateChangeCallback();
181 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioDeviceChangeCallback();
182 DelayedSingleton<AudioProxy>::GetInstance()->SetAudioPreferDeviceChangeCallback();
183 AudioControlManagerFunc(data, size);
184 AudioDeviceManagerFunc(data, size);
185 AudioProxyFunc(data, size);
186 AudioSceneProcessorFunc(data, size);
187 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
188 }
189 } // namespace OHOS
190
191 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)192 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
193 {
194 OHOS::AddCallTokenFuzzer token;
195 /* Run your code on data */
196 OHOS::DoSomethingInterestingWithMyAPI(data, size);
197 return 0;
198 }
199