1 /*
2 * Copyright (c) 2024 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 <atomic>
20 #include <thread>
21 #include "audio_policy_server.h"
22 #include "audio_device_info.h"
23 #include "message_parcel.h"
24 #include "accesstoken_kit.h"
25 #include "audio_routing_manager.h"
26 #include "audio_stream_manager.h"
27 #include "nativetoken_kit.h"
28 #include "token_setproc.h"
29 #include "access_token.h"
30 #include "audio_policy_utils.h"
31 using namespace std;
32
33 namespace OHOS {
34 namespace AudioStandard {
35 bool g_hasPermission = false;
36 const int32_t MOD_NUM_TWO = 2;
37 const int32_t SYSTEM_ABILITY_ID = 3009;
38 const bool RUN_ON_CREATE = false;
39 const uint32_t CHANNELS = 2;
40 const uint32_t RATE = 4;
41 const uint64_t SESSIONID = 123456;
42 constexpr int32_t DEFAULT_STREAM_ID = 10;
43 bool g_hasServerInit = false;
44 const int64_t ACTIVEBTTIME = 60 * 1140 * 2;
45 const uint32_t ENUM_NUM = 4;
46 const int32_t A2DP_PLAYING = 2;
47 const int32_t A2DP_STOPPED = 1;
48 const std::string SPLITARGS = "splitArgs";
49 const std::string NETWORKID = "networkId";
50 const int32_t SESSIONID_32 = 123456;
51 static const uint8_t *RAW_DATA = nullptr;
52 static size_t g_dataSize = 0;
53 static size_t g_pos;
54 const size_t THRESHOLD = 10;
55
56 /*
57 * describe: get data from outside untrusted data(RAW_DATA) which size is according to sizeof(T)
58 * tips: only support basic type
59 */
60 template<class T>
GetData()61 T GetData()
62 {
63 T object {};
64 size_t objectSize = sizeof(object);
65 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
66 return object;
67 }
68 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
69 if (ret != EOK) {
70 return {};
71 }
72 g_pos += objectSize;
73 return object;
74 }
75
76 template<class T>
GetArrLength(T & arr)77 uint32_t GetArrLength(T& arr)
78 {
79 if (arr == nullptr) {
80 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
81 return 0;
82 }
83 return sizeof(arr) / sizeof(arr[0]);
84 }
85
GetServerPtr()86 AudioPolicyServer* GetServerPtr()
87 {
88 static AudioPolicyServer server(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
89 if (!g_hasServerInit) {
90 server.OnStart();
91 server.OnAddSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID, "");
92 #ifdef FEATURE_MULTIMODALINPUT_INPUT
93 server.OnAddSystemAbility(MULTIMODAL_INPUT_SERVICE_ID, "");
94 #endif
95 server.OnAddSystemAbility(BLUETOOTH_HOST_SYS_ABILITY_ID, "");
96 server.OnAddSystemAbility(POWER_MANAGER_SERVICE_ID, "");
97 server.OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, "");
98 server.audioPolicyService_.SetDefaultDeviceLoadFlag(true);
99 g_hasServerInit = true;
100 }
101 return &server;
102 }
103
InitProcessConfig()104 static AudioProcessConfig InitProcessConfig()
105 {
106 AudioProcessConfig config;
107 config.appInfo.appUid = DEFAULT_STREAM_ID;
108 config.appInfo.appPid = DEFAULT_STREAM_ID;
109 config.streamInfo.format = SAMPLE_S32LE;
110 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
111 config.streamInfo.channels = STEREO;
112 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
113 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
114 config.streamType = AudioStreamType::STREAM_MUSIC;
115 config.deviceType = DEVICE_TYPE_USB_HEADSET;
116 return config;
117 }
118
AudioFuzzTestGetPermission()119 void AudioFuzzTestGetPermission()
120 {
121 if (!g_hasPermission) {
122 uint64_t tokenId;
123 constexpr int perNum = 10;
124 const char *perms[perNum] = {
125 "ohos.permission.MICROPHONE",
126 "ohos.permission.MANAGE_INTELLIGENT_VOICE",
127 "ohos.permission.MANAGE_AUDIO_CONFIG",
128 "ohos.permission.MICROPHONE_CONTROL",
129 "ohos.permission.MODIFY_AUDIO_SETTINGS",
130 "ohos.permission.ACCESS_NOTIFICATION_POLICY",
131 "ohos.permission.USE_BLUETOOTH",
132 "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO",
133 "ohos.permission.RECORD_VOICE_CALL",
134 "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS",
135 };
136
137 NativeTokenInfoParams infoInstance = {
138 .dcapsNum = 0,
139 .permsNum = 10,
140 .aclsNum = 0,
141 .dcaps = nullptr,
142 .perms = perms,
143 .acls = nullptr,
144 .processName = "audiofuzztest",
145 .aplStr = "system_basic",
146 };
147 tokenId = GetAccessTokenId(&infoInstance);
148 SetSelfTokenID(tokenId);
149 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
150 g_hasPermission = true;
151 }
152 }
153
InitGetServerService(DeviceRole deviceRole,AudioStreamInfo audioStreamInfo_2)154 void InitGetServerService(DeviceRole deviceRole, AudioStreamInfo audioStreamInfo_2)
155 {
156 AudioStreamInfo audioStreamInfo = {};
157 audioStreamInfo.samplingRate = GetData<AudioSamplingRate>();
158 audioStreamInfo.encoding = GetData<AudioEncodingType>();
159 audioStreamInfo.format = GetData<AudioSampleFormat>();
160 audioStreamInfo.channels = GetData<AudioChannel>();
161
162 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_ = "activeBTDevice";
163 A2dpDeviceConfigInfo configInfo = {audioStreamInfo, false};
164 GetServerPtr()->audioPolicyService_.audioA2dpDevice_.connectedA2dpDeviceMap_.insert({"activeBTDevice",
165 configInfo});
166 GetServerPtr()->audioPolicyService_.audioA2dpDevice_.connectedA2dpDeviceMap_.insert({"A2dpDeviceCommon", {}});
167 GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID;
168 GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_
169 = DEVICE_TYPE_BLUETOOTH_A2DP;
170 }
171
ThreadFunctionTest()172 void ThreadFunctionTest()
173 {
174 GetServerPtr()->audioPolicyService_.audioConfigManager_.isAdapterInfoMap_.store(true);
175 }
176
AudioPolicyServiceSecondTest(AudioStreamInfo audioStreamInfo,std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor)177 void AudioPolicyServiceSecondTest(AudioStreamInfo audioStreamInfo,
178 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor)
179 {
180 bool isConnected = GetData<bool>();
181 GetServerPtr()->audioPolicyService_.audioCapturerSession_.HandleRemoteCastDevice(isConnected, audioStreamInfo);
182 GetServerPtr()->audioPolicyService_.audioConfigManager_.OnVoipConfigParsed(isConnected);
183 GetServerPtr()->audioPolicyService_.audioConfigManager_.GetVoipConfig();
184 pid_t clientPid = GetData<pid_t>();
185 GetServerPtr()->audioPolicyService_.ReduceAudioPolicyClientProxyMap(clientPid);
186 AudioStreamChangeInfo streamChangeInfo;
187 int32_t clientUID = GetData<int32_t>();
188 int32_t sessionId = GetData<int32_t>();
189 int32_t clientPid1 = GetData<int32_t>();
190 streamChangeInfo.audioRendererChangeInfo.clientUID = clientUID;
191 streamChangeInfo.audioRendererChangeInfo.sessionId = sessionId;
192 streamChangeInfo.audioRendererChangeInfo.clientPid = clientPid1;
193 streamChangeInfo.audioRendererChangeInfo.rendererState = RENDERER_NEW;
194 streamChangeInfo.audioRendererChangeInfo.rendererInfo = {};
195
196 auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
197 sptr<IRemoteObject> object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID);
198 std::vector<AudioMode> audioMode = { AUDIO_MODE_RECORD, AUDIO_MODE_PLAYBACK };
199 uint32_t modeInt = GetData<uint32_t>() % audioMode.size();
200 AudioMode mode = audioMode[modeInt];
201 GetServerPtr()->audioPolicyService_.RegisterTracker(mode, streamChangeInfo, object, sessionId);
202 std::vector<DeviceType> DeviceTypeVec = {
203 DEVICE_TYPE_BLUETOOTH_SCO,
204 DEVICE_TYPE_USB_ARM_HEADSET,
205 DEVICE_TYPE_BLUETOOTH_A2DP,
206 DEVICE_TYPE_FILE_SINK,
207 DEVICE_TYPE_DP,
208 };
209 uint32_t deviceTypeInt = GetData<uint32_t>() % DeviceTypeVec.size();
210 DeviceType deviceType = DeviceTypeVec[deviceTypeInt];
211 GetServerPtr()->audioPolicyService_.audioIOHandleMap_.GetSinkIOHandle(deviceType);
212 std::vector<DeviceType> DeviceTypeSourceVec = {
213 DEVICE_TYPE_USB_ARM_HEADSET,
214 DEVICE_TYPE_MIC,
215 DEVICE_TYPE_FILE_SOURCE,
216 DEVICE_TYPE_DP,
217 };
218 uint32_t deviceTypeSouInt = GetData<uint32_t>() % DeviceTypeSourceVec.size();
219 DeviceType deviceTypeSou = DeviceTypeSourceVec[deviceTypeSouInt];
220 GetServerPtr()->audioPolicyService_.audioIOHandleMap_.GetSourceIOHandle(deviceTypeSou);
221 SinkInput sinkInput = {};
222 SourceOutput sourceOutput = {};
223 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.WriteOutputDeviceChangedSysEvents(remoteDeviceDescriptor,
224 sinkInput);
225 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.WriteInputDeviceChangedSysEvents(remoteDeviceDescriptor,
226 sourceOutput);
227 }
228
AudioPolicyServiceThirdTest()229 void AudioPolicyServiceThirdTest()
230 {
231 AudioProcessConfig config = InitProcessConfig();
232 std::thread t1(ThreadFunctionTest);
233 t1.join();
234 GetServerPtr()->audioPolicyService_.audioConfigManager_.Init(true);
235
236 vector<shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
237 AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
238 GetServerPtr()->audioPolicyService_.RegisterRemoteDevStatusCallback();
239 GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_
240 = DEVICE_TYPE_BLUETOOTH_A2DP;
241 std::vector<DeviceType> DeviceTypeVec = {
242 DEVICE_TYPE_BLUETOOTH_A2DP,
243 DEVICE_TYPE_BLUETOOTH_SCO,
244 };
245 uint32_t deviceTypeInt = GetData<uint32_t>() % DeviceTypeVec.size();
246 DeviceType deviceType = DeviceTypeVec[deviceTypeInt];
247 GetServerPtr()->audioPolicyService_.audioVolumeManager_.IsBlueTooth(deviceType);
248 GetServerPtr()->audioPolicyService_.audioVolumeManager_.activeSafeTimeBt_ = ACTIVEBTTIME;
249 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CheckBlueToothActiveMusicTime(1);
250 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CheckWiredActiveMusicTime(1);
251 int32_t safeVolume = GetData<int32_t>();
252 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CheckBlueToothActiveMusicTime(safeVolume);
253 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CheckWiredActiveMusicTime(safeVolume);
254 }
255
AudioPolicyServiceTest()256 void AudioPolicyServiceTest()
257 {
258 AudioStreamInfo streamInfo;
259 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
260 streamInfo.channels = AudioChannel::STEREO;
261 streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
262 SessionInfo sessionInfo;
263 sessionInfo.sourceType = SOURCE_TYPE_VOICE_CALL;
264 sessionInfo.rate = RATE;
265 sessionInfo.channels = CHANNELS;
266 GetServerPtr()->audioPolicyService_.OnCapturerSessionAdded(SESSIONID, sessionInfo, streamInfo);
267
268 uint32_t deviceRoleInt = GetData<uint32_t>();
269 deviceRoleInt = (deviceRoleInt % ENUM_NUM) - 1;
270 DeviceRole deviceRole = static_cast<DeviceRole>(deviceRoleInt);
271 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
272
273 AudioStreamInfo audioStreamInfo = {};
274 audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
275 audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM;
276 audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
277 audioStreamInfo.channels = AudioChannel::STEREO;
278 InitGetServerService(deviceRole, audioStreamInfo);
279 GetServerPtr()->audioPolicyService_.OnDeviceConfigurationChanged(DEVICE_TYPE_BLUETOOTH_A2DP,
280 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_, "DeviceName", audioStreamInfo);
281
282 shared_ptr<AudioDeviceDescriptor> dis = make_shared<AudioDeviceDescriptor>();
283 dis->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
284 dis->macAddress_ = GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_;
285 dis->deviceRole_ = OUTPUT_DEVICE;
286 GetServerPtr()->audioPolicyService_.audioDeviceManager_.connectedDevices_.push_back(dis);
287
288 std::vector<DeviceType> DeviceTypeVec = {
289 DEVICE_TYPE_BLUETOOTH_A2DP,
290 DEVICE_TYPE_BLUETOOTH_SCO,
291 };
292 uint32_t deviceTypeInt = GetData<uint32_t>() % DeviceTypeVec.size();
293 DeviceType deviceType = DeviceTypeVec[deviceTypeInt];
294 GetServerPtr()-> audioPolicyService_.OnForcedDeviceSelected(deviceType,
295 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_);
296 AudioPolicyServiceSecondTest(audioStreamInfo, remoteDeviceDescriptor);
297 AudioPolicyServiceThirdTest();
298 }
299
AudioPolicyServiceTestII()300 void AudioPolicyServiceTestII()
301 {
302 int32_t volumeLevel = GetData<int32_t>();
303 bool isA2dpDevice = GetData<bool>();
304 GetServerPtr()->audioPolicyService_.audioVolumeManager_.DealWithSafeVolume(volumeLevel, isA2dpDevice);
305 AudioStreamInfo audioStreamInfo = {};
306 audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
307 audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM;
308 audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
309 audioStreamInfo.channels = AudioChannel::STEREO;
310 A2dpDeviceConfigInfo configInfo = {audioStreamInfo, true};
311 volumeLevel = GetServerPtr()->audioPolicyService_.audioPolicyManager_.GetSafeVolumeLevel() + MOD_NUM_TWO;
312 GetServerPtr()->audioPolicyService_.audioA2dpDevice_.connectedA2dpDeviceMap_.insert({"activeBTDevice_1",
313 configInfo});
314 GetServerPtr()->audioPolicyService_.SetA2dpDeviceVolume("activeBTDevice_1", volumeLevel, isA2dpDevice);
315 DeviceType devType = GetData<DeviceType>();
316 DeviceBlockStatus status = GetData<DeviceBlockStatus>();
317 GetServerPtr()->audioPolicyService_.OnMicrophoneBlockedUpdate(devType, status);
318 vector<shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
319 AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
320 for (auto &capturerChangeInfo : audioCapturerChangeInfos) {
321 capturerChangeInfo->capturerInfo.sourceType = SOURCE_TYPE_VIRTUAL_CAPTURE;
322 capturerChangeInfo->capturerState = CAPTURER_PREPARED;
323 }
324 GetServerPtr()->audioPolicyService_.OnReceiveBluetoothEvent(
325 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_, "deviceName");
326 GetServerPtr()->audioPolicyService_.GetAudioEffectOffloadFlag();
327 GetServerPtr()->audioPolicyService_.audioOffloadStream_.CheckSpatializationAndEffectState();
328 int32_t sessionId = GetData<int32_t>();
329 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->IsA2dpOffloadConnecting(sessionId);
330 std::vector<int32_t> playingStateVec = {
331 A2DP_STOPPED,
332 A2DP_PLAYING,
333 };
334 int32_t playingStateInt = GetData<int32_t>() % playingStateVec.size();
335 int32_t playingState = playingStateVec[playingStateInt];
336 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->a2dpOffloadDeviceAddress_ = "A2dpMacAddress";
337 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->audioA2dpOffloadFlag_.currentOffloadConnectionState_
338 = CONNECTION_STATUS_CONNECTED;
339 GetServerPtr()->
340 audioPolicyService_.audioA2dpOffloadManager_->OnA2dpPlayingStateChanged("A2dpMacAddressS", playingState);
341 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->audioA2dpOffloadFlag_.currentOffloadConnectionState_
342 = CONNECTION_STATUS_CONNECTING;
343 GetServerPtr()->
344 audioPolicyService_.audioA2dpOffloadManager_->OnA2dpPlayingStateChanged("A2dpMacAddress", playingState);
345 }
346
AudioPolicyServiceTestIII()347 void AudioPolicyServiceTestIII()
348 {
349 uint32_t rotate = GetData<uint32_t>();
350 GetServerPtr()->audioPolicyService_.SetRotationToEffect(rotate);
351 AudioRendererChangeInfo audioRendererChangeInfo;
352 int32_t clientUID = GetData<int32_t>();
353 int32_t sessionId = GetData<int32_t>();
354 int32_t clientPid1 = GetData<int32_t>();
355 audioRendererChangeInfo.clientUID = clientUID;
356 audioRendererChangeInfo.sessionId = sessionId;
357 audioRendererChangeInfo.clientPid = clientPid1;
358 audioRendererChangeInfo.rendererState = RENDERER_NEW;
359 AudioRendererInfo rendererInfo;
360 rendererInfo.streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
361 audioRendererChangeInfo.rendererInfo = rendererInfo;
362 GetServerPtr()->audioPolicyService_.audioScene_ = AUDIO_SCENE_PHONE_CALL;
363 GetServerPtr()->audioPolicyService_.streamCollector_.audioRendererChangeInfos_.
364 push_back(make_shared<AudioRendererChangeInfo>(audioRendererChangeInfo));
365 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->WaitForConnectionCompleted();
366
367 std::string dumpString = "";
368 GetServerPtr()->audioPolicyDump_.AudioStreamDump(dumpString);
369 GetServerPtr()->audioPolicyService_.audioVolumeManager_.ringerModeMute_ = true;
370 GetServerPtr()->audioPolicyService_.ResetRingerModeMute();
371
372 AudioStreamInfo audioStreamInfo = {};
373 audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
374 audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM;
375 audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
376 audioStreamInfo.channels = AudioChannel::STEREO;
377 DeviceType deviceType = GetData<DeviceType>();
378 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.ReloadA2dpOffloadOnDeviceChanged(deviceType,
379 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_, "DeviceName", audioStreamInfo);
380
381 int32_t sessionId = GetData<int32_t>();
382 RestoreInfo restoreInfo;
383 restoreInfo.restoreReason = static_cast<RestoreReason>(GetData<int32_t>());
384 restoreInfo.targetStreamFlag = GetData<int32_t>();
385 GetServerPtr()->audioPolicyService_.RestoreSession(sessionId, restoreInfo);
386 }
387
AudioPolicyServiceTestIV()388 void AudioPolicyServiceTestIV()
389 {
390 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
391 if (audioRendererFilter == nullptr) {return;}
392 audioRendererFilter->uid = getuid();
393 audioRendererFilter->rendererInfo.rendererFlags = STREAM_FLAG_FAST;
394 audioRendererFilter->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
395 std::vector<std::shared_ptr<AudioDeviceDescriptor>> desc;
396 AudioRoutingManager::GetInstance()->
397 GetPreferredOutputDeviceForRendererInfo(audioRendererFilter->rendererInfo, desc);
398 AudioModuleInfo audioModuleInfo;
399 AudioIOHandle ioHandle = GetServerPtr()->audioPolicyService_.audioPolicyManager_.OpenAudioPort(audioModuleInfo);
400 std::string moduleName = "moduleName";
401 GetServerPtr()->audioPolicyService_.audioIOHandleMap_.AddIOHandleInfo(moduleName, ioHandle);
402 GetServerPtr()->audioPolicyService_.CloseWakeUpAudioCapturer();
403 AudioDeviceDescriptor newDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
404 newDeviceInfo.networkId_ = LOCAL_NETWORK_ID;
405 newDeviceInfo.macAddress_ = GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_;
406 int32_t sessionId = GetData<int32_t>();
407 AudioPolicyUtils::GetInstance().GetSinkName(newDeviceInfo, sessionId);
408 AudioDeviceDescriptor ads;
409 ads.networkId_ = LOCAL_NETWORK_ID;
410 ads.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
411 AudioPolicyUtils::GetInstance().GetSinkName(ads, sessionId);
412 }
413
414 typedef void (*TestFuncs[4])();
415
416 TestFuncs g_testFuncs = {
417 AudioPolicyServiceTest,
418 AudioPolicyServiceTestII,
419 AudioPolicyServiceTestIII,
420 AudioPolicyServiceTestIV,
421 };
422
FuzzTest(const uint8_t * rawData,size_t size)423 bool FuzzTest(const uint8_t* rawData, size_t size)
424 {
425 if (rawData == nullptr) {
426 return false;
427 }
428
429 // initialize data
430 RAW_DATA = rawData;
431 g_dataSize = size;
432 g_pos = 0;
433
434 uint32_t code = GetData<uint32_t>();
435 uint32_t len = GetArrLength(g_testFuncs);
436 if (len > 0) {
437 g_testFuncs[code % len]();
438 } else {
439 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
440 }
441
442 return true;
443 }
444 } // namespace AudioStandard
445 } // namesapce OHOS
446
LLVMFuzzerInitialize(int * argc,char *** argv)447 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
448 {
449 OHOS::AudioStandard::AudioFuzzTestGetPermission();
450 return 0;
451 }
452
453 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)454 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
455 {
456 if (size < OHOS::AudioStandard::THRESHOLD) {
457 return 0;
458 }
459
460 OHOS::AudioStandard::FuzzTest(data, size);
461 return 0;
462 }
463