1 /*
2 * Copyright (c) 2022 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
20 #include "audio_manager_base.h"
21 #include "audio_policy_manager_listener_stub.h"
22 #include "audio_server.h"
23 #include "message_parcel.h"
24 using namespace std;
25
26 namespace OHOS {
27 namespace AudioStandard {
28 constexpr int32_t OFFSET = 4;
29 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IStandardAudioService";
30 const int32_t SYSTEM_ABILITY_ID = 3001;
31 const bool RUN_ON_CREATE = false;
32 const int32_t LIMITSIZE = 4;
33 const int32_t SHIFT_LEFT_8 = 8;
34 const int32_t SHIFT_LEFT_16 = 16;
35 const int32_t SHIFT_LEFT_24 = 24;
36 const uint32_t LIMIT_MIN = 0;
37 const uint32_t LIMIT_MAX = static_cast<uint32_t>(AudioServerInterfaceCode::AUDIO_SERVER_CODE_MAX);
38 typedef void (*TestPtr)(const uint8_t *, size_t);
39
40 template<class T>
GetArrLength(T & arr)41 uint32_t GetArrLength(T& arr)
42 {
43 if (arr == nullptr) {
44 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
45 return 0;
46 }
47 return sizeof(arr) / sizeof(arr[0]);
48 }
49
Convert2Uint32(const uint8_t * ptr)50 uint32_t Convert2Uint32(const uint8_t *ptr)
51 {
52 if (ptr == nullptr) {
53 return 0;
54 }
55 /* Move the 0th digit to the left by 24 bits, the 1st digit to the left by 16 bits,
56 the 2nd digit to the left by 8 bits, and the 3rd digit not to the left */
57 return (ptr[0] << SHIFT_LEFT_24) | (ptr[1] << SHIFT_LEFT_16) | (ptr[2] << SHIFT_LEFT_8) | (ptr[3]);
58 }
59
AudioServerFuzzTest(const uint8_t * rawData,size_t size)60 void AudioServerFuzzTest(const uint8_t *rawData, size_t size)
61 {
62 if (rawData == nullptr || size < LIMITSIZE) {
63 return;
64 }
65 uint32_t code = Convert2Uint32(rawData) % (LIMIT_MAX - LIMIT_MIN + 1) + LIMIT_MIN;
66 rawData = rawData + OFFSET;
67 size = size - OFFSET;
68
69 MessageParcel data;
70 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
71 data.WriteBuffer(rawData, size);
72 data.RewindRead(0);
73 MessageParcel reply;
74 MessageOption option;
75
76 std::shared_ptr<AudioServer> AudioServerPtr =
77 std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
78
79 if (code == static_cast<uint32_t>(AudioServerInterfaceCode::SET_PARAMETER_CALLBACK)) {
80 sptr<AudioPolicyManagerListenerStub> focusListenerStub = new(std::nothrow) AudioPolicyManagerListenerStub();
81 sptr<IRemoteObject> object = focusListenerStub->AsObject();
82 AudioServerPtr->SetParameterCallback(object);
83 return;
84 }
85 AudioServerPtr->OnRemoteRequest(code, data, reply, option);
86
87 if (size < LIMITSIZE) {
88 return;
89 }
90 std::string netWorkId(reinterpret_cast<const char*>(rawData), size - 1);
91 AudioParamKey key = *reinterpret_cast<const AudioParamKey *>(rawData);
92 std::string condition(reinterpret_cast<const char*>(rawData), size - 1);
93 std::string value(reinterpret_cast<const char*>(rawData), size - 1);
94 AudioServerPtr->OnRenderSinkParamChange(netWorkId, key, condition, value);
95 }
96
AudioServerCaptureSilentlyFuzzTest(const uint8_t * rawData,size_t size)97 void AudioServerCaptureSilentlyFuzzTest(const uint8_t *rawData, size_t size)
98 {
99 if (rawData == nullptr || size < LIMITSIZE) {
100 return;
101 }
102
103 MessageParcel data;
104 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
105 data.WriteBuffer(rawData, size);
106 data.RewindRead(0);
107 MessageParcel reply;
108 MessageOption option;
109
110 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
111 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_CAPTURE_SILENT_STATE),
112 data, reply, option);
113 }
114
Convert2Float(const uint8_t * ptr)115 float Convert2Float(const uint8_t *ptr)
116 {
117 float floatValue = static_cast<float>(*ptr);
118 return floatValue / 128.0f - 1.0f;
119 }
120
AudioServerOffloadSetVolumeFuzzTest(const uint8_t * rawData,size_t size)121 void AudioServerOffloadSetVolumeFuzzTest(const uint8_t *rawData, size_t size)
122 {
123 if (rawData == nullptr || size < LIMITSIZE) {
124 return;
125 }
126
127 MessageParcel data;
128 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
129 float volume = Convert2Float(rawData);
130 data.WriteFloat(volume);
131 MessageParcel reply;
132 MessageOption option;
133
134 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
135 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::OFFLOAD_SET_VOLUME),
136 data, reply, option);
137 }
138
AudioServerNotifyStreamVolumeChangedFuzzTest(const uint8_t * rawData,size_t size)139 void AudioServerNotifyStreamVolumeChangedFuzzTest(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 uint32_t sizeMs = *reinterpret_cast<const uint32_t*>(rawData);
148 data.WriteUint32(sizeMs);
149 MessageParcel reply;
150 MessageOption option;
151
152 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
153 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_STREAM_VOLUME_CHANGED),
154 data, reply, option);
155 }
156
AudioServerResetRouteForDisconnectFuzzTest(const uint8_t * rawData,size_t size)157 void AudioServerResetRouteForDisconnectFuzzTest(const uint8_t *rawData, size_t size)
158 {
159 if (rawData == nullptr || size < LIMITSIZE) {
160 return;
161 }
162
163 MessageParcel data;
164 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
165 int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
166 data.WriteInt32(deviceType);
167 MessageParcel reply;
168 MessageOption option;
169
170 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
171 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::RESET_ROUTE_FOR_DISCONNECT),
172 data, reply, option);
173 }
174
AudioServerGetEffectLatencyTest(const uint8_t * rawData,size_t size)175 void AudioServerGetEffectLatencyTest(const uint8_t *rawData, size_t size)
176 {
177 if (rawData == nullptr || size < LIMITSIZE) {
178 return;
179 }
180
181 MessageParcel data;
182 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
183 std::string sessionId(reinterpret_cast<const char*>(rawData), size);
184 data.WriteString(sessionId);
185
186 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
187 MessageParcel reply;
188 MessageOption option;
189 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_EFFECT_LATENCY),
190 data, reply, option);
191 }
192
AudioServerUpdateLatencyTimestampTest(const uint8_t * rawData,size_t size)193 void AudioServerUpdateLatencyTimestampTest(const uint8_t *rawData, size_t size)
194 {
195 if (rawData == nullptr || size < LIMITSIZE) {
196 return;
197 }
198
199 MessageParcel data;
200 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
201 std::string timestamp(reinterpret_cast<const char*>(rawData), size - 1);
202 bool isRenderer = *reinterpret_cast<const bool*>(rawData);
203 data.WriteString(timestamp);
204 data.WriteBool(isRenderer);
205
206 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
207 MessageParcel reply;
208 MessageOption option;
209 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UPDATE_LATENCY_TIMESTAMP),
210 data, reply, option);
211 }
212
AudioServerGetMaxAmplitudeTest(const uint8_t * rawData,size_t size)213 void AudioServerGetMaxAmplitudeTest(const uint8_t *rawData, size_t size)
214 {
215 if (rawData == nullptr || size < LIMITSIZE) {
216 return;
217 }
218
219 MessageParcel data;
220 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
221 bool isOutputDevice = *reinterpret_cast<const bool*>(rawData);
222 int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
223 data.WriteBool(isOutputDevice);
224 data.WriteInt32(deviceType);
225
226 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
227 MessageParcel reply;
228 MessageOption option;
229 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_MAX_AMPLITUDE),
230 data, reply, option);
231 }
232
AudioServerResetAudioEndpointTest(const uint8_t * rawData,size_t size)233 void AudioServerResetAudioEndpointTest(const uint8_t *rawData, size_t size)
234 {
235 if (rawData == nullptr || size < LIMITSIZE) {
236 return;
237 }
238
239 MessageParcel data;
240 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
241
242 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
243 MessageParcel reply;
244 MessageOption option;
245 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::RESET_AUDIO_ENDPOINT),
246 data, reply, option);
247 }
248
AudioServerCreatePlaybackCapturerManagerTest(const uint8_t * rawData,size_t size)249 void AudioServerCreatePlaybackCapturerManagerTest(const uint8_t *rawData, size_t size)
250 {
251 if (rawData == nullptr || size < LIMITSIZE) {
252 return;
253 }
254
255 MessageParcel data;
256 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
257
258 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
259 MessageParcel reply;
260 MessageOption option;
261 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CREATE_PLAYBACK_CAPTURER_MANAGER),
262 data, reply, option);
263 }
264
AudioServerSetOutputDeviceSinkTest(const uint8_t * rawData,size_t size)265 void AudioServerSetOutputDeviceSinkTest(const uint8_t *rawData, size_t size)
266 {
267 if (rawData == nullptr || size < LIMITSIZE) {
268 return;
269 }
270
271 MessageParcel data;
272 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
273 int32_t deviceType = *reinterpret_cast<const int32_t*>(rawData);
274 std::string sinkName(reinterpret_cast<const char*>(rawData), size - 1);
275 data.WriteInt32(deviceType);
276 data.WriteString(sinkName);
277
278 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
279 MessageParcel reply;
280 MessageOption option;
281 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_OUTPUT_DEVICE_SINK),
282 data, reply, option);
283 }
284
AudioServerSetAudioMonoStateTest(const uint8_t * rawData,size_t size)285 void AudioServerSetAudioMonoStateTest(const uint8_t *rawData, size_t size)
286 {
287 if (rawData == nullptr || size < LIMITSIZE) {
288 return;
289 }
290
291 MessageParcel data;
292 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
293 bool audioMono = *reinterpret_cast<const bool*>(rawData);
294 data.WriteBool(audioMono);
295
296 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
297 MessageParcel reply;
298 MessageOption option;
299 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_MONO_STATE),
300 data, reply, option);
301 }
302
AudioServerSetVoiceVolumeTest(const uint8_t * rawData,size_t size)303 void AudioServerSetVoiceVolumeTest(const uint8_t *rawData, size_t size)
304 {
305 if (rawData == nullptr || size < LIMITSIZE) {
306 return;
307 }
308
309 MessageParcel data;
310 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
311 float volume = *reinterpret_cast<const float*>(rawData);
312 data.WriteFloat(volume);
313
314 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
315 MessageParcel reply;
316 MessageOption option;
317 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_VOICE_VOLUME),
318 data, reply, option);
319 }
320
AudioServerCheckRemoteDeviceStateTest(const uint8_t * rawData,size_t size)321 void AudioServerCheckRemoteDeviceStateTest(const uint8_t *rawData, size_t size)
322 {
323 if (rawData == nullptr || size < LIMITSIZE) {
324 return;
325 }
326
327 MessageParcel data;
328 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
329 std::string networkId(reinterpret_cast<const char*>(rawData), size - 1);
330 DeviceRole deviceRole = *reinterpret_cast<const DeviceRole*>(rawData);
331 bool isStartDevice = *reinterpret_cast<const bool*>(rawData);
332 data.WriteString(networkId);
333 data.WriteInt32(static_cast<int32_t>(deviceRole));
334 data.WriteBool(isStartDevice);
335
336 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
337 MessageParcel reply;
338 MessageOption option;
339 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CHECK_REMOTE_DEVICE_STATE),
340 data, reply, option);
341 }
342
AudioServerNotifyDeviceInfoTest(const uint8_t * rawData,size_t size)343 void AudioServerNotifyDeviceInfoTest(const uint8_t *rawData, size_t size)
344 {
345 if (rawData == nullptr || size < LIMITSIZE) {
346 return;
347 }
348
349 MessageParcel data;
350 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
351 std::string networkId(reinterpret_cast<const char*>(rawData), size - 1);
352 bool connected = *reinterpret_cast<const bool*>(rawData);
353 data.WriteString(networkId);
354 data.WriteBool(connected);
355
356 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
357 MessageParcel reply;
358 MessageOption option;
359 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::NOTIFY_DEVICE_INFO),
360 data, reply, option);
361 }
362
AudioServerGetAudioParameterTest(const uint8_t * rawData,size_t size)363 void AudioServerGetAudioParameterTest(const uint8_t *rawData, size_t size)
364 {
365 if (rawData == nullptr || size < LIMITSIZE) {
366 return;
367 }
368
369 MessageParcel data;
370 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
371 std::string key(reinterpret_cast<const char*>(rawData), size - 1);
372 data.WriteString(key);
373
374 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
375 MessageParcel reply;
376 MessageOption option;
377 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::GET_AUDIO_PARAMETER),
378 data, reply, option);
379 }
380
AudioServerSetAudioParameterTest(const uint8_t * rawData,size_t size)381 void AudioServerSetAudioParameterTest(const uint8_t *rawData, size_t size)
382 {
383 if (rawData == nullptr || size < LIMITSIZE) {
384 return;
385 }
386
387 MessageParcel data;
388 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
389 std::string key(reinterpret_cast<const char*>(rawData), size - 1);
390 std::string value(reinterpret_cast<const char*>(rawData), size - 1);
391 data.WriteString(key);
392 data.WriteString(value);
393
394 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
395 MessageParcel reply;
396 MessageOption option;
397 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_PARAMETER),
398 data, reply, option);
399 }
400
AudioServerSetMicrophoneMuteTest(const uint8_t * rawData,size_t size)401 void AudioServerSetMicrophoneMuteTest(const uint8_t *rawData, size_t size)
402 {
403 if (rawData == nullptr || size < LIMITSIZE) {
404 return;
405 }
406
407 MessageParcel data;
408 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
409 bool isMute = *reinterpret_cast<const bool*>(rawData);
410 data.WriteBool(isMute);
411
412 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
413 MessageParcel reply;
414 MessageOption option;
415 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_MICROPHONE_MUTE),
416 data, reply, option);
417 }
418
AudioServerSetAudioBalanceValueTest(const uint8_t * rawData,size_t size)419 void AudioServerSetAudioBalanceValueTest(const uint8_t *rawData, size_t size)
420 {
421 if (rawData == nullptr || size < LIMITSIZE) {
422 return;
423 }
424
425 MessageParcel data;
426 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
427 float audioBalance = *reinterpret_cast<const float*>(rawData);
428 data.WriteFloat(audioBalance);
429
430 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
431 MessageParcel reply;
432 MessageOption option;
433 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_BALANCE_VALUE),
434 data, reply, option);
435 }
436
AudioServerSetAudioSceneTest(const uint8_t * rawData,size_t size)437 void AudioServerSetAudioSceneTest(const uint8_t *rawData, size_t size)
438 {
439 if (rawData == nullptr || size < LIMITSIZE) {
440 return;
441 }
442
443 MessageParcel data;
444 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
445 AudioScene audioScene = *reinterpret_cast<const AudioScene*>(rawData);
446 DeviceType outputDevice = *reinterpret_cast<const DeviceType*>(rawData);
447 DeviceType inputDevice = *reinterpret_cast<const DeviceType*>(rawData);
448 data.WriteInt32(static_cast<int32_t>(audioScene));
449 data.WriteInt32(static_cast<int32_t>(outputDevice));
450 data.WriteInt32(static_cast<int32_t>(inputDevice));
451
452 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
453 MessageParcel reply;
454 MessageOption option;
455 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_AUDIO_SCENE),
456 data, reply, option);
457 }
458
AudioServerSetOffloadModeTest(const uint8_t * rawData,size_t size)459 void AudioServerSetOffloadModeTest(const uint8_t *rawData, size_t size)
460 {
461 if (rawData == nullptr || size < LIMITSIZE) {
462 return;
463 }
464
465 MessageParcel data;
466 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
467 uint32_t sessionId = *reinterpret_cast<const uint32_t*>(rawData);
468 int32_t state = *reinterpret_cast<const int32_t*>(rawData);
469 bool isAppBack = *reinterpret_cast<const bool*>(rawData);
470 data.WriteUint32(sessionId);
471 data.WriteInt32(state);
472 data.WriteBool(isAppBack);
473
474 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
475 MessageParcel reply;
476 MessageOption option;
477 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::SET_OFFLOAD_MODE),
478 data, reply, option);
479 }
480
AudioServerUnsetOffloadTest(const uint8_t * rawData,size_t size)481 void AudioServerUnsetOffloadTest(const uint8_t *rawData, size_t size)
482 {
483 if (rawData == nullptr || size < LIMITSIZE) {
484 return;
485 }
486
487 MessageParcel data;
488 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
489 uint32_t sessionId = *reinterpret_cast<const uint32_t*>(rawData);
490 data.WriteUint32(sessionId);
491
492 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
493 MessageParcel reply;
494 MessageOption option;
495 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::UNSET_OFFLOAD_MODE),
496 data, reply, option);
497 }
498
AudioServerCheckHibernateStateTest(const uint8_t * rawData,size_t size)499 void AudioServerCheckHibernateStateTest(const uint8_t *rawData, size_t size)
500 {
501 if (rawData == nullptr || size < LIMITSIZE) {
502 return;
503 }
504
505 MessageParcel data;
506 data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
507 bool hibernate = *reinterpret_cast<const bool*>(rawData);
508 data.WriteBool(hibernate);
509
510 std::shared_ptr<AudioServer> AudioServerPtr = std::make_shared<AudioServer>(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
511 MessageParcel reply;
512 MessageOption option;
513 AudioServerPtr->OnRemoteRequest(static_cast<uint32_t>(AudioServerInterfaceCode::CHECK_HIBERNATE_STATE),
514 data, reply, option);
515 }
516 } // namespace AudioStandard
517 } // namesapce OHOS
518
519 OHOS::AudioStandard::TestPtr g_testPtrs[] = {
520 OHOS::AudioStandard::AudioServerFuzzTest,
521 OHOS::AudioStandard::AudioServerCaptureSilentlyFuzzTest,
522 OHOS::AudioStandard::AudioServerOffloadSetVolumeFuzzTest,
523 OHOS::AudioStandard::AudioServerNotifyStreamVolumeChangedFuzzTest,
524 OHOS::AudioStandard::AudioServerResetRouteForDisconnectFuzzTest,
525 OHOS::AudioStandard::AudioServerGetEffectLatencyTest,
526 OHOS::AudioStandard::AudioServerGetMaxAmplitudeTest,
527 OHOS::AudioStandard::AudioServerResetAudioEndpointTest,
528 OHOS::AudioStandard::AudioServerCreatePlaybackCapturerManagerTest,
529 OHOS::AudioStandard::AudioServerSetOutputDeviceSinkTest,
530 OHOS::AudioStandard::AudioServerSetAudioMonoStateTest,
531 OHOS::AudioStandard::AudioServerSetVoiceVolumeTest,
532 OHOS::AudioStandard::AudioServerCheckRemoteDeviceStateTest,
533 OHOS::AudioStandard::AudioServerNotifyDeviceInfoTest,
534 OHOS::AudioStandard::AudioServerGetAudioParameterTest,
535 OHOS::AudioStandard::AudioServerSetAudioParameterTest,
536 OHOS::AudioStandard::AudioServerSetMicrophoneMuteTest,
537 OHOS::AudioStandard::AudioServerSetAudioBalanceValueTest,
538 OHOS::AudioStandard::AudioServerSetAudioSceneTest,
539 OHOS::AudioStandard::AudioServerUpdateLatencyTimestampTest,
540 OHOS::AudioStandard::AudioServerSetOffloadModeTest,
541 OHOS::AudioStandard::AudioServerUnsetOffloadTest,
542 OHOS::AudioStandard::AudioServerCheckHibernateStateTest
543 };
544
545 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)546 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
547 {
548 /* Run your code on data */
549 if (data == nullptr || size <= 1) {
550 return 0;
551 }
552 uint32_t len = OHOS::AudioStandard::GetArrLength(g_testPtrs);
553 if (len > 0) {
554 uint8_t firstByte = *data % len;
555 if (firstByte >= len) {
556 return 0;
557 }
558 data = data + 1;
559 size = size - 1;
560 g_testPtrs[firstByte](data, size);
561 }
562 return 0;
563 }