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.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 using namespace std;
30
31 namespace OHOS {
32 namespace AudioStandard {
33 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IStandardAudioService";
34 const int32_t SYSTEM_ABILITY_ID = 3001;
35 const bool RUN_ON_CREATE = false;
36 const int32_t LIMITSIZE = 4;
37 const uint32_t COMMON_SIZE = 2;
38 const int32_t COMMON_INT = 2;
39 const std::u16string COMMONU16STRTEST = u"Test";
40 const uint32_t IOPERTAION_LENGTH = 13;
41 const uint32_t ENUM_LENGTH = 15;
42 const uint32_t ENUM_LENGTH_1 = 6;
43 const uint32_t ENUM_LENGTH_2 = 1;
44 const uint32_t APPID_LENGTH = 10;
45 const uint64_t COMMON_UINT64_NUM = 2;
46 const uint32_t RES_TYPE_AUDIO_RENDERER_STANDBY = 119;
47 static const uint8_t *RAW_DATA = nullptr;
48 static size_t g_dataSize = 0;
49 static size_t g_pos;
50 const size_t THRESHOLD = 10;
51
52 /*
53 * describe: get data from outside untrusted data(RAW_DATA) which size is according to sizeof(T)
54 * tips: only support basic type
55 */
56 template<class T>
GetData()57 T GetData()
58 {
59 T object {};
60 size_t objectSize = sizeof(object);
61 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
62 return object;
63 }
64 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
65 if (ret != EOK) {
66 return {};
67 }
68 g_pos += objectSize;
69 return object;
70 }
71
72 template<class T>
GetArrLength(T & arr)73 uint32_t GetArrLength(T& arr)
74 {
75 if (arr == nullptr) {
76 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
77 return 0;
78 }
79 return sizeof(arr) / sizeof(arr[0]);
80 }
81
AudioServerSetSpatializationSceneTypeTest(const uint8_t * rawData,size_t size)82 void AudioServerSetSpatializationSceneTypeTest(const uint8_t *rawData, size_t size)
83 {
84 if (rawData == nullptr || size < LIMITSIZE) {
85 return;
86 }
87 MessageParcel reply;
88 MessageOption option;
89 MessageParcel data;
90 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
91 uint32_t sizeMs = *reinterpret_cast<const uint32_t*>(rawData);
92 data.WriteUint32(sizeMs);
93 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
94
95 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_SPATIALIZATION_SCENE_TYPE),
96 data, reply, option);
97 }
98
AudioServerUpdateSpatialDeviceTypeTest(const uint8_t * rawData,size_t size)99 void AudioServerUpdateSpatialDeviceTypeTest(const uint8_t *rawData, size_t size)
100 {
101 if (rawData == nullptr || size < LIMITSIZE) {
102 return;
103 }
104 MessageParcel reply;
105 MessageOption option;
106 MessageParcel data;
107 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
108 uint32_t sizeMs = *reinterpret_cast<const uint32_t*>(rawData);
109 data.WriteUint32(sizeMs);
110 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
111
112 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_SPATIAL_DEVICE_TYPE),
113 data, reply, option);
114 }
115
AudioServerLoadConfigurationTest(const uint8_t * rawData,size_t size)116 void AudioServerLoadConfigurationTest(const uint8_t *rawData, size_t size)
117 {
118 if (rawData == nullptr || size < LIMITSIZE) {
119 return;
120 }
121 std::unordered_map<std::string, std::unordered_map<std::string, std::set<std::string>>> audioParameterKeys = {};
122 std::unordered_map<std::string, std::set<std::string>> audioParameterKey = {};
123 std::set<std::string> audioParameterValue = {};
124 std::string audioParameterKeyStr1 = "key1";
125 std::string audioParameterKeyStr2 = "key2";
126 std::string audioParameterKeyValueStr1 = "value1";
127 std::string audioParameterKeyValueStr2 = "value2";
128 audioParameterValue.insert(audioParameterKeyValueStr1);
129 audioParameterValue.insert(audioParameterKeyValueStr2);
130 audioParameterKey.insert(std::make_pair(audioParameterKeyStr1, audioParameterValue));
131 audioParameterKey.insert(std::make_pair(audioParameterKeyStr2, audioParameterValue));
132 audioParameterKeys.insert(std::make_pair(audioParameterKeyStr1, audioParameterKey));
133 audioParameterKeys.insert(std::make_pair(audioParameterKeyStr2, audioParameterKey));
134
135 std::shared_ptr<AudioParamParser> audioParamParser = std::make_shared<AudioParamParser>();
136 audioParamParser->LoadConfiguration(audioParameterKeys);
137 }
138
AudioServerGetExtarAudioParametersTest(const uint8_t * rawData,size_t size)139 void AudioServerGetExtarAudioParametersTest(const uint8_t* rawData, size_t size)
140 {
141 if (rawData == nullptr || size < LIMITSIZE) {
142 return;
143 }
144
145 MessageParcel data;
146 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
147 std::string mainKey = "mainKey";
148 std::string value1 = "value1";
149 std::string value2 = "value2";
150 std::vector<std::string> subkeys = {};
151 subkeys.push_back(value1);
152 subkeys.push_back(value2);
153
154 data.WriteString(static_cast<std::string>(mainKey));
155 data.WriteInt32(subkeys.size());
156 for (std::string subKey : subkeys) {
157 data.WriteString(static_cast<std::string>(subKey));
158 }
159
160 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
161 MessageParcel reply;
162 MessageOption option;
163 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_EXTRA_AUDIO_PARAMETERS),
164 data, reply, option);
165 }
166
AudioServerSetExtraAudioParametersTest(const uint8_t * rawData,size_t size)167 void AudioServerSetExtraAudioParametersTest(const uint8_t* rawData, size_t size)
168 {
169 if (rawData == nullptr || size < LIMITSIZE) {
170 return;
171 }
172
173 MessageParcel data;
174 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
175 std::string mainKey = "mainKey";
176 std::vector<std::pair<std::string, std::string>> kvpairs;
177 for (uint32_t i = 0; i < COMMON_SIZE; i++) {
178 std::string subKey = "subKey" + std::to_string(i);
179 std::string subValue = "subValue" + std::to_string(i);
180 kvpairs.push_back(std::make_pair(subKey, subValue));
181 }
182
183 data.WriteString(mainKey);
184 data.WriteInt32(static_cast<int32_t>(kvpairs.size()));
185 for (auto it = kvpairs.begin(); it != kvpairs.end(); it++) {
186 data.WriteString(static_cast<std::string>(it->first));
187 data.WriteString(static_cast<std::string>(it->second));
188 }
189
190 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
191 MessageParcel reply;
192 MessageOption option;
193 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_EXTRA_AUDIO_PARAMETERS),
194 data, reply, option);
195 }
196
AudioServerUpdateRouteReqTest(const uint8_t * rawData,size_t size)197 void AudioServerUpdateRouteReqTest(const uint8_t* rawData, size_t size)
198 {
199 if (rawData == nullptr || size < LIMITSIZE) {
200 return;
201 }
202
203 MessageParcel data;
204 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
205
206 DeviceType type = *reinterpret_cast<const DeviceType*>(rawData);
207 DeviceFlag flag = *reinterpret_cast<const DeviceFlag*>(rawData);
208 BluetoothOffloadState a2dpOffloadFlag = *reinterpret_cast<const BluetoothOffloadState*>(rawData);
209 data.WriteInt32(type);
210 data.WriteInt32(flag);
211 data.WriteInt32(static_cast<int32_t>(a2dpOffloadFlag));
212
213 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
214 MessageParcel reply;
215 MessageOption option;
216 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_ROUTE_REQ),
217 data, reply, option);
218 }
219
AudioServerUpdateActiveDevicesRouteTest(const uint8_t * rawData,size_t size)220 void AudioServerUpdateActiveDevicesRouteTest(const uint8_t* rawData, size_t size)
221 {
222 if (rawData == nullptr || size < LIMITSIZE) {
223 return;
224 }
225
226 MessageParcel data;
227 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
228 std::vector<std::pair<DeviceType, DeviceFlag>> activeDevices;
229 for (uint32_t i = 0; i < COMMON_SIZE; i++) {
230 DeviceType deviceType = *reinterpret_cast<const DeviceType*>(rawData);
231 DeviceFlag deviceFlag = *reinterpret_cast<const DeviceFlag*>(rawData);
232 activeDevices.push_back(std::make_pair(deviceType, deviceFlag));
233 }
234 data.WriteInt32(static_cast<int32_t>(activeDevices.size()));
235 for (auto it = activeDevices.begin(); it != activeDevices.end(); it++) {
236 data.WriteInt32(static_cast<int32_t>(it->first));
237 data.WriteInt32(static_cast<int32_t>(it->second));
238 }
239
240 BluetoothOffloadState a2dpOffloadFlag = *reinterpret_cast<const BluetoothOffloadState*>(rawData);
241 data.WriteInt32(static_cast<int32_t>(a2dpOffloadFlag));
242
243 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
244 MessageParcel reply;
245 MessageOption option;
246 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_ROUTES_REQ),
247 data, reply, option);
248 }
249
AudioServerUpdateDualToneStateTest(const uint8_t * rawData,size_t size)250 void AudioServerUpdateDualToneStateTest(const uint8_t* rawData, size_t size)
251 {
252 if (rawData == nullptr || size < LIMITSIZE) {
253 return;
254 }
255
256 MessageParcel data;
257 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
258 bool enable = *reinterpret_cast<const bool*>(rawData);
259 int32_t sessionId = *reinterpret_cast<const int32_t*>(rawData);
260
261 data.WriteBool(enable);
262 data.WriteInt32(sessionId);
263
264 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
265 MessageParcel reply;
266 MessageOption option;
267 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_DUAL_TONE_REQ),
268 data, reply, option);
269 }
270
AudioServerGetTransactionIdTest(const uint8_t * rawData,size_t size)271 void AudioServerGetTransactionIdTest(const uint8_t* rawData, size_t size)
272 {
273 if (rawData == nullptr || size < LIMITSIZE) {
274 return;
275 }
276
277 MessageParcel data;
278 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
279 DeviceType deviceType = *reinterpret_cast<const DeviceType*>(rawData);
280 DeviceRole deviceRole = *reinterpret_cast<const DeviceRole*>(rawData);
281 data.WriteInt32(deviceType);
282 data.WriteInt32(deviceRole);
283 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
284 MessageParcel reply;
285 MessageOption option;
286 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_TRANSACTION_ID),
287 data, reply, option);
288 }
289
AudioGetAudioParameterTest(const uint8_t * rawData,size_t size)290 void AudioGetAudioParameterTest(const uint8_t* rawData, size_t size)
291 {
292 if (rawData == nullptr || size < LIMITSIZE || size < sizeof(AudioParamKey)) {
293 return;
294 }
295
296 MessageParcel data;
297 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
298
299 std::string networkId(reinterpret_cast<const char*>(rawData), size);
300 std::string condition(reinterpret_cast<const char*>(rawData), size);
301 AudioParamKey key = *reinterpret_cast<const AudioParamKey*>(rawData);
302 data.WriteString(networkId);
303 data.WriteInt32(static_cast<int32_t>(key));
304 data.WriteString(condition);
305
306 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
307 MessageParcel reply;
308 MessageOption option;
309 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_REMOTE_AUDIO_PARAMETER),
310 data, reply, option);
311 }
312
AudioSetAudioParameterTest(const uint8_t * rawData,size_t size)313 void AudioSetAudioParameterTest(const uint8_t* rawData, size_t size)
314 {
315 if (rawData == nullptr || size < LIMITSIZE || size < sizeof(AudioParamKey)) {
316 return;
317 }
318
319 MessageParcel data;
320 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
321
322 std::string networkId = "123";
323 std::string condition = "123456";
324 std::string value = "123456";
325 AudioParamKey key = *reinterpret_cast<const AudioParamKey*>(rawData);
326 data.WriteString(networkId);
327 data.WriteInt32(static_cast<uint32_t>(key));
328 data.WriteString(condition);
329 data.WriteString(value);
330
331 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
332 MessageParcel reply;
333 MessageOption option;
334 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_REMOTE_AUDIO_PARAMETER),
335 data, reply, option);
336 }
337
AudioCreateAudioProcessTest(const uint8_t * rawData,size_t size)338 void AudioCreateAudioProcessTest(const uint8_t* rawData, size_t size)
339 {
340 if (rawData == nullptr || size < LIMITSIZE) {
341 return;
342 }
343
344 MessageParcel data;
345 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
346 AudioProcessConfig config;
347 config.appInfo.appUid = APPID_LENGTH;
348 config.appInfo.appPid = APPID_LENGTH;
349 config.streamInfo.format = SAMPLE_S32LE;
350 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
351 config.streamInfo.channels = STEREO;
352 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
353 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
354 config.streamType = AudioStreamType::STREAM_MUSIC;
355 config.deviceType = DEVICE_TYPE_USB_HEADSET;
356
357 ProcessConfig::WriteConfigToParcel(config, data);
358
359 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
360 MessageParcel reply;
361 MessageOption option;
362 audioServer->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CREATE_AUDIOPROCESS),
363 data, reply, option);
364 }
365
AudioLoadAudioEffectLibrariesTest(const uint8_t * rawData,size_t size)366 void AudioLoadAudioEffectLibrariesTest(const uint8_t* rawData, size_t size)
367 {
368 if (rawData == nullptr || size < LIMITSIZE) {
369 return;
370 }
371
372 MessageParcel data;
373 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
374 data.WriteInt32(COMMON_INT);
375 data.WriteInt32(COMMON_INT);
376 for (int32_t i = 0; i < COMMON_INT; i++) {
377 std::string libName(reinterpret_cast<const char*>(rawData), size - 1);
378 std::string libPath(reinterpret_cast<const char*>(rawData), size - 1);
379 data.WriteString(libName);
380 data.WriteString(libPath);
381 }
382
383 for (int32_t i = 0; i < COMMON_INT; i++) {
384 std::string effectName = "effectName" + std::to_string(i);
385 std::string libName = "libName" + std::to_string(i);
386 data.WriteString(effectName);
387 data.WriteString(libName);
388 }
389
390 std::shared_ptr<AudioServer> audioServer = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
391 MessageParcel reply;
392 MessageOption option;
393 audioServer->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::LOAD_AUDIO_EFFECT_LIBRARIES),
394 data, reply, option);
395 }
396
AudioCapturerInServerFuzzTest()397 void AudioCapturerInServerFuzzTest()
398 {
399 std::shared_ptr<CapturerInServer> capturerInServer = nullptr;
400 AudioProcessConfig config;
401 config.appInfo.appUid = APPID_LENGTH;
402 config.appInfo.appPid = APPID_LENGTH;
403 config.streamInfo.format = SAMPLE_S32LE;
404 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
405 config.streamInfo.channels = STEREO;
406 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
407 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
408 config.streamType = AudioStreamType::STREAM_MUSIC;
409 config.deviceType = DEVICE_TYPE_USB_HEADSET;
410 std::weak_ptr<IStreamListener> innerListener;
411 capturerInServer = std::make_shared<CapturerInServer>(config, innerListener);
412 if (capturerInServer == nullptr) {
413 return;
414 }
415 uint32_t operationCode = GetData<uint32_t>();
416 operationCode = (operationCode % IOPERTAION_LENGTH) - 1;
417 IOperation operation = static_cast<IOperation>(operationCode);
418 capturerInServer->OnStatusUpdate(operation);
419 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
420 capturerInServer->ResolveBuffer(buffer);
421 uint32_t sessionId = GetData<uint32_t>();
422 capturerInServer->GetSessionId(sessionId);
423 }
424
AudioRendererInServerTestFirst(std::shared_ptr<RendererInServer> renderer)425 void AudioRendererInServerTestFirst(std::shared_ptr<RendererInServer> renderer)
426 {
427 uint32_t operationCode = GetData<uint32_t>();
428 operationCode = (operationCode % IOPERTAION_LENGTH) - 1;
429 IOperation operation = static_cast<IOperation>(operationCode);
430 renderer->OnStatusUpdate(operation);
431 renderer->HandleOperationFlushed();
432 std::shared_ptr<OHAudioBuffer> buffer = nullptr;
433 renderer->ResolveBuffer(buffer);
434 uint32_t sessionId = GetData<uint32_t>();
435 renderer->GetSessionId(sessionId);
436 uint64_t framePos = COMMON_UINT64_NUM;
437 uint64_t timeStamp = COMMON_UINT64_NUM;
438 uint64_t latency = COMMON_UINT64_NUM;
439 renderer->GetAudioTime(framePos, timeStamp);
440 renderer->GetAudioPosition(framePos, timeStamp, latency);
441 renderer->GetLatency(latency);
442 int32_t rate = GetData<int32_t>();
443 renderer->SetRate(rate);
444 float volume = GetData<float>();
445 renderer->SetLowPowerVolume(volume);
446 renderer->GetLowPowerVolume(volume);
447 int32_t effectMode = GetData<int32_t>();
448 renderer->SetAudioEffectMode(effectMode);
449 renderer->GetAudioEffectMode(effectMode);
450 int32_t privacyType = GetData<int32_t>();
451 renderer->SetPrivacyType(privacyType);
452 renderer->GetPrivacyType(privacyType);
453 int32_t state = GetData<int32_t>();
454 bool isAppBack = GetData<bool>();
455 renderer->SetOffloadMode(state, isAppBack);
456 renderer->UnsetOffloadMode();
457 }
458
AudioRendererInServerTestSecond(std::shared_ptr<RendererInServer> renderer)459 void AudioRendererInServerTestSecond(std::shared_ptr<RendererInServer> renderer)
460 {
461 bool isAppBack = GetData<bool>();
462 bool headTrackingEnabled = GetData<bool>();
463 RestoreInfo restoreInfo;
464 restoreInfo.restoreReason = static_cast<RestoreReason>(GetData<int32_t>());
465 restoreInfo.targetStreamFlag = GetData<int32_t>();
466 renderer->UpdateSpatializationState(isAppBack, headTrackingEnabled);
467 renderer->CheckAndWriterRenderStreamStandbySysEvent(GetData<bool>());
468 uint64_t timeStamp = COMMON_UINT64_NUM;
469 renderer->GetOffloadApproximatelyCacheTime(timeStamp, timeStamp, timeStamp, timeStamp);
470 BufferDesc desc;
471 desc.buffer = nullptr;
472 desc.bufLength = 0;
473 desc.dataLength =0;
474 renderer->VolumeHandle(desc);
475 renderer->WriteData();
476 renderer->WriteEmptyData();
477 renderer->DrainAudioBuffer();
478 renderer->EnableInnerCap(1);
479 renderer->DisableInnerCap(1);
480 renderer->InitDupStream(1);
481 renderer->EnableDualTone();
482 renderer->DisableDualTone();
483 renderer->InitDualToneStream();
484 renderer->GetStreamManagerType();
485 renderer->SetSilentModeAndMixWithOthers(isAppBack);
486 renderer->SetClientVolume();
487 uint32_t operationCode = GetData<uint32_t>();
488 operationCode = (operationCode % IOPERTAION_LENGTH) - 1;
489 IOperation operation = static_cast<IOperation>(operationCode);
490 renderer->OnDataLinkConnectionUpdate(operation);
491 std::string dumpString = "";
492 renderer->managerType_ = DIRECT_PLAYBACK;
493 renderer->Dump(dumpString);
494 bool muteFlag = false;
495 renderer->SetNonInterruptMute(muteFlag);
496 renderer->RestoreSession(restoreInfo);
497 renderer->Pause();
498 renderer->Flush();
499 renderer->Drain(headTrackingEnabled);
500 renderer->Stop();
501 renderer->Release();
502 }
503
AudioRendererInServerTest()504 void AudioRendererInServerTest()
505 {
506 AudioProcessConfig config;
507 config.appInfo.appUid = APPID_LENGTH;
508 config.appInfo.appPid = APPID_LENGTH;
509 config.streamInfo.format = SAMPLE_S32LE;
510 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
511 config.streamInfo.channels = STEREO;
512 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
513 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
514 config.streamType = AudioStreamType::STREAM_MUSIC;
515 config.deviceType = DEVICE_TYPE_USB_HEADSET;
516 int32_t ret = 0;
517 sptr<IpcStreamInServer> ipcStreamInServer = IpcStreamInServer::Create(config, ret);
518 if (ipcStreamInServer == nullptr) {
519 return;
520 }
521 std::shared_ptr<RendererInServer> renderer = ipcStreamInServer->GetRenderer();
522 renderer->Init();
523 renderer->Start();
524 renderer->ConfigServerBuffer();
525 renderer->InitBufferStatus();
526 renderer->UpdateWriteIndex();
527 uint32_t statusInt = GetData<uint32_t>();
528 statusInt = (statusInt % ENUM_LENGTH) -ENUM_LENGTH_2;
529 IStatus status = static_cast<IStatus>(statusInt);
530 uint32_t typeInt = GetData<uint32_t>();
531 typeInt = typeInt % ENUM_LENGTH_1;
532 ManagerType type = static_cast<ManagerType>(typeInt);
533 renderer->managerType_ = type;
534 renderer->status_ = status;
535 std::string dumpString = "";
536 renderer->Dump(dumpString);
537 renderer->SetStreamVolumeInfoForEnhanceChain();
538 std::unordered_map<std::string, std::string> payload;
539 renderer->ReportDataToResSched(payload, RES_TYPE_AUDIO_RENDERER_STANDBY);
540 AudioRendererInServerTestFirst(renderer);
541 AudioRendererInServerTestSecond(renderer);
542 }
543
AudioMicroPhoneFuzzTest()544 void AudioMicroPhoneFuzzTest()
545 {
546 sptr<MicrophoneDescriptor> micDesc = new (std::nothrow) MicrophoneDescriptor();
547 MicrophoneDescriptor micDescs;
548 Vector3D vector3d;
549 vector3d.x = 0.0f;
550 vector3d.y = 0.0f;
551 vector3d.z = 0.0f;
552 micDesc->SetMicPositionInfo(vector3d);
553 micDesc->SetMicOrientationInfo(vector3d);
554 }
555
556 typedef void (*TestFuncs[3])();
557
558 TestFuncs g_testFuncs = {
559 AudioCapturerInServerFuzzTest,
560 AudioRendererInServerTest,
561 AudioMicroPhoneFuzzTest,
562 };
563
FuzzTest(const uint8_t * rawData,size_t size)564 bool FuzzTest(const uint8_t* rawData, size_t size)
565 {
566 if (rawData == nullptr) {
567 return false;
568 }
569
570 // initialize data
571 RAW_DATA = rawData;
572 g_dataSize = size;
573 g_pos = 0;
574
575 uint32_t code = GetData<uint32_t>();
576 uint32_t len = GetArrLength(g_testFuncs);
577 if (len > 0) {
578 g_testFuncs[code % len]();
579 } else {
580 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
581 }
582
583 return true;
584 }
585 } // namespace AudioStandard
586 } // namesapce OHOS
587
588 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)589 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
590 {
591 if (size < OHOS::AudioStandard::THRESHOLD) {
592 return 0;
593 }
594
595 OHOS::AudioStandard::FuzzTest(data, size);
596 OHOS::AudioStandard::AudioServerSetSpatializationSceneTypeTest(data, size);
597 OHOS::AudioStandard::AudioServerUpdateSpatialDeviceTypeTest(data, size);
598 OHOS::AudioStandard::AudioServerLoadConfigurationTest(data, size);
599 OHOS::AudioStandard::AudioServerGetExtarAudioParametersTest(data, size);
600 OHOS::AudioStandard::AudioServerSetExtraAudioParametersTest(data, size);
601 OHOS::AudioStandard::AudioServerUpdateRouteReqTest(data, size);
602 OHOS::AudioStandard::AudioServerUpdateActiveDevicesRouteTest(data, size);
603 OHOS::AudioStandard::AudioServerUpdateDualToneStateTest(data, size);
604 OHOS::AudioStandard::AudioServerGetTransactionIdTest(data, size);
605 OHOS::AudioStandard::AudioSetAudioParameterTest(data, size);
606 OHOS::AudioStandard::AudioGetAudioParameterTest(data, size);
607 OHOS::AudioStandard::AudioCreateAudioProcessTest(data, size);
608 OHOS::AudioStandard::AudioLoadAudioEffectLibrariesTest(data, size);
609 return 0;
610 }
611