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 <string>
20
21 #include "audio_manager_base.h"
22 #include "audio_policy_manager_listener_stub_impl.h"
23 #include "audio_server.h"
24 #include "message_parcel.h"
25 #include "audio_process_in_client.h"
26 #include "audio_param_parser.h"
27 #include "audio_process_config.h"
28 #include "ipc_stream_in_server.h"
29 #include "pulseaudio_ipc_interface_code.h"
30 #include "audio_server_hpae_dump.h"
31 #include "audio_info.h"
32 #include "hpae_info.h"
33 using namespace std;
34
35 namespace OHOS {
36 namespace AudioStandard {
37 const std::u16string FORMMGR_INTERFACE_TOKEN = u"OHOS.AudioStandard.IAudioPolicy";
38 const int32_t SYSTEM_ABILITY_ID = 3001;
39 const bool RUN_ON_CREATE = false;
40 const int32_t LIMITSIZE = 4;
41 const uint32_t COMMON_SIZE = 2;
42 const int32_t COMMON_INT = 2;
43 const std::u16string COMMONU16STRTEST = u"Test";
44 const uint32_t IOPERTAION_LENGTH = 13;
45 const uint32_t ENUM_LENGTH = 15;
46 const uint32_t ENUM_LENGTH_1 = 6;
47 const uint32_t ENUM_LENGTH_2 = 1;
48 const uint32_t APPID_LENGTH = 10;
49 const uint64_t COMMON_UINT64_NUM = 2;
50 const uint32_t RES_TYPE_AUDIO_RENDERER_STANDBY = 119;
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
AudioServerSetSpatializationSceneTypeTest(const uint8_t * rawData,size_t size)86 void AudioServerSetSpatializationSceneTypeTest(const uint8_t *rawData, size_t size)
87 {
88 if (rawData == nullptr || size < LIMITSIZE) {
89 return;
90 }
91 MessageParcel reply;
92 MessageOption option;
93 MessageParcel data;
94 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
95 uint32_t sizeMs = *reinterpret_cast<const uint32_t*>(rawData);
96 data.WriteUint32(sizeMs);
97 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
98
99 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_SPATIALIZATION_SCENE_TYPE),
100 data, reply, option);
101 }
102
AudioServerUpdateSpatialDeviceTypeTest(const uint8_t * rawData,size_t size)103 void AudioServerUpdateSpatialDeviceTypeTest(const uint8_t *rawData, size_t size)
104 {
105 if (rawData == nullptr || size < LIMITSIZE) {
106 return;
107 }
108 MessageParcel reply;
109 MessageOption option;
110 MessageParcel data;
111 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
112 uint32_t sizeMs = *reinterpret_cast<const uint32_t*>(rawData);
113 data.WriteUint32(sizeMs);
114 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
115
116 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_SPATIAL_DEVICE_TYPE),
117 data, reply, option);
118 }
119
AudioServerLoadConfigurationTest(const uint8_t * rawData,size_t size)120 void AudioServerLoadConfigurationTest(const uint8_t *rawData, size_t size)
121 {
122 if (rawData == nullptr || size < LIMITSIZE) {
123 return;
124 }
125 std::unordered_map<std::string, std::unordered_map<std::string, std::set<std::string>>> audioParameterKeys = {};
126 std::unordered_map<std::string, std::set<std::string>> audioParameterKey = {};
127 std::set<std::string> audioParameterValue = {};
128 std::string audioParameterKeyStr1 = "key1";
129 std::string audioParameterKeyStr2 = "key2";
130 std::string audioParameterKeyValueStr1 = "value1";
131 std::string audioParameterKeyValueStr2 = "value2";
132 audioParameterValue.insert(audioParameterKeyValueStr1);
133 audioParameterValue.insert(audioParameterKeyValueStr2);
134 audioParameterKey.insert(std::make_pair(audioParameterKeyStr1, audioParameterValue));
135 audioParameterKey.insert(std::make_pair(audioParameterKeyStr2, audioParameterValue));
136 audioParameterKeys.insert(std::make_pair(audioParameterKeyStr1, audioParameterKey));
137 audioParameterKeys.insert(std::make_pair(audioParameterKeyStr2, audioParameterKey));
138
139 std::shared_ptr<AudioParamParser> audioParamParser = std::make_shared<AudioParamParser>();
140 audioParamParser->LoadConfiguration(audioParameterKeys);
141 }
142
AudioServerGetExtarAudioParametersTest(const uint8_t * rawData,size_t size)143 void AudioServerGetExtarAudioParametersTest(const uint8_t* rawData, size_t size)
144 {
145 if (rawData == nullptr || size < LIMITSIZE) {
146 return;
147 }
148
149 MessageParcel data;
150 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
151 std::string mainKey = "mainKey";
152 std::string value1 = "value1";
153 std::string value2 = "value2";
154 std::vector<std::string> subkeys = {};
155 subkeys.push_back(value1);
156 subkeys.push_back(value2);
157
158 data.WriteString(static_cast<std::string>(mainKey));
159 data.WriteInt32(subkeys.size());
160 for (std::string subKey : subkeys) {
161 data.WriteString(static_cast<std::string>(subKey));
162 }
163
164 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
165 MessageParcel reply;
166 MessageOption option;
167 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_EXTRA_AUDIO_PARAMETERS),
168 data, reply, option);
169 }
170
AudioServerSetExtraAudioParametersTest(const uint8_t * rawData,size_t size)171 void AudioServerSetExtraAudioParametersTest(const uint8_t* rawData, size_t size)
172 {
173 if (rawData == nullptr || size < LIMITSIZE) {
174 return;
175 }
176
177 MessageParcel data;
178 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
179 std::string mainKey = "mainKey";
180 std::vector<std::pair<std::string, std::string>> kvpairs;
181 for (uint32_t i = 0; i < COMMON_SIZE; i++) {
182 std::string subKey = "subKey" + std::to_string(i);
183 std::string subValue = "subValue" + std::to_string(i);
184 kvpairs.push_back(std::make_pair(subKey, subValue));
185 }
186
187 data.WriteString(mainKey);
188 data.WriteInt32(static_cast<int32_t>(kvpairs.size()));
189 for (auto it = kvpairs.begin(); it != kvpairs.end(); it++) {
190 data.WriteString(static_cast<std::string>(it->first));
191 data.WriteString(static_cast<std::string>(it->second));
192 }
193
194 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
195 MessageParcel reply;
196 MessageOption option;
197 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_EXTRA_AUDIO_PARAMETERS),
198 data, reply, option);
199 }
200
AudioServerUpdateRouteReqTest(const uint8_t * rawData,size_t size)201 void AudioServerUpdateRouteReqTest(const uint8_t* rawData, size_t size)
202 {
203 if (rawData == nullptr || size < LIMITSIZE) {
204 return;
205 }
206
207 MessageParcel data;
208 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
209
210 DeviceType type = *reinterpret_cast<const DeviceType*>(rawData);
211 DeviceFlag flag = *reinterpret_cast<const DeviceFlag*>(rawData);
212 BluetoothOffloadState a2dpOffloadFlag = *reinterpret_cast<const BluetoothOffloadState*>(rawData);
213 data.WriteInt32(type);
214 data.WriteInt32(flag);
215 data.WriteInt32(static_cast<int32_t>(a2dpOffloadFlag));
216
217 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
218 MessageParcel reply;
219 MessageOption option;
220 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_ROUTE_REQ),
221 data, reply, option);
222 }
223
AudioServerUpdateActiveDevicesRouteTest(const uint8_t * rawData,size_t size)224 void AudioServerUpdateActiveDevicesRouteTest(const uint8_t* rawData, size_t size)
225 {
226 if (rawData == nullptr || size < LIMITSIZE) {
227 return;
228 }
229
230 MessageParcel data;
231 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
232 std::vector<std::pair<DeviceType, DeviceFlag>> activeDevices;
233 for (uint32_t i = 0; i < COMMON_SIZE; i++) {
234 DeviceType deviceType = *reinterpret_cast<const DeviceType*>(rawData);
235 DeviceFlag deviceFlag = *reinterpret_cast<const DeviceFlag*>(rawData);
236 activeDevices.push_back(std::make_pair(deviceType, deviceFlag));
237 }
238 data.WriteInt32(static_cast<int32_t>(activeDevices.size()));
239 for (auto it = activeDevices.begin(); it != activeDevices.end(); it++) {
240 data.WriteInt32(static_cast<int32_t>(it->first));
241 data.WriteInt32(static_cast<int32_t>(it->second));
242 }
243
244 BluetoothOffloadState a2dpOffloadFlag = *reinterpret_cast<const BluetoothOffloadState*>(rawData);
245 data.WriteInt32(static_cast<int32_t>(a2dpOffloadFlag));
246
247 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
248 MessageParcel reply;
249 MessageOption option;
250 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_ROUTES_REQ),
251 data, reply, option);
252 }
253
AudioServerUpdateDualToneStateTest(const uint8_t * rawData,size_t size)254 void AudioServerUpdateDualToneStateTest(const uint8_t* rawData, size_t size)
255 {
256 if (rawData == nullptr || size < LIMITSIZE) {
257 return;
258 }
259
260 MessageParcel data;
261 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
262 bool enable = *reinterpret_cast<const bool*>(rawData);
263 int32_t sessionId = *reinterpret_cast<const int32_t*>(rawData);
264
265 data.WriteBool(enable);
266 data.WriteInt32(sessionId);
267
268 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
269 MessageParcel reply;
270 MessageOption option;
271 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_DUAL_TONE_REQ),
272 data, reply, option);
273 }
274
AudioServerGetTransactionIdTest(const uint8_t * rawData,size_t size)275 void AudioServerGetTransactionIdTest(const uint8_t* rawData, size_t size)
276 {
277 if (rawData == nullptr || size < LIMITSIZE) {
278 return;
279 }
280
281 MessageParcel data;
282 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
283 DeviceType deviceType = *reinterpret_cast<const DeviceType*>(rawData);
284 DeviceRole deviceRole = *reinterpret_cast<const DeviceRole*>(rawData);
285 data.WriteInt32(deviceType);
286 data.WriteInt32(deviceRole);
287 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
288 MessageParcel reply;
289 MessageOption option;
290 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_TRANSACTION_ID),
291 data, reply, option);
292 }
293
AudioGetAudioParameterTest(const uint8_t * rawData,size_t size)294 void AudioGetAudioParameterTest(const uint8_t* rawData, size_t size)
295 {
296 if (rawData == nullptr || size < LIMITSIZE || size < sizeof(AudioParamKey)) {
297 return;
298 }
299
300 MessageParcel data;
301 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
302
303 std::string networkId(reinterpret_cast<const char*>(rawData), size);
304 std::string condition(reinterpret_cast<const char*>(rawData), size);
305 AudioParamKey key = *reinterpret_cast<const AudioParamKey*>(rawData);
306 data.WriteString(networkId);
307 data.WriteInt32(static_cast<int32_t>(key));
308 data.WriteString(condition);
309
310 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
311 MessageParcel reply;
312 MessageOption option;
313 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_REMOTE_AUDIO_PARAMETER),
314 data, reply, option);
315 }
316
AudioSetAudioParameterTest(const uint8_t * rawData,size_t size)317 void AudioSetAudioParameterTest(const uint8_t* rawData, size_t size)
318 {
319 if (rawData == nullptr || size < LIMITSIZE || size < sizeof(AudioParamKey)) {
320 return;
321 }
322
323 MessageParcel data;
324 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
325
326 std::string networkId = "123";
327 std::string condition = "123456";
328 std::string value = "123456";
329 AudioParamKey key = *reinterpret_cast<const AudioParamKey*>(rawData);
330 data.WriteString(networkId);
331 data.WriteInt32(static_cast<uint32_t>(key));
332 data.WriteString(condition);
333 data.WriteString(value);
334
335 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
336 MessageParcel reply;
337 MessageOption option;
338 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_REMOTE_AUDIO_PARAMETER),
339 data, reply, option);
340 }
341
AudioCreateAudioProcessTest(const uint8_t * rawData,size_t size)342 void AudioCreateAudioProcessTest(const uint8_t* rawData, size_t size)
343 {
344 if (rawData == nullptr || size < LIMITSIZE) {
345 return;
346 }
347
348 MessageParcel data;
349 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
350 AudioProcessConfig config;
351 config.appInfo.appUid = APPID_LENGTH;
352 config.appInfo.appPid = APPID_LENGTH;
353 config.streamInfo.format = SAMPLE_S32LE;
354 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
355 config.streamInfo.channels = STEREO;
356 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
357 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
358 config.streamType = AudioStreamType::STREAM_MUSIC;
359 config.deviceType = DEVICE_TYPE_USB_HEADSET;
360
361 config.Marshalling(data);
362
363 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
364 MessageParcel reply;
365 MessageOption option;
366 audioServer->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CREATE_AUDIOPROCESS),
367 data, reply, option);
368 }
369
AudioLoadAudioEffectLibrariesTest(const uint8_t * rawData,size_t size)370 void AudioLoadAudioEffectLibrariesTest(const uint8_t* rawData, size_t size)
371 {
372 if (rawData == nullptr || size < LIMITSIZE) {
373 return;
374 }
375
376 MessageParcel data;
377 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
378 data.WriteInt32(COMMON_INT);
379 data.WriteInt32(COMMON_INT);
380 for (int32_t i = 0; i < COMMON_INT; i++) {
381 std::string libName(reinterpret_cast<const char*>(rawData), size - 1);
382 std::string libPath(reinterpret_cast<const char*>(rawData), size - 1);
383 data.WriteString(libName);
384 data.WriteString(libPath);
385 }
386
387 for (int32_t i = 0; i < COMMON_INT; i++) {
388 std::string effectName = "effectName" + std::to_string(i);
389 std::string libName = "libName" + std::to_string(i);
390 data.WriteString(effectName);
391 data.WriteString(libName);
392 }
393
394 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
395 MessageParcel reply;
396 MessageOption option;
397 audioServer->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::LOAD_AUDIO_EFFECT_LIBRARIES),
398 data, reply, option);
399 }
400
AudioCapturerInServerTestFirst(std::shared_ptr<CapturerInServer> capturerInServer)401 void AudioCapturerInServerTestFirst(std::shared_ptr<CapturerInServer> capturerInServer)
402 {
403 capturerInServer->Init();
404 capturerInServer->Start();
405 capturerInServer->ConfigServerBuffer();
406 if (capturerInServer->isInited_ == true) {
407 capturerInServer->InitBufferStatus();
408 capturerInServer->UpdateReadIndex();
409 }
410 uint32_t sessionId;
411 capturerInServer->GetSessionId(sessionId);
412 capturerInServer->DrainAudioBuffer();
413 capturerInServer->Pause();
414 capturerInServer->Flush();
415 capturerInServer->Stop();
416 capturerInServer->Release();
417 }
418
AudioCapturerInServerFuzzTest()419 void AudioCapturerInServerFuzzTest()
420 {
421 std::shared_ptr<CapturerInServer> capturerInServer = nullptr;
422 AudioProcessConfig config;
423 config.appInfo.appUid = APPID_LENGTH;
424 config.appInfo.appPid = APPID_LENGTH;
425 config.streamInfo.format = SAMPLE_S32LE;
426 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
427 config.streamInfo.channels = STEREO;
428 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
429 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
430 config.streamType = AudioStreamType::STREAM_MUSIC;
431 config.deviceType = DEVICE_TYPE_USB_HEADSET;
432 std::weak_ptr<IStreamListener> innerListener;
433 capturerInServer = std::make_shared<CapturerInServer>(config, innerListener);
434 if (capturerInServer == nullptr) {
435 return;
436 }
437 uint32_t operationCode = GetData<uint32_t>();
438 operationCode = (operationCode % IOPERTAION_LENGTH) - 1;
439 IOperation operation = static_cast<IOperation>(operationCode);
440 capturerInServer->OnStatusUpdate(operation);
441 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
442 capturerInServer->ResolveBuffer(buffer);
443 uint32_t sessionId = GetData<uint32_t>();
444 capturerInServer->GetSessionId(sessionId);
445 AudioCapturerInServerTestFirst(capturerInServer);
446 }
447
AudioRendererInServerTestFirst(std::shared_ptr<RendererInServer> renderer)448 void AudioRendererInServerTestFirst(std::shared_ptr<RendererInServer> renderer)
449 {
450 uint32_t operationCode = GetData<uint32_t>();
451 operationCode = (operationCode % IOPERTAION_LENGTH) - 1;
452 IOperation operation = static_cast<IOperation>(operationCode);
453 renderer->OnStatusUpdate(operation);
454 renderer->HandleOperationFlushed();
455 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
456 renderer->ResolveBuffer(buffer);
457 uint32_t sessionId = GetData<uint32_t>();
458 renderer->GetSessionId(sessionId);
459 uint64_t framePos = COMMON_UINT64_NUM;
460 uint64_t timeStamp = COMMON_UINT64_NUM;
461 uint64_t latency = COMMON_UINT64_NUM;
462 int32_t base = GetData<int32_t>();
463 renderer->GetAudioTime(framePos, timeStamp);
464 renderer->GetAudioPosition(framePos, timeStamp, latency, base);
465 renderer->GetLatency(latency);
466 int32_t rate = GetData<int32_t>();
467 renderer->SetRate(rate);
468 float volume = GetData<float>();
469 renderer->SetLowPowerVolume(volume);
470 renderer->GetLowPowerVolume(volume);
471 int32_t effectMode = GetData<int32_t>();
472 renderer->SetAudioEffectMode(effectMode);
473 renderer->GetAudioEffectMode(effectMode);
474 int32_t privacyType = GetData<int32_t>();
475 renderer->SetPrivacyType(privacyType);
476 renderer->GetPrivacyType(privacyType);
477 int32_t state = GetData<int32_t>();
478 bool isAppBack = GetData<bool>();
479 renderer->SetOffloadMode(state, isAppBack);
480 renderer->UnsetOffloadMode();
481 }
482
AudioRendererInServerTestSecond(std::shared_ptr<RendererInServer> renderer)483 void AudioRendererInServerTestSecond(std::shared_ptr<RendererInServer> renderer)
484 {
485 bool isAppBack = GetData<bool>();
486 bool headTrackingEnabled = GetData<bool>();
487 RestoreInfo restoreInfo;
488 restoreInfo.restoreReason = static_cast<RestoreReason>(GetData<int32_t>());
489 restoreInfo.targetStreamFlag = GetData<int32_t>();
490 renderer->UpdateSpatializationState(isAppBack, headTrackingEnabled);
491 renderer->CheckAndWriterRenderStreamStandbySysEvent(GetData<bool>());
492 uint64_t timeStamp = COMMON_UINT64_NUM;
493 renderer->GetOffloadApproximatelyCacheTime(timeStamp, timeStamp, timeStamp, timeStamp);
494 BufferDesc desc;
495 desc.buffer = nullptr;
496 desc.bufLength = 0;
497 desc.dataLength =0;
498 renderer->VolumeHandle(desc);
499 renderer->WriteData();
500 renderer->WriteEmptyData();
501 renderer->DrainAudioBuffer();
502 renderer->EnableInnerCap(1);
503 renderer->DisableInnerCap(1);
504 renderer->InitDupStream(1);
505 renderer->EnableDualTone();
506 renderer->DisableDualTone();
507 renderer->InitDualToneStream();
508 renderer->GetStreamManagerType();
509 renderer->SetSilentModeAndMixWithOthers(isAppBack);
510 renderer->SetClientVolume();
511 uint32_t operationCode = GetData<uint32_t>();
512 operationCode = (operationCode % IOPERTAION_LENGTH) - 1;
513 IOperation operation = static_cast<IOperation>(operationCode);
514 renderer->OnDataLinkConnectionUpdate(operation);
515 std::string dumpString = "";
516 renderer->managerType_ = DIRECT_PLAYBACK;
517 renderer->Dump(dumpString);
518 bool muteFlag = false;
519 renderer->SetNonInterruptMute(muteFlag);
520 renderer->RestoreSession(restoreInfo);
521 renderer->Pause();
522 renderer->Flush();
523 renderer->Drain(headTrackingEnabled);
524 renderer->Stop();
525 renderer->Release();
526 }
527
AudioRendererInServerTest()528 void AudioRendererInServerTest()
529 {
530 AudioProcessConfig config;
531 config.appInfo.appUid = APPID_LENGTH;
532 config.appInfo.appPid = APPID_LENGTH;
533 config.streamInfo.format = SAMPLE_S32LE;
534 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
535 config.streamInfo.channels = STEREO;
536 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
537 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
538 config.streamType = AudioStreamType::STREAM_MUSIC;
539 config.deviceType = DEVICE_TYPE_USB_HEADSET;
540 int32_t ret = 0;
541 sptr<IpcStreamInServer> ipcStreamInServer = IpcStreamInServer::Create(config, ret);
542 if (ipcStreamInServer == nullptr) {
543 return;
544 }
545 std::shared_ptr<RendererInServer> renderer = ipcStreamInServer->GetRenderer();
546 renderer->Init();
547 renderer->Start();
548 renderer->ConfigServerBuffer();
549 renderer->InitBufferStatus();
550 renderer->UpdateWriteIndex();
551 uint32_t statusInt = GetData<uint32_t>();
552 statusInt = (statusInt % ENUM_LENGTH) -ENUM_LENGTH_2;
553 IStatus status = static_cast<IStatus>(statusInt);
554 uint32_t typeInt = GetData<uint32_t>();
555 typeInt = typeInt % ENUM_LENGTH_1;
556 ManagerType type = static_cast<ManagerType>(typeInt);
557 renderer->managerType_ = type;
558 renderer->status_ = status;
559 std::string dumpString = "";
560 renderer->Dump(dumpString);
561 renderer->SetStreamVolumeInfoForEnhanceChain();
562 std::unordered_map<std::string, std::string> payload;
563 renderer->ReportDataToResSched(payload, RES_TYPE_AUDIO_RENDERER_STANDBY);
564 AudioRendererInServerTestFirst(renderer);
565 AudioRendererInServerTestSecond(renderer);
566 }
567
AudioMicroPhoneFuzzTest()568 void AudioMicroPhoneFuzzTest()
569 {
570 sptr<MicrophoneDescriptor> micDesc = new (std::nothrow) MicrophoneDescriptor();
571 MicrophoneDescriptor micDescs;
572 Vector3D vector3d;
573 vector3d.x = 0.0f;
574 vector3d.y = 0.0f;
575 vector3d.z = 0.0f;
576 micDesc->SetMicPositionInfo(vector3d);
577 micDesc->SetMicOrientationInfo(vector3d);
578 }
579
580 typedef void (*TestFuncs[3])();
581
582 TestFuncs g_testFuncs = {
583 AudioCapturerInServerFuzzTest,
584 AudioRendererInServerTest,
585 AudioMicroPhoneFuzzTest,
586 };
587
FuzzTest(const uint8_t * rawData,size_t size)588 bool FuzzTest(const uint8_t* rawData, size_t size)
589 {
590 if (rawData == nullptr) {
591 return false;
592 }
593
594 // initialize data
595 RAW_DATA = rawData;
596 g_dataSize = size;
597 g_pos = 0;
598
599 uint32_t code = GetData<uint32_t>();
600 uint32_t len = GetArrLength(g_testFuncs);
601 if (len > 0) {
602 g_testFuncs[code % len]();
603 } else {
604 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
605 }
606
607 return true;
608 }
AudioServerSetAsrAecModeFuzzTest(const uint8_t * rawData,size_t size)609 void AudioServerSetAsrAecModeFuzzTest(const uint8_t *rawData, size_t size)
610 {
611 if (rawData == nullptr || size < LIMITSIZE) {
612 return;
613 }
614 int32_t asrAecMode = *reinterpret_cast<const int32_t*>(rawData);
615 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
616 audioServerPtr->SetAsrAecMode(asrAecMode);
617 }
618
AudioServerGetAsrAecModeFuzzTest(const uint8_t * rawData,size_t size)619 void AudioServerGetAsrAecModeFuzzTest(const uint8_t *rawData, size_t size)
620 {
621 if (rawData == nullptr || size < LIMITSIZE) {
622 return;
623 }
624 int32_t asrAecMode = *reinterpret_cast<const int32_t*>(rawData);
625 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
626 audioServerPtr->GetAsrAecMode(asrAecMode);
627 }
628
AudioServerGetAsrNoiseSuppressionModeFuzzTest(const uint8_t * rawData,size_t size)629 void AudioServerGetAsrNoiseSuppressionModeFuzzTest(const uint8_t *rawData, size_t size)
630 {
631 if (rawData == nullptr || size < LIMITSIZE) {
632 return;
633 }
634 int32_t asrNoiseSuppressionMode = *reinterpret_cast<const int32_t*>(rawData);
635 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
636 audioServerPtr->GetAsrNoiseSuppressionMode(asrNoiseSuppressionMode);
637 }
638
AudioServerSetAsrWhisperDetectionModeFuzzTest(const uint8_t * rawData,size_t size)639 void AudioServerSetAsrWhisperDetectionModeFuzzTest(const uint8_t *rawData, size_t size)
640 {
641 if (rawData == nullptr || size < LIMITSIZE) {
642 return;
643 }
644 int32_t asrNoiseSuppressionMode = *reinterpret_cast<const int32_t*>(rawData);
645 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
646 audioServerPtr->SetAsrWhisperDetectionMode(asrNoiseSuppressionMode);
647 }
648
AudioServerGetAsrWhisperDetectionModeFuzzTest(const uint8_t * rawData,size_t size)649 void AudioServerGetAsrWhisperDetectionModeFuzzTest(const uint8_t *rawData, size_t size)
650 {
651 if (rawData == nullptr || size < LIMITSIZE) {
652 return;
653 }
654 int32_t asrNoiseSuppressionMode = *reinterpret_cast<const int32_t*>(rawData);
655 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
656 audioServerPtr->GetAsrWhisperDetectionMode(asrNoiseSuppressionMode);
657 }
658
AudioServerSetAsrVoiceSuppressionControlModeFuzzTest(const uint8_t * rawData,size_t size)659 void AudioServerSetAsrVoiceSuppressionControlModeFuzzTest(const uint8_t *rawData, size_t size)
660 {
661 if (rawData == nullptr || size < LIMITSIZE) {
662 return;
663 }
664 vector<AudioParamKey> audioParamKey {
665 NONE,
666 VOLUME,
667 INTERRUPT,
668 PARAM_KEY_STATE,
669 A2DP_SUSPEND_STATE,
670 BT_HEADSET_NREC,
671 BT_WBS,
672 A2DP_OFFLOAD_STATE,
673 GET_DP_DEVICE_INFO,
674 GET_PENCIL_INFO,
675 GET_UWB_INFO,
676 USB_DEVICE,
677 PERF_INFO,
678 MMI,
679 PARAM_KEY_LOWPOWER,
680 };
681 uint32_t keyId = *reinterpret_cast<const uint32_t*>(rawData) % audioParamKey.size();
682 AudioParamKey paramKey = static_cast<AudioParamKey>(audioParamKey[keyId]);
683 AsrVoiceControlMode asrVoiceControlMode = AsrVoiceControlMode::AUDIO_SUPPRESSION_OPPOSITE;
684 bool on = *reinterpret_cast<const bool*>(rawData);
685 int32_t modifyVolume = *reinterpret_cast<const int32_t*>(rawData);
686 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
687 audioServerPtr->SetAsrVoiceSuppressionControlMode(paramKey, asrVoiceControlMode, on, modifyVolume);
688 }
689
AudioServerSetAsrVoiceControlModeFuzzTest(const uint8_t * rawData,size_t size)690 void AudioServerSetAsrVoiceControlModeFuzzTest(const uint8_t *rawData, size_t size)
691 {
692 if (rawData == nullptr || size < LIMITSIZE) {
693 return;
694 }
695 int32_t asrVoiceControlMode = *reinterpret_cast<const int32_t*>(rawData);
696 bool on = *reinterpret_cast<const bool*>(rawData);
697 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
698 audioServerPtr->SetAsrVoiceControlMode(asrVoiceControlMode, on);
699 }
700
AudioServerSetAsrVoiceMuteModeFuzzTest(const uint8_t * rawData,size_t size)701 void AudioServerSetAsrVoiceMuteModeFuzzTest(const uint8_t *rawData, size_t size)
702 {
703 if (rawData == nullptr || size < LIMITSIZE) {
704 return;
705 }
706 int32_t asrVoiceControlMode = *reinterpret_cast<const int32_t*>(rawData);
707 bool on = *reinterpret_cast<const bool*>(rawData);
708 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
709 audioServerPtr->SetAsrVoiceMuteMode(asrVoiceControlMode, on);
710 }
711
AudioServerIsWhisperingFuzzTest(const uint8_t * rawData,size_t size)712 void AudioServerIsWhisperingFuzzTest(const uint8_t *rawData, size_t size)
713 {
714 if (rawData == nullptr || size < LIMITSIZE) {
715 return;
716 }
717 int32_t whisperRes = *reinterpret_cast<const int32_t*>(rawData);
718 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
719 audioServerPtr->IsWhispering(whisperRes);
720 }
721
AudioServerHpaeDumpServerDataDumpFuzzTest(const uint8_t * rawData,size_t size)722 void AudioServerHpaeDumpServerDataDumpFuzzTest(const uint8_t *rawData, size_t size)
723 {
724 if (rawData == nullptr || size < LIMITSIZE) {
725 return;
726 }
727 std::string dumpString = "test_dumpString";
728 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
729 audioServerHpaeDumpPtr->ServerDataDump(dumpString);
730 }
731
AudioServerHpaeDumpGetDeviceSinkInfoFuzzTest(const uint8_t * rawData,size_t size)732 void AudioServerHpaeDumpGetDeviceSinkInfoFuzzTest(const uint8_t *rawData, size_t size)
733 {
734 if (rawData == nullptr || size < LIMITSIZE) {
735 return;
736 }
737 std::string dumpString = "test_dumpString";
738 std::string deviceName = "test_deviceName";
739 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
740 audioServerHpaeDumpPtr->GetDeviceSinkInfo(dumpString, deviceName);
741 }
742
AudioServerHpaeDumpPlaybackSinkDumpFuzzTest(const uint8_t * rawData,size_t size)743 void AudioServerHpaeDumpPlaybackSinkDumpFuzzTest(const uint8_t *rawData, size_t size)
744 {
745 if (rawData == nullptr || size < LIMITSIZE) {
746 return;
747 }
748 std::string dumpString = "test_dumpString";
749 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
750 audioServerHpaeDumpPtr->PlaybackSinkDump(dumpString);
751 }
752
AudioServerHpaeDumpOnDumpSinkInfoCbFuzzTest(const uint8_t * rawData,size_t size)753 void AudioServerHpaeDumpOnDumpSinkInfoCbFuzzTest(const uint8_t *rawData, size_t size)
754 {
755 if (rawData == nullptr || size < LIMITSIZE) {
756 return;
757 }
758 std::string dumpStr = "test_dumpStr";
759 int32_t result = *reinterpret_cast<const int32_t*>(rawData);
760 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
761 audioServerHpaeDumpPtr->OnDumpSinkInfoCb(dumpStr, result);
762 }
763
AudioServerHpaeDumpGetDeviceSourceInfoFuzzTest(const uint8_t * rawData,size_t size)764 void AudioServerHpaeDumpGetDeviceSourceInfoFuzzTest(const uint8_t *rawData, size_t size)
765 {
766 if (rawData == nullptr || size < LIMITSIZE) {
767 return;
768 }
769 std::string dumpString = "test_dumpString";
770 std::string deviceName = "test_deviceName";
771 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
772 audioServerHpaeDumpPtr->GetDeviceSourceInfo(dumpString, deviceName);
773 }
774
AudioServerHpaeDumpRecordSourceDumpFuzzTest(const uint8_t * rawData,size_t size)775 void AudioServerHpaeDumpRecordSourceDumpFuzzTest(const uint8_t *rawData, size_t size)
776 {
777 if (rawData == nullptr || size < LIMITSIZE) {
778 return;
779 }
780 std::string dumpString = "test_dumpString";
781 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
782 audioServerHpaeDumpPtr->RecordSourceDump(dumpString);
783 }
784
AudioServerHpaeDumpOnDumpSourceInfoCbFuzzTest(const uint8_t * rawData,size_t size)785 void AudioServerHpaeDumpOnDumpSourceInfoCbFuzzTest(const uint8_t *rawData, size_t size)
786 {
787 if (rawData == nullptr || size < LIMITSIZE) {
788 return;
789 }
790 std::string dumpStr = "test_dumpStr";
791 int32_t result = *reinterpret_cast<const int32_t*>(rawData);
792 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
793 audioServerHpaeDumpPtr->OnDumpSourceInfoCb(dumpStr, result);
794 }
795
AudioServerHpaeDumpHelpInfoDumpFuzzTest(const uint8_t * rawData,size_t size)796 void AudioServerHpaeDumpHelpInfoDumpFuzzTest(const uint8_t *rawData, size_t size)
797 {
798 if (rawData == nullptr || size < LIMITSIZE) {
799 return;
800 }
801 std::string dumpString = "test_dumpString";
802 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
803 audioServerHpaeDumpPtr->HelpInfoDump(dumpString);
804 }
805
AudioServerHpaeDumpHDFModulesDumpFuzzTest(const uint8_t * rawData,size_t size)806 void AudioServerHpaeDumpHDFModulesDumpFuzzTest(const uint8_t *rawData, size_t size)
807 {
808 if (rawData == nullptr || size < LIMITSIZE) {
809 return;
810 }
811 std::string dumpString = "test_dumpString";
812 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
813 audioServerHpaeDumpPtr->HDFModulesDump(dumpString);
814 }
815
AudioServerHpaeDumpOnDumpAllAvailableDeviceCbFuzzTest(const uint8_t * rawData,size_t size)816 void AudioServerHpaeDumpOnDumpAllAvailableDeviceCbFuzzTest(const uint8_t *rawData, size_t size)
817 {
818 if (rawData == nullptr || size < LIMITSIZE) {
819 return;
820 }
821 int32_t result = *reinterpret_cast<const int32_t*>(rawData);
822 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
823 audioServerHpaeDumpPtr->OnDumpAllAvailableDeviceCb(result);
824 }
825
AudioServerHpaeDumpPolicyHandlerDumpFuzzTest(const uint8_t * rawData,size_t size)826 void AudioServerHpaeDumpPolicyHandlerDumpFuzzTest(const uint8_t *rawData, size_t size)
827 {
828 if (rawData == nullptr || size < LIMITSIZE) {
829 return;
830 }
831 std::string dumpString = "test_dumpString";
832 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
833 audioServerHpaeDumpPtr->PolicyHandlerDump(dumpString);
834 }
835
AudioServerHpaeDumpAudioCacheMemoryDumpFuzzTest(const uint8_t * rawData,size_t size)836 void AudioServerHpaeDumpAudioCacheMemoryDumpFuzzTest(const uint8_t *rawData, size_t size)
837 {
838 if (rawData == nullptr || size < LIMITSIZE) {
839 return;
840 }
841 std::string dumpString = "test_dumpString";
842 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
843 audioServerHpaeDumpPtr->AudioCacheMemoryDump(dumpString);
844 }
845
AudioServerHpaeDumpAudioPerformMonitorDumpFuzzTest(const uint8_t * rawData,size_t size)846 void AudioServerHpaeDumpAudioPerformMonitorDumpFuzzTest(const uint8_t *rawData, size_t size)
847 {
848 if (rawData == nullptr || size < LIMITSIZE) {
849 return;
850 }
851 std::string dumpString = "test_dumpString";
852 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
853 audioServerHpaeDumpPtr->AudioPerformMonitorDump(dumpString);
854 }
855
AudioServerHpaeDumpHdiAdapterDumpFuzzTest(const uint8_t * rawData,size_t size)856 void AudioServerHpaeDumpHdiAdapterDumpFuzzTest(const uint8_t *rawData, size_t size)
857 {
858 if (rawData == nullptr || size < LIMITSIZE) {
859 return;
860 }
861 std::string dumpString = "test_dumpString";
862 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
863 audioServerHpaeDumpPtr->HdiAdapterDump(dumpString);
864 }
865
AudioServerHpaeDumpPlaybackSinkInputDumpFuzzTest(const uint8_t * rawData,size_t size)866 void AudioServerHpaeDumpPlaybackSinkInputDumpFuzzTest(const uint8_t *rawData, size_t size)
867 {
868 if (rawData == nullptr || size < LIMITSIZE) {
869 return;
870 }
871 std::string dumpString = "test_dumpString";
872 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
873 audioServerHpaeDumpPtr->PlaybackSinkInputDump(dumpString);
874 }
875
AudioServerHpaeDumpRecordSourceOutputDumpFuzzTest(const uint8_t * rawData,size_t size)876 void AudioServerHpaeDumpRecordSourceOutputDumpFuzzTest(const uint8_t *rawData, size_t size)
877 {
878 if (rawData == nullptr || size < LIMITSIZE) {
879 return;
880 }
881 std::string dumpString = "test_dumpString";
882 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
883 audioServerHpaeDumpPtr->RecordSourceOutputDump(dumpString);
884 }
885
AudioServerHpaeDumpOnDumpSinkInputsInfoCbFuzzTest(const uint8_t * rawData,size_t size)886 void AudioServerHpaeDumpOnDumpSinkInputsInfoCbFuzzTest(const uint8_t *rawData, size_t size)
887 {
888 if (rawData == nullptr || size < LIMITSIZE) {
889 return;
890 }
891 std::vector<HpaeInputOutputInfo> sinkInputs;
892 sinkInputs.push_back({0, "", 0, 0, 0, false, PRIVACY_TYPE_PUBLIC, "", HPAE::HPAE_SESSION_NEW, 0});
893 int32_t result = *reinterpret_cast<const int32_t*>(rawData);
894 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
895 audioServerHpaeDumpPtr->OnDumpSinkInputsInfoCb(sinkInputs, result);
896 }
897
AudioServerHpaeDumpSourceOutputsInfoCbFuzzTest(const uint8_t * rawData,size_t size)898 void AudioServerHpaeDumpSourceOutputsInfoCbFuzzTest(const uint8_t *rawData, size_t size)
899 {
900 if (rawData == nullptr || size < LIMITSIZE) {
901 return;
902 }
903 std::vector<HpaeInputOutputInfo> sourceOutputs;
904 sourceOutputs.push_back({0, "", 0, 0, 0, false, PRIVACY_TYPE_PUBLIC, "", HPAE::HPAE_SESSION_NEW, 0});
905 int32_t result = *reinterpret_cast<const int32_t*>(rawData);
906 std::shared_ptr<AudioServerHpaeDump> audioServerHpaeDumpPtr = std::make_shared<AudioServerHpaeDump>();
907 audioServerHpaeDumpPtr->OnDumpSourceOutputsInfoCb(sourceOutputs, result);
908 }
AudioServerRemoveThreadFromGroupFuzzTest(const uint8_t * rawData,size_t size)909 void AudioServerRemoveThreadFromGroupFuzzTest(const uint8_t *rawData, size_t size)
910 {
911 if (rawData == nullptr || size < LIMITSIZE) {
912 return;
913 }
914 int32_t pid = *reinterpret_cast<const int32_t*>(rawData);
915 int32_t workgroupId = *reinterpret_cast<const int32_t*>(rawData);
916 int32_t tokenId = *reinterpret_cast<const int32_t*>(rawData);
917 std::shared_ptr<AudioServer> audioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
918 audioServerPtr->RemoveThreadFromGroup(pid, workgroupId, tokenId);
919 }
920
921 } // namespace AudioStandard
922 } // namesapce OHOS
923
924 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)925 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
926 {
927 if (size < OHOS::AudioStandard::THRESHOLD) {
928 return 0;
929 }
930 OHOS::AudioStandard::FuzzTest(data, size);
931 OHOS::AudioStandard::AudioServerSetSpatializationSceneTypeTest(data, size);
932 OHOS::AudioStandard::AudioServerUpdateSpatialDeviceTypeTest(data, size);
933 OHOS::AudioStandard::AudioServerLoadConfigurationTest(data, size);
934 OHOS::AudioStandard::AudioServerGetExtarAudioParametersTest(data, size);
935 OHOS::AudioStandard::AudioServerSetExtraAudioParametersTest(data, size);
936 OHOS::AudioStandard::AudioServerUpdateRouteReqTest(data, size);
937 OHOS::AudioStandard::AudioServerUpdateActiveDevicesRouteTest(data, size);
938 OHOS::AudioStandard::AudioServerUpdateDualToneStateTest(data, size);
939 OHOS::AudioStandard::AudioServerGetTransactionIdTest(data, size);
940 OHOS::AudioStandard::AudioSetAudioParameterTest(data, size);
941 OHOS::AudioStandard::AudioGetAudioParameterTest(data, size);
942 OHOS::AudioStandard::AudioCreateAudioProcessTest(data, size);
943 OHOS::AudioStandard::AudioLoadAudioEffectLibrariesTest(data, size);
944 OHOS::AudioStandard::AudioServerSetAsrAecModeFuzzTest(data, size);
945 OHOS::AudioStandard::AudioServerGetAsrAecModeFuzzTest(data, size);
946 OHOS::AudioStandard::AudioServerGetAsrNoiseSuppressionModeFuzzTest(data, size);
947 OHOS::AudioStandard::AudioServerSetAsrWhisperDetectionModeFuzzTest(data, size);
948 OHOS::AudioStandard::AudioServerGetAsrWhisperDetectionModeFuzzTest(data, size);
949 OHOS::AudioStandard::AudioServerSetAsrVoiceSuppressionControlModeFuzzTest(data, size);
950 OHOS::AudioStandard::AudioServerSetAsrVoiceControlModeFuzzTest(data, size);
951 OHOS::AudioStandard::AudioServerSetAsrVoiceMuteModeFuzzTest(data, size);
952 OHOS::AudioStandard::AudioServerIsWhisperingFuzzTest(data, size);
953 OHOS::AudioStandard::AudioServerHpaeDumpServerDataDumpFuzzTest(data, size);
954 OHOS::AudioStandard::AudioServerHpaeDumpGetDeviceSinkInfoFuzzTest(data, size);
955 OHOS::AudioStandard::AudioServerHpaeDumpPlaybackSinkDumpFuzzTest(data, size);
956 OHOS::AudioStandard::AudioServerHpaeDumpOnDumpSinkInfoCbFuzzTest(data, size);
957 OHOS::AudioStandard::AudioServerHpaeDumpGetDeviceSourceInfoFuzzTest(data, size);
958 OHOS::AudioStandard::AudioServerHpaeDumpRecordSourceDumpFuzzTest(data, size);
959 OHOS::AudioStandard::AudioServerHpaeDumpOnDumpSourceInfoCbFuzzTest(data, size);
960 OHOS::AudioStandard::AudioServerHpaeDumpHelpInfoDumpFuzzTest(data, size);
961 OHOS::AudioStandard::AudioServerHpaeDumpHDFModulesDumpFuzzTest(data, size);
962 OHOS::AudioStandard::AudioServerHpaeDumpOnDumpAllAvailableDeviceCbFuzzTest(data, size);
963 OHOS::AudioStandard::AudioServerHpaeDumpPolicyHandlerDumpFuzzTest(data, size);
964 OHOS::AudioStandard::AudioServerHpaeDumpAudioCacheMemoryDumpFuzzTest(data, size);
965 OHOS::AudioStandard::AudioServerHpaeDumpAudioPerformMonitorDumpFuzzTest(data, size);
966 OHOS::AudioStandard::AudioServerHpaeDumpHdiAdapterDumpFuzzTest(data, size);
967 OHOS::AudioStandard::AudioServerHpaeDumpPlaybackSinkInputDumpFuzzTest(data, size);
968 OHOS::AudioStandard::AudioServerHpaeDumpRecordSourceOutputDumpFuzzTest(data, size);
969 OHOS::AudioStandard::AudioServerHpaeDumpOnDumpSinkInputsInfoCbFuzzTest(data, size);
970 OHOS::AudioStandard::AudioServerHpaeDumpSourceOutputsInfoCbFuzzTest(data, size);
971 OHOS::AudioStandard::AudioServerRemoveThreadFromGroupFuzzTest(data, size);
972 return 0;
973 }
974