1 /*
2 * Copyright (c) 2023 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_policy_service.h"
22 #include "audio_bluetooth_manager.h"
23 #include "audio_device_info.h"
24 using namespace std;
25
26 namespace OHOS {
27 namespace AudioStandard {
28 using namespace std;
29 const int32_t LIMITSIZE = 4;
30 const int32_t SYSTEM_ABILITY_ID = 3009;
31 const bool RUN_ON_CREATE = false;
32 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy";
33 const uint8_t TESTSIZE = 4;
34 typedef void (*TestPtr)(const uint8_t *, size_t);
35
AudioBluetoothManagerFuzzTest(const uint8_t * rawData,size_t size)36 void AudioBluetoothManagerFuzzTest(const uint8_t *rawData, size_t size)
37 {
38 if (rawData == nullptr || size < LIMITSIZE) {
39 return;
40 }
41
42 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
43 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
44
45 DeviceType devType = *reinterpret_cast<const DeviceType *>(rawData);
46 bool isConnected = *reinterpret_cast<const bool *>(rawData);
47 std::string macAddress(reinterpret_cast<const char*>(rawData), size);
48 std::string deviceName(reinterpret_cast<const char*>(rawData), size);
49
50 AudioStreamInfo audioStreamInfo = {};
51 audioStreamInfo.samplingRate = *reinterpret_cast<const AudioSamplingRate *>(rawData);
52 audioStreamInfo.encoding = *reinterpret_cast<const AudioEncodingType *>(rawData);
53 audioStreamInfo.format = *reinterpret_cast<const AudioSampleFormat *>(rawData);
54 audioStreamInfo.channels = *reinterpret_cast<const AudioChannel *>(rawData);
55
56 AudioPolicyServerPtr->audioPolicyService_
57 .OnDeviceStatusUpdated(devType, isConnected, macAddress, deviceName, audioStreamInfo);
58
59 AudioPolicyServerPtr->audioPolicyService_
60 .OnDeviceConfigurationChanged(devType, macAddress, deviceName, audioStreamInfo);
61 }
62
AudioA2dpManagerFuzzTest(const uint8_t * rawData,size_t size)63 void AudioA2dpManagerFuzzTest(const uint8_t *rawData, size_t size)
64 {
65 if (rawData == nullptr || size < LIMITSIZE) {
66 return;
67 }
68 std::string macAddress(reinterpret_cast<const char*>(rawData), size);
69 int32_t volume = *reinterpret_cast<const int32_t*>(rawData);
70 std::vector<Bluetooth::A2dpStreamInfo> info;
71 std::vector<int32_t> sessionsID = {};
72
73 Bluetooth::AudioA2dpManager::SetDeviceAbsVolume(macAddress, volume);
74 Bluetooth::AudioA2dpManager::OffloadStartPlaying(sessionsID);
75 Bluetooth::AudioA2dpManager::OffloadStopPlaying(sessionsID);
76 Bluetooth::AudioA2dpManager::A2dpOffloadSessionRequest(info);
77 }
78
AudioHfpManagerFuzzTest(const uint8_t * rawData,size_t size)79 void AudioHfpManagerFuzzTest(const uint8_t *rawData, size_t size)
80 {
81 if (rawData == nullptr || size < LIMITSIZE) {
82 return;
83 }
84 AudioScene scene = *reinterpret_cast<const AudioScene*>(rawData);
85 std::string macAddress(reinterpret_cast<const char*>(rawData), size);
86
87 Bluetooth::AudioHfpManager::SetActiveHfpDevice(macAddress);
88 Bluetooth::AudioHfpManager::ConnectScoWithAudioScene(scene);
89 Bluetooth::AudioHfpManager::GetScoCategoryFromScene(scene);
90 Bluetooth::AudioHfpManager::UpdateAudioScene(scene);
91 }
92
FetchOutputDeviceForTrackInternalFuzzTest(const uint8_t * rawData,size_t size)93 void FetchOutputDeviceForTrackInternalFuzzTest(const uint8_t *rawData, size_t size)
94 {
95 if (rawData == nullptr || size < LIMITSIZE) {
96 return;
97 }
98
99 MessageParcel data;
100 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
101 data.WriteBuffer(rawData, size);
102 data.RewindRead(0);
103
104 AudioStreamChangeInfo streamChangeInfo = {};
105 streamChangeInfo.audioRendererChangeInfo.Unmarshalling(data);
106 std::shared_ptr<AudioPolicyServer> AudioPolicyServerPtr =
107 std::make_shared<AudioPolicyServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
108 AudioPolicyServerPtr->audioPolicyService_.FetchOutputDeviceForTrack(streamChangeInfo,
109 AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN);
110 }
111 } // namespace AudioStandard
112 } // namesapce OHOS
113
114 OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = {
115 OHOS::AudioStandard::AudioBluetoothManagerFuzzTest,
116 OHOS::AudioStandard::AudioA2dpManagerFuzzTest,
117 OHOS::AudioStandard::AudioHfpManagerFuzzTest,
118 OHOS::AudioStandard::FetchOutputDeviceForTrackInternalFuzzTest
119 };
120
121 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)122 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
123 {
124 /* Run your code on data */
125 if (data == nullptr || size <= 1) {
126 return 0;
127 }
128 uint8_t firstByte = *data % OHOS::AudioStandard::TESTSIZE;
129 if (firstByte >= OHOS::AudioStandard::TESTSIZE) {
130 return 0;
131 }
132 data = data + 1;
133 size = size - 1;
134 g_testPtrs[firstByte](data, size);
135 return 0;
136 }