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_DISTRIBUTED_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 StreamPropInfo streamPropInfo;
235 AudioAdapterInfo adapterInfo = {};
236 adapterInfo.adapterName_ = "wakeup_input";
237 adapterInfo.adaptersupportScene_ = "supportScene";
238 std::list<PipeInfo> pipeInfos_;
239 PipeInfo pipeInfo = {};
240 pipeInfo.name_ = "wakeup_input";
241 pipeInfo.streamPropInfos_.push_back(streamPropInfo);
242 pipeInfos_.push_back(pipeInfo);
243 adapterInfo.pipeInfos_ = pipeInfos_;
244 GetServerPtr()->audioPolicyService_.audioConfigManager_.adapterInfoMap_ = {};
245 GetServerPtr()->audioPolicyService_.audioConfigManager_.adapterInfoMap_.
246 insert({AdaptersType::TYPE_PRIMARY, adapterInfo});
247 GetServerPtr()->audioPolicyService_.SetWakeUpAudioCapturerFromAudioServer(config);
248
249 vector<shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
250 AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
251 GetServerPtr()->audioPolicyService_.RegisterRemoteDevStatusCallback();
252 GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_
253 = DEVICE_TYPE_BLUETOOTH_A2DP;
254 uint32_t channelcount = GetData<uint32_t>();
255 GetServerPtr()->audioPolicyService_.ReconfigureAudioChannel(channelcount, DEVICE_TYPE_FILE_SINK);
256 GetServerPtr()->audioPolicyService_.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_FILE_SINK;
257 GetServerPtr()->audioPolicyService_.ReconfigureAudioChannel(channelcount, DEVICE_TYPE_FILE_SINK);
258 GetServerPtr()->audioPolicyService_.ReconfigureAudioChannel(channelcount, DEVICE_TYPE_FILE_SOURCE);
259 std::vector<DeviceType> DeviceTypeVec = {
260 DEVICE_TYPE_BLUETOOTH_A2DP,
261 DEVICE_TYPE_BLUETOOTH_SCO,
262 };
263 uint32_t deviceTypeInt = GetData<uint32_t>() % DeviceTypeVec.size();
264 DeviceType deviceType = DeviceTypeVec[deviceTypeInt];
265 GetServerPtr()->audioPolicyService_.audioVolumeManager_.IsBlueTooth(deviceType);
266 GetServerPtr()->audioPolicyService_.audioVolumeManager_.activeSafeTimeBt_ = ACTIVEBTTIME;
267 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CheckBlueToothActiveMusicTime(1);
268 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CheckWiredActiveMusicTime(1);
269 int32_t safeVolume = GetData<int32_t>();
270 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CheckBlueToothActiveMusicTime(safeVolume);
271 GetServerPtr()->audioPolicyService_.audioVolumeManager_.CheckWiredActiveMusicTime(safeVolume);
272 }
273
MakeAdapterInfoMap()274 void MakeAdapterInfoMap()
275 {
276 AudioAdapterInfo adapterInfo = {};
277 adapterInfo.adapterName_ = "wakeup_input";
278 adapterInfo.adaptersupportScene_ = "supportScene";
279 std::list<PipeInfo> pipeInfos_;
280 PipeInfo pipeInfo = {};
281 pipeInfo.name_ = "primary_input";
282 StreamPropInfo streamPropInfo;
283 pipeInfo.streamPropInfos_.push_back(streamPropInfo);
284 pipeInfos_.push_back(pipeInfo);
285 adapterInfo.pipeInfos_ = pipeInfos_;
286 GetServerPtr()->audioPolicyService_.audioConfigManager_.adapterInfoMap_.
287 insert({AdaptersType::TYPE_PRIMARY, adapterInfo});
288 }
289
AudioPolicyServiceTest()290 void AudioPolicyServiceTest()
291 {
292 AudioStreamInfo streamInfo;
293 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
294 streamInfo.channels = AudioChannel::STEREO;
295 streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
296 SessionInfo sessionInfo;
297 sessionInfo.sourceType = SOURCE_TYPE_VOICE_CALL;
298 sessionInfo.rate = RATE;
299 sessionInfo.channels = CHANNELS;
300 MakeAdapterInfoMap();
301 GetServerPtr()->audioPolicyService_.OnCapturerSessionAdded(SESSIONID, sessionInfo, streamInfo);
302
303 uint32_t deviceRoleInt = GetData<uint32_t>();
304 deviceRoleInt = (deviceRoleInt % ENUM_NUM) - 1;
305 DeviceRole deviceRole = static_cast<DeviceRole>(deviceRoleInt);
306 std::shared_ptr<AudioDeviceDescriptor> remoteDeviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
307
308 AudioStreamInfo audioStreamInfo = {};
309 audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
310 audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM;
311 audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
312 audioStreamInfo.channels = AudioChannel::STEREO;
313 InitGetServerService(deviceRole, audioStreamInfo);
314 GetServerPtr()->audioPolicyService_.OnDeviceConfigurationChanged(DEVICE_TYPE_BLUETOOTH_A2DP,
315 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_, "DeviceName", audioStreamInfo);
316
317 shared_ptr<AudioDeviceDescriptor> dis = make_shared<AudioDeviceDescriptor>();
318 dis->deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
319 dis->macAddress_ = GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_;
320 dis->deviceRole_ = OUTPUT_DEVICE;
321 GetServerPtr()->audioPolicyService_.audioDeviceManager_.connectedDevices_.push_back(dis);
322
323 std::vector<DeviceType> DeviceTypeVec = {
324 DEVICE_TYPE_BLUETOOTH_A2DP,
325 DEVICE_TYPE_BLUETOOTH_SCO,
326 };
327 uint32_t deviceTypeInt = GetData<uint32_t>() % DeviceTypeVec.size();
328 DeviceType deviceType = DeviceTypeVec[deviceTypeInt];
329 GetServerPtr()-> audioPolicyService_.OnForcedDeviceSelected(deviceType,
330 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_);
331 AudioPolicyServiceSecondTest(audioStreamInfo, remoteDeviceDescriptor);
332 AudioPolicyServiceThirdTest();
333 }
334
AudioPolicyServiceTestII()335 void AudioPolicyServiceTestII()
336 {
337 int32_t volumeLevel = GetData<int32_t>();
338 bool isA2dpDevice = GetData<bool>();
339 GetServerPtr()->audioPolicyService_.audioVolumeManager_.DealWithSafeVolume(volumeLevel, isA2dpDevice);
340 AudioStreamInfo audioStreamInfo = {};
341 audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
342 audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM;
343 audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
344 audioStreamInfo.channels = AudioChannel::STEREO;
345 A2dpDeviceConfigInfo configInfo = {audioStreamInfo, true};
346 volumeLevel = GetServerPtr()->audioPolicyService_.audioPolicyManager_.GetSafeVolumeLevel() + MOD_NUM_TWO;
347 GetServerPtr()->audioPolicyService_.audioA2dpDevice_.connectedA2dpDeviceMap_.insert({"activeBTDevice_1",
348 configInfo});
349 GetServerPtr()->audioPolicyService_.SetA2dpDeviceVolume("activeBTDevice_1", volumeLevel, isA2dpDevice);
350 DeviceType devType = GetData<DeviceType>();
351 DeviceBlockStatus status = GetData<DeviceBlockStatus>();
352 GetServerPtr()->audioPolicyService_.OnMicrophoneBlockedUpdate(devType, status);
353 vector<shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
354 AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
355 for (auto &capturerChangeInfo : audioCapturerChangeInfos) {
356 capturerChangeInfo->capturerInfo.sourceType = SOURCE_TYPE_VIRTUAL_CAPTURE;
357 capturerChangeInfo->capturerState = CAPTURER_PREPARED;
358 }
359 GetServerPtr()->audioPolicyService_.OnReceiveBluetoothEvent(
360 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_, "deviceName");
361 GetServerPtr()->audioPolicyService_.GetAudioEffectOffloadFlag();
362 GetServerPtr()->audioPolicyService_.audioOffloadStream_.CheckSpatializationAndEffectState();
363 int32_t sessionId = GetData<int32_t>();
364 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->IsA2dpOffloadConnecting(sessionId);
365 std::vector<int32_t> playingStateVec = {
366 A2DP_STOPPED,
367 A2DP_PLAYING,
368 };
369 int32_t playingStateInt = GetData<int32_t>() % playingStateVec.size();
370 int32_t playingState = playingStateVec[playingStateInt];
371 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->a2dpOffloadDeviceAddress_ = "A2dpMacAddress";
372 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->audioA2dpOffloadFlag_.currentOffloadConnectionState_
373 = CONNECTION_STATUS_CONNECTED;
374 GetServerPtr()->
375 audioPolicyService_.audioA2dpOffloadManager_->OnA2dpPlayingStateChanged("A2dpMacAddressS", playingState);
376 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->audioA2dpOffloadFlag_.currentOffloadConnectionState_
377 = CONNECTION_STATUS_CONNECTING;
378 GetServerPtr()->
379 audioPolicyService_.audioA2dpOffloadManager_->OnA2dpPlayingStateChanged("A2dpMacAddress", playingState);
380 GetServerPtr()->audioPolicyService_.LoadSplitModule("", NETWORKID);
381 GetServerPtr()->audioPolicyService_.LoadSplitModule(SPLITARGS, NETWORKID);
382 }
383
AudioPolicyServiceTestIII()384 void AudioPolicyServiceTestIII()
385 {
386 uint32_t rotate = GetData<uint32_t>();
387 GetServerPtr()->audioPolicyService_.SetRotationToEffect(rotate);
388 AudioRendererChangeInfo audioRendererChangeInfo;
389 int32_t clientUID = GetData<int32_t>();
390 int32_t sessionId = GetData<int32_t>();
391 int32_t clientPid1 = GetData<int32_t>();
392 audioRendererChangeInfo.clientUID = clientUID;
393 audioRendererChangeInfo.sessionId = sessionId;
394 audioRendererChangeInfo.clientPid = clientPid1;
395 audioRendererChangeInfo.rendererState = RENDERER_NEW;
396 AudioRendererInfo rendererInfo;
397 rendererInfo.streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
398 audioRendererChangeInfo.rendererInfo = rendererInfo;
399 GetServerPtr()->audioPolicyService_.audioScene_ = AUDIO_SCENE_PHONE_CALL;
400 GetServerPtr()->audioPolicyService_.streamCollector_.audioRendererChangeInfos_.
401 push_back(make_shared<AudioRendererChangeInfo>(audioRendererChangeInfo));
402 GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->WaitForConnectionCompleted();
403
404 std::string dumpString = "";
405 GetServerPtr()->audioPolicyDump_.AudioStreamDump(dumpString);
406 GetServerPtr()->audioPolicyService_.audioVolumeManager_.ringerModeMute_ = true;
407 GetServerPtr()->audioPolicyService_.ResetRingerModeMute();
408
409 AudioStreamInfo audioStreamInfo = {};
410 audioStreamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
411 audioStreamInfo.encoding = AudioEncodingType::ENCODING_PCM;
412 audioStreamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
413 audioStreamInfo.channels = AudioChannel::STEREO;
414 DeviceType deviceType = GetData<DeviceType>();
415 GetServerPtr()->audioPolicyService_.audioDeviceStatus_.ReloadA2dpOffloadOnDeviceChanged(deviceType,
416 GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_, "DeviceName", audioStreamInfo);
417
418 int32_t sessionId = GetData<int32_t>();
419 RestoreInfo restoreInfo;
420 restoreInfo.restoreReason = static_cast<RestoreReason>(GetData<int32_t>());
421 restoreInfo.targetStreamFlag = GetData<int32_t>();
422 GetServerPtr()->audioPolicyService_.RestoreSession(sessionId, restoreInfo);
423 }
424
AudioPolicyServiceTestIV()425 void AudioPolicyServiceTestIV()
426 {
427 sptr<AudioRendererFilter> audioRendererFilter = new(std::nothrow) AudioRendererFilter();
428 if (audioRendererFilter == nullptr) {return;}
429 audioRendererFilter->uid = getuid();
430 audioRendererFilter->rendererInfo.rendererFlags = STREAM_FLAG_FAST;
431 audioRendererFilter->rendererInfo.streamUsage = STREAM_USAGE_MUSIC;
432 std::vector<std::shared_ptr<AudioDeviceDescriptor>> desc;
433 AudioRoutingManager::GetInstance()->
434 GetPreferredOutputDeviceForRendererInfo(audioRendererFilter->rendererInfo, desc);
435 AudioModuleInfo audioModuleInfo;
436 AudioIOHandle ioHandle = GetServerPtr()->audioPolicyService_.audioPolicyManager_.OpenAudioPort(audioModuleInfo);
437 std::string moduleName = "moduleName";
438 GetServerPtr()->audioPolicyService_.audioIOHandleMap_.AddIOHandleInfo(moduleName, ioHandle);
439 GetServerPtr()->audioPolicyService_.CloseWakeUpAudioCapturer();
440 AudioDeviceDescriptor newDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
441 newDeviceInfo.networkId_ = LOCAL_NETWORK_ID;
442 newDeviceInfo.macAddress_ = GetServerPtr()->audioPolicyService_.audioActiveDevice_.activeBTDevice_;
443 int32_t sessionId = GetData<int32_t>();
444 AudioPolicyUtils::GetInstance().GetSinkName(newDeviceInfo, sessionId);
445 AudioDeviceDescriptor ads;
446 ads.networkId_ = LOCAL_NETWORK_ID;
447 ads.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
448 AudioPolicyUtils::GetInstance().GetSinkName(ads, sessionId);
449 }
450
451 typedef void (*TestFuncs[4])();
452
453 TestFuncs g_testFuncs = {
454 AudioPolicyServiceTest,
455 AudioPolicyServiceTestII,
456 AudioPolicyServiceTestIII,
457 AudioPolicyServiceTestIV,
458 };
459
FuzzTest(const uint8_t * rawData,size_t size)460 bool FuzzTest(const uint8_t* rawData, size_t size)
461 {
462 if (rawData == nullptr) {
463 return false;
464 }
465
466 // initialize data
467 RAW_DATA = rawData;
468 g_dataSize = size;
469 g_pos = 0;
470
471 uint32_t code = GetData<uint32_t>();
472 uint32_t len = GetArrLength(g_testFuncs);
473 if (len > 0) {
474 g_testFuncs[code % len]();
475 } else {
476 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
477 }
478
479 return true;
480 }
481 } // namespace AudioStandard
482 } // namesapce OHOS
483
LLVMFuzzerInitialize(int * argc,char *** argv)484 extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv)
485 {
486 OHOS::AudioStandard::AudioFuzzTestGetPermission();
487 return 0;
488 }
489
490 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)491 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
492 {
493 if (size < OHOS::AudioStandard::THRESHOLD) {
494 return 0;
495 }
496
497 OHOS::AudioStandard::FuzzTest(data, size);
498 return 0;
499 }
500