1 /*
2 * Copyright (c) 2023 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 <cstddef>
17 #include <cstdint>
18
19 #include "securec.h"
20 #include "avsession_item.h"
21 #include "ipc_skeleton.h"
22 #include "avcontroller_callback_proxy.h"
23 #include "avsession_controller_stub.h"
24 #include "avsession_errors.h"
25 #include "system_ability_definition.h"
26 #include "audio_info.h"
27 #include "avsession_service.h"
28 #include "avsessionservice_fuzzer.h"
29 #include "client_death_proxy.h"
30 #include "client_death_stub.h"
31 #include "audio_info.h"
32 #include "audio_adapter.h"
33
34 using namespace std;
35 using namespace OHOS::AudioStandard;
36 namespace OHOS {
37 namespace AVSession {
38
39 static constexpr int32_t CAST_ENGINE_SA_ID = 65546;
40 static constexpr int32_t TEST_SESSION_ID = 2;
41 static constexpr int32_t CLIENT_UID = 1;
42 static char g_testSessionTag[] = "test";
43 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
44 static char g_testAnotherAbilityName[] = "testAnother.ability";
45 static sptr<AVSessionService> avsessionService_;
46 AppExecFwk::ElementName elementName;
47 sptr<AVSessionItem> avsessionHere_ = nullptr;
48 std::vector<OHOS::DistributedHardware::DmDeviceInfo> deviceList;
49 static const int32_t MAX_CODE_LEN = 20;
50 static const int32_t MIN_SIZE_NUM = 10;
51 static const uint8_t *RAW_DATA = nullptr;
52 static size_t g_totalSize = 0;
53 static size_t g_sizePos;
54
55 /*
56 * describe: get data from FUZZ untrusted data(RAW_DATA) which size is according to sizeof(T)
57 * tips: only support basic type
58 */
59 template<class T>
GetData()60 T GetData()
61 {
62 T object {};
63 size_t objectSize = sizeof(object);
64 if (RAW_DATA == nullptr || objectSize > g_totalSize - g_sizePos) {
65 return object;
66 }
67 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_sizePos, objectSize);
68 if (ret != EOK) {
69 return {};
70 }
71 g_sizePos += objectSize;
72 return object;
73 }
74
GetString()75 std::string GetString()
76 {
77 size_t objectSize = (GetData<int8_t>() % MAX_CODE_LEN) + 1;
78 if (RAW_DATA == nullptr || objectSize > g_totalSize - g_sizePos) {
79 return "OVER_SIZE";
80 }
81 char object[objectSize + 1];
82 errno_t ret = memcpy_s(object, sizeof(object), RAW_DATA + g_sizePos, objectSize);
83 if (ret != EOK) {
84 return "";
85 }
86 g_sizePos += objectSize;
87 std::string output(object);
88 return output;
89 }
90
91 template<class T>
GetArrLength(T & arr)92 uint32_t GetArrLength(T& arr)
93 {
94 if (arr == nullptr) {
95 SLOGE("%{public}s: The array length is equal to 0", __func__);
96 return 0;
97 }
98 return sizeof(arr) / sizeof(arr[0]);
99 }
100
101 typedef void (*TestFuncs[3])();
102
103 TestFuncs g_allFuncs = {
104 MockGetTrustedDeviceList,
105 AvSessionServiceTest,
106 AVSessionServiceStubRemoteRequestTest
107 };
108
FuzzTest(const uint8_t * rawData,size_t size)109 bool FuzzTest(const uint8_t* rawData, size_t size)
110 {
111 if (rawData == nullptr) {
112 return false;
113 }
114
115 // initialize data
116 RAW_DATA = rawData;
117 g_totalSize = size;
118 g_sizePos = 0;
119
120 uint32_t code = GetData<uint32_t>();
121 uint32_t len = GetArrLength(g_allFuncs);
122 if (len > 0) {
123 g_allFuncs[code % len]();
124 } else {
125 SLOGE("%{public}s: The len length is equal to 0", __func__);
126 }
127
128 return true;
129 }
130
131
132 class FuzzTestISessionListener : public ISessionListener {
133 public:
OnSessionCreate(const AVSessionDescriptor & descriptor)134 void OnSessionCreate(const AVSessionDescriptor& descriptor) override
135 {
136 };
137
OnSessionRelease(const AVSessionDescriptor & descriptor)138 void OnSessionRelease(const AVSessionDescriptor& descriptor) override
139 {
140 };
141
OnTopSessionChange(const AVSessionDescriptor & descriptor)142 void OnTopSessionChange(const AVSessionDescriptor& descriptor) override
143 {
144 };
145
OnAudioSessionChecked(const int32_t uid)146 void OnAudioSessionChecked(const int32_t uid) override
147 {
148 };
149
OnDeviceAvailable(const OutputDeviceInfo & castOutputDeviceInfo)150 void OnDeviceAvailable(const OutputDeviceInfo& castOutputDeviceInfo) override
151 {
152 };
153
OnDeviceLogEvent(const DeviceLogEventCode eventId,const int64_t param)154 void OnDeviceLogEvent(const DeviceLogEventCode eventId, const int64_t param) override
155 {
156 };
157
OnDeviceOffline(const std::string & deviceId)158 void OnDeviceOffline(const std::string& deviceId) override
159 {
160 };
161
OnRemoteDistributedSessionChange(const std::vector<sptr<IRemoteObject>> & sessionControllers)162 void OnRemoteDistributedSessionChange(
163 const std::vector<sptr<IRemoteObject>>& sessionControllers) override
164 {
165 };
166
AsObject()167 sptr<IRemoteObject> AsObject() override
168 {
169 return nullptr;
170 };
171 };
172
173 template<typename T>
174 class ResourceAutoDestroy {
175 public:
ResourceAutoDestroy(T ptr)176 explicit ResourceAutoDestroy(T ptr) : ptr_(ptr)
177 {
178 }
179
~ResourceAutoDestroy()180 ~ResourceAutoDestroy()
181 {
182 if (ptr_) {
183 ptr_->Destroy();
184 }
185 }
186
187 private:
188 T ptr_;
189 };
190
MockGetTrustedDeviceList()191 void MockGetTrustedDeviceList()
192 {
193 OHOS::DistributedHardware::DmDeviceInfo localeDevice;
194 memset_s(&localeDevice, sizeof(localeDevice), 0, sizeof(localeDevice));
195 strcpy_s(localeDevice.deviceId, sizeof(localeDevice.deviceId) - 1, "<localeDeviceId>");
196 strcpy_s(localeDevice.deviceName, sizeof(localeDevice.deviceName) - 1, "<localeDeviceName>");
197
198 OHOS::DistributedHardware::DmDeviceInfo remoteDevice;
199 memset_s(&remoteDevice, sizeof(remoteDevice), 0, sizeof(remoteDevice));
200 strcpy_s(remoteDevice.deviceId, sizeof(remoteDevice.deviceId) - 1, "<remoteDeviceId>");
201 strcpy_s(remoteDevice.deviceName, sizeof(remoteDevice.deviceName) - 1, "<remoteDeviceName>");
202
203 deviceList.clear();
204 deviceList.push_back(localeDevice);
205 deviceList.push_back(remoteDevice);
206 }
207
GetDeviceInfoTest()208 void GetDeviceInfoTest()
209 {
210 if (avsessionService_ == nullptr) {
211 SLOGI("check service null, try create");
212 avsessionService_ = new AVSessionService(AVSESSION_SERVICE_ID);
213 }
214 if (avsessionService_ == nullptr) {
215 SLOGE("service is null, return");
216 return;
217 }
218 OHOS::AppExecFwk::ElementName elementName;
219 elementName.SetBundleName(g_testAnotherBundleName);
220 elementName.SetAbilityName(g_testAnotherAbilityName);
221 auto uid = GetData<int32_t>();
222 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors;
223 avsessionService_->GetDeviceInfo(avsessionHere_, descriptors, descriptors, descriptors);
224 avsessionService_->GetTrustedDevicesInfo(deviceList);
225 AudioStandard::AudioDeviceDescriptor des;
226 avsessionService_->SelectOutputDevice(uid, des);
227 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
228 avsessionHere_->Destroy();
229
230 avsessionService_->OnDump();
231 avsessionService_->OnStart();
232 avsessionService_->OnStop();
233 }
234
AvSessionServiceSystemAbilityTest(sptr<AVSessionService> service)235 void AvSessionServiceSystemAbilityTest(sptr<AVSessionService> service)
236 {
237 static std::vector<int32_t> systemAbilityIdSet {
238 SAMGR_DUMP_SAID,
239 MULTIMODAL_INPUT_SERVICE_ID,
240 AUDIO_POLICY_SERVICE_ID,
241 APP_MGR_SERVICE_ID,
242 DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID,
243 BUNDLE_MGR_SERVICE_SYS_ABILITY_ID,
244 CAST_ENGINE_SA_ID,
245 MEMORY_MANAGER_SA_ID,
246 COMMON_EVENT_SERVICE_ID,
247 };
248
249 int32_t randomNumber = GetData<uint32_t>();
250 int32_t systemAbilityId = systemAbilityIdSet[randomNumber % systemAbilityIdSet.size()];
251 std::string deviceId = GetString();
252 service->OnAddSystemAbility(systemAbilityId, deviceId);
253 service->OnRemoveSystemAbility(systemAbilityId, deviceId);
254 }
255
AvSessionServiceGetAVQueueInfosTest(sptr<AVSessionService> service)256 void AvSessionServiceGetAVQueueInfosTest(sptr<AVSessionService> service)
257 {
258 int32_t maxSize = GetData<int32_t>();
259 int32_t maxAppSize = GetData<int32_t>();
260 std::vector<AVQueueInfo> avQueueInfos;
261 service->GetHistoricalAVQueueInfos(maxSize, maxAppSize, avQueueInfos);
262 }
263
AvSessionServiceGetDescriptorsTest(sptr<AVSessionService> service)264 void AvSessionServiceGetDescriptorsTest(sptr<AVSessionService> service)
265 {
266 std::string systemAbilityId = GetString();
267 std::vector<AVSessionDescriptor> descriptors;
268 AVSessionDescriptor descriptor;
269 int32_t maxSize = GetData<int32_t>();
270
271 service->GetAllSessionDescriptors(descriptors);
272 service->GetSessionDescriptorsBySessionId(systemAbilityId, descriptor);
273 service->GetHistoricalSessionDescriptors(maxSize, descriptors);
274 systemAbilityId = "sessionId";
275
276 service->GetSessionDescriptorsBySessionId(systemAbilityId, descriptor);
277 }
278
AvSessionServiceAVPlaybackTest(sptr<AVSessionService> service)279 void AvSessionServiceAVPlaybackTest(sptr<AVSessionService> service)
280 {
281 std::string bundleName = GetString();
282 std::string assetId = GetString();
283 AVMetaData meta = avsessionHere_->GetMetaData();
284
285 service->StartAVPlayback(bundleName, assetId);
286 service->DoMetadataImgClean(meta);
287 }
288
CreateNewControllerForSessionTest(sptr<AVSessionService> service)289 void CreateNewControllerForSessionTest(sptr<AVSessionService> service)
290 {
291 int32_t pid = GetData<int32_t>();
292
293 service->CreateNewControllerForSession(pid, avsessionHere_);
294 service->CancelCastAudioForClientExit(pid, avsessionHere_);
295 }
296
AvSessionServiceControllerTest(sptr<AVSessionService> service)297 void AvSessionServiceControllerTest(sptr<AVSessionService> service)
298 {
299 std::string tag = GetString();
300 int32_t type = 0;
301 std::string bundleName = GetString();
302 std::string abilityName = GetString();
303 sptr<IRemoteObject> avSessionItemObj = service->CreateSessionInner(tag, type, elementName);
304 sptr<AVSessionItem> avSessionItem = (sptr<AVSessionItem>&)avSessionItemObj;
305 if (!avSessionItem) {
306 return;
307 }
308 ResourceAutoDestroy<sptr<AVSessionItem>> avSessionItemRelease(avSessionItem);
309 service->AddAvQueueInfoToFile(*avSessionItem);
310 sptr<IRemoteObject> avControllerItemObj;
311 std::string sessionId = GetString();
312 uint32_t ret = service->CreateControllerInner(avSessionItem->GetSessionId(), avControllerItemObj);
313 if (ret != AVSESSION_SUCCESS) {
314 return;
315 }
316 sptr<AVControllerItem> avControllerItem = (sptr<AVControllerItem>&)avControllerItemObj;
317 if (!avControllerItem) {
318 return;
319 }
320 ResourceAutoDestroy<sptr<AVControllerItem>> avControllerItemRelease(avControllerItem);
321 service->HandleControllerRelease(*avControllerItem);
322 service->HandleSessionRelease(avSessionItem->GetSessionId());
323 int32_t uid = GetData<int32_t>();
324
325 service->NotifyAudioSessionCheckTrigger(uid);
326 service->CreateControllerInner("default", avControllerItemObj);
327 }
328
AvSessionServiceCastTest(sptr<AVSessionService> service)329 void AvSessionServiceCastTest(sptr<AVSessionService> service)
330 {
331 std::string tag = GetString();
332 int32_t type = 0;
333 std::string bundleName = GetString();
334 std::string abilityName = GetString();
335 sptr<IRemoteObject> avSessionItemObj = service->CreateSessionInner(tag, type, elementName);
336 sptr<AVSessionItem> avSessionItem = (sptr<AVSessionItem>&)avSessionItemObj;
337 if (!avSessionItem) {
338 return;
339 }
340 SessionToken token;
341 token.sessionId = avSessionItem->GetSessionId();
342 token.pid = GetData<int32_t>();
343 token.uid = GetData<int32_t>();
344
345 std::vector<AudioStandard::AudioDeviceDescriptor> audioDeviceDescriptors;
346 AudioStandard::AudioDeviceDescriptor descriptor;
347 descriptor.deviceType_ = OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
348 audioDeviceDescriptors.push_back(descriptor);
349 OutputDeviceInfo outputDeviceInfo;
350 OHOS::AVSession::DeviceInfo deviceInfo;
351 deviceInfo.castCategory_ = 1;
352 deviceInfo.deviceId_ = "deviceId";
353 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
354 service->CastAudio(token, audioDeviceDescriptors);
355 if (audioDeviceDescriptors.empty()) {
356 audioDeviceDescriptors.emplace_back();
357 }
358 std::string sourceSessionInfo = "SOURCE";
359 service->CastAudioForAll(audioDeviceDescriptors);
360 service->CastAudioProcess(audioDeviceDescriptors, sourceSessionInfo, avsessionHere_);
361 service->CastAudioInner(audioDeviceDescriptors, sourceSessionInfo, avsessionHere_);
362 service->CancelCastAudioInner(audioDeviceDescriptors, sourceSessionInfo, avsessionHere_);
363 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
364 service->StartCast(token, outputDeviceInfo);
365 service->StopCast(token);
366 #endif
367 }
368
369
AVSessionServiceSendSystemControlCommandTest(sptr<AVSessionService> service)370 void AVSessionServiceSendSystemControlCommandTest(sptr<AVSessionService> service)
371 {
372 AVControlCommand command;
373 command.SetCommand(GetData<int32_t>());
374 service->SendSystemControlCommand(command);
375 sptr<FuzzTestISessionListener> listener = new FuzzTestISessionListener();
376 service->RegisterSessionListener(listener);
377 }
378
AvSessionServiceClientTest(sptr<AVSessionService> service)379 void AvSessionServiceClientTest(sptr<AVSessionService> service)
380 {
381 int32_t pid = GetData<int32_t>();
382 service->OnClientDied(pid);
383
384 sptr<IClientDeath> clientDeath = new ClientDeathStub();
385 auto func = []() {};
386 sptr<ClientDeathRecipient> recipient = new ClientDeathRecipient(func);
387 std::vector<AVSessionDescriptor> descriptors;
388 AVSessionDescriptor descriptor;
389 service->AddClientDeathObserver(pid, clientDeath, recipient);
390 service->RegisterClientDeathObserver(clientDeath);
391
392 service->NotifyTopSessionChanged(descriptor);
393 service->CreateWantAgent(&descriptor);
394 }
395
AvSessionServiceHandleEventTest(sptr<AVSessionService> service)396 void AvSessionServiceHandleEventTest(sptr<AVSessionService> service)
397 {
398 std::string sessionId = GetString();
399 service->HandleSessionRelease(sessionId);
400 service->HandleCallStartEvent();
401
402 int32_t fd = GetData<int32_t>();
403 string strArg = GetString();
404 std::u16string u16strArg(strArg.begin(), strArg.end());
405 std::vector<std::u16string> args;
406 args.emplace_back(u16strArg);
407 service->Dump(fd, args);
408 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
409 OutputDeviceInfo outputDeviceInfo;
410 OHOS::AVSession::DeviceInfo deviceInfo;
411 deviceInfo.castCategory_ = 1;
412 deviceInfo.deviceId_ = "deviceId";
413 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
414 avsessionService_->NotifyDeviceAvailable(outputDeviceInfo);
415 avsessionService_->UpdateTopSession(avsessionHere_);
416 avsessionService_->NotifyMirrorToStreamCast();
417 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
418 #endif
419 }
420
AvSessionServiceSuperLauncherTest001(sptr<AVSessionService> service)421 void AvSessionServiceSuperLauncherTest001(sptr<AVSessionService> service)
422 {
423 vector<string> states { "UNKNOWN", "IDLE", "CONNECTING" };
424 vector<string> serviceNames {"Unknown", "SuperLauncher-Dual", "HuaweiCast" };
425 int32_t randomNumber = 1;
426 std::string serviceName = serviceNames[randomNumber % serviceNames.size()];
427 std::string state = states[randomNumber % states.size()];
428 std::string deviceId = GetString();
429 std::string extraInfo = GetString();
430 service->SuperLauncher(deviceId, serviceName, extraInfo, state);
431 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
432 avsessionService_->NotifyMirrorToStreamCast();
433 #endif
434 }
435
StartDefaultAbilityByCall001()436 void StartDefaultAbilityByCall001()
437 {
438 SLOGI("StartDefaultAbilityByCall001 begin!");
439 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
440 avsessionService_->UpdateTopSession(avsessionHere_);
441 avsessionService_->NotifyMirrorToStreamCast();
442 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
443 avsessionService_->is2in1_ = true;
444 avsessionService_->MirrorToStreamCast(avsessionHere_);
445 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
446 #endif
447 AudioRendererChangeInfo info = {};
448 info.clientUID = avsessionHere_->GetUid();
449
450 std::shared_ptr<AudioRendererChangeInfo> info_ = std::make_shared<AudioRendererChangeInfo>();
451 info_->clientUID = CLIENT_UID;
452 info_->sessionId = TEST_SESSION_ID;
453 info_->rendererState = RendererState::RENDERER_RELEASED;
454 AudioRendererChangeInfos infos;
455 infos.push_back(std::move(info_));
456 avsessionService_->SelectSessionByUid(info);
457 avsessionService_->OutputDeviceChangeListener(infos);
458 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
459 avsessionService_->SaveSessionInfoInFile(avsessionHere_->GetSessionId(),
460 "audio", elementName);
461 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
462 std::string sessionId = GetString();
463 avsessionService_->SaveSessionInfoInFile(avsessionHere_->GetSessionId(),
464 "audio", elementName);
465 avsessionService_->StartDefaultAbilityByCall(sessionId);
466 std::vector<AVQueueInfo> avQueueInfos_;
467 avsessionService_->GetHistoricalAVQueueInfos(0, 0, avQueueInfos_);
468 info = {};
469 info.clientUID = avsessionHere_->GetUid();
470 }
471
StartAVPlayback001()472 void StartAVPlayback001()
473 {
474 SLOGI("StartAVPlayback001 begin!");
475 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
476 avsessionService_->is2in1_ = true;
477 avsessionService_->MirrorToStreamCast(avsessionHere_);
478 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
479 #endif
480 avsessionService_->AddAvQueueInfoToFile(*avsessionHere_);
481 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
482 vector<string> assetNames { "FAKE_ASSET_NAME1", "FAKE_ASSET_NAME2" };
483 int32_t randomNumber = GetData<int32_t>();
484 std::string assetName = assetNames[randomNumber % assetNames.size()];
485 avsessionService_->StartAVPlayback(g_testAnotherBundleName, assetName);
486 nlohmann::json value;
487 value["bundleName"] = g_testAnotherBundleName;
488 avsessionService_->GetSubNode(value, "FAKE_NAME");
489 avsessionService_->DeleteHistoricalRecord(g_testAnotherBundleName);
490 std::vector<std::u16string> argsList;
491 avsessionService_->Dump(1, argsList);
492 SLOGI("StartAVPlayback001 end!");
493 }
494
ReportStartCastBegin001()495 void ReportStartCastBegin001()
496 {
497 SLOGI("ReportStartCastBegin001 begin!");
498 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
499 avsessionService_->is2in1_ = false;
500 avsessionService_->MirrorToStreamCast(avsessionHere_);
501 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
502 #endif
503 std::string sourceSessionInfo = "SOURCE";
504 std::string sinkSessionInfo = " SINK";
505 avsessionService_->ProcessCastAudioCommand(
506 OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CAST_AUDIO,
507 sourceSessionInfo, sinkSessionInfo);
508 OutputDeviceInfo outputDeviceInfo;
509 std::string func = GetString();
510 auto uid = GetData<int32_t>();
511 avsessionService_->ReportStartCastBegin(func, outputDeviceInfo, uid);
512 SLOGI("ReportStartCastBegin001 end!");
513 }
514
ReportStartCastEnd001()515 void ReportStartCastEnd001()
516 {
517 SLOGI("ReportStartCastEnd001 begin!");
518 std::string sourceSessionInfo = "SOURCE";
519 std::string sinkSessionInfo = " SINK";
520 avsessionService_->ProcessCastAudioCommand(
521 OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CANCEL_CAST_AUDIO,
522 sourceSessionInfo, sinkSessionInfo);
523 OutputDeviceInfo outputDeviceInfo;
524 int32_t ret = AVSESSION_SUCCESS;
525 std::string func = GetString();
526 auto uid = GetData<int32_t>();
527 avsessionService_->ReportStartCastEnd(func, outputDeviceInfo, uid, ret);
528 SLOGI("ReportStartCastEnd001 end!");
529 }
530
ReportStartCastEnd002()531 void ReportStartCastEnd002()
532 {
533 SLOGI("ReportStartCastEnd002 begin!");
534 OutputDeviceInfo outputDeviceInfo;
535 int32_t ret = AVSESSION_ERROR;
536 std::string func = GetString();
537 auto uid = GetData<int32_t>();
538 avsessionService_->ReportStartCastEnd(func, outputDeviceInfo, uid, ret);
539 SLOGI("ReportStartCastEnd002 end!");
540 }
541
ConvertKeyCodeToCommand001()542 void ConvertKeyCodeToCommand001()
543 {
544 auto keyCode = GetData<int32_t>();
545 avsessionService_->ConvertKeyCodeToCommand(keyCode);
546 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
547 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
548 descriptor->deviceType_ = OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
549 audioDeviceDescriptors.push_back(descriptor);
550 avsessionService_->HandleDeviceChange(audioDeviceDescriptors);
551 }
552
HandleDeviceChange001()553 void HandleDeviceChange001()
554 {
555 SLOGI("HandleDeviceChange001 begin!");
556 DeviceChangeAction deviceChange;
557 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
558 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
559 descriptor->deviceType_ = OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
560 int32_t randomNumber = GetData<int32_t>();
561 int32_t enumSize = 2;
562 deviceChange.type = static_cast<DeviceChangeType>(randomNumber % enumSize);
563 deviceChange.flag = static_cast<DeviceFlag>(randomNumber % enumSize);
564
565 audioDeviceDescriptors.push_back(descriptor);
566 deviceChange.deviceDescriptors = audioDeviceDescriptors;
567 avsessionService_->HandleDeviceChange(audioDeviceDescriptors);
568 auto keyEvent = OHOS::MMI::KeyEvent::Create();
569 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
570 keyEvent->SetActionTime(1);
571 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_CANCEL);
572 avsessionService_->SendSystemAVKeyEvent(*(keyEvent.get()));
573 SLOGI("HandleDeviceChange001 end!");
574 }
575
GetTrustedDeviceName001()576 void GetTrustedDeviceName001()
577 {
578 SLOGI("GetTrustedDeviceName001 begin!");
579 auto keyEvent = OHOS::MMI::KeyEvent::Create();
580 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HOME);
581 keyEvent->SetActionTime(1);
582 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_CANCEL);
583 avsessionService_->SendSystemAVKeyEvent(*(keyEvent.get()));
584 std::string networkId = "networkId";
585 std::string deviceName = GetString();
586 avsessionService_->GetTrustedDeviceName(networkId, deviceName);
587
588 deviceName = "LocalDevice";
589 avsessionService_->GetTrustedDeviceName(networkId, deviceName);
590 networkId = "networkId";
591 std::string deviceId = "deviceId";
592 avsessionService_->GetService(deviceId);
593 std::vector<AudioStandard::AudioDeviceDescriptor> castAudioDescriptors;
594 AudioStandard::AudioDeviceDescriptor des;
595 castAudioDescriptors.push_back(des);
596 avsessionService_->SetDeviceInfo(castAudioDescriptors, avsessionHere_);
597 avsessionService_->CastAudioForNewSession(avsessionHere_);
598 SLOGI("GetTrustedDeviceName001 end!");
599 }
600
601 class FuzzSessionListener : public SessionListener {
602 public:
OnSessionCreate(const AVSessionDescriptor & descriptor)603 void OnSessionCreate(const AVSessionDescriptor& descriptor) override
604 {
605 SLOGI("sessionId=%{public}s created", descriptor.sessionId_.c_str());
606 }
607
OnSessionRelease(const AVSessionDescriptor & descripter)608 void OnSessionRelease(const AVSessionDescriptor& descripter) override
609 {
610 SLOGI("sessionId=%{public}s released", descripter.sessionId_.c_str());
611 }
612
OnTopSessionChange(const AVSessionDescriptor & descriptor)613 void OnTopSessionChange(const AVSessionDescriptor& descriptor) override
614 {
615 SLOGI("sessionId=%{public}s be top session", descriptor.sessionId_.c_str());
616 }
617
OnAudioSessionChecked(const int32_t uid)618 void OnAudioSessionChecked(const int32_t uid) override
619 {
620 SLOGI("uid=%{public}d checked", uid);
621 }
622 };
623
handleusereventTest(sptr<AVSessionService> service)624 void handleusereventTest(sptr<AVSessionService> service)
625 {
626 FuzzSessionListener listener;
627 avsessionService_->AddInnerSessionListener(&listener);
628 avsessionService_->RemoveInnerSessionListener(&listener);
629 OHOS::EventFwk::CommonEventData eventData;
630 string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON;
631 OHOS::AAFwk::Want want = eventData.GetWant();
632 want.SetAction(action);
633 eventData.SetWant(want);
634 OHOS::EventFwk::MatchingSkills matchingSkills;
635 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
636 EventSubscriber eventSubscriber(subscriberInfo, avsessionService_);
637 eventSubscriber.OnReceiveEvent(eventData);
638 auto userId = GetData<int32_t>();
639 std::string type = GetString();
640 service->HandleUserEvent(type, userId);
641 }
642
AvSessionServiceTest001()643 void AvSessionServiceTest001()
644 {
645 GetDeviceInfoTest();
646 StartDefaultAbilityByCall001();
647 StartAVPlayback001();
648 ReportStartCastBegin001();
649 ReportStartCastEnd001();
650 ReportStartCastEnd002();
651 HandleDeviceChange001();
652 GetTrustedDeviceName001();
653 }
654
AvSessionServiceTest()655 void AvSessionServiceTest()
656 {
657 if (avsessionService_ == nullptr) {
658 SLOGI("check service null, try create");
659 avsessionService_ = new AVSessionService(AVSESSION_SERVICE_ID);
660 }
661 if (avsessionService_ == nullptr) {
662 SLOGE("service is null, return");
663 return;
664 }
665 elementName.SetBundleName(g_testAnotherBundleName);
666 elementName.SetAbilityName(g_testAnotherAbilityName);
667 avsessionHere_ = avsessionService_->CreateSessionInner(
668 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
669 AvSessionServiceSystemAbilityTest(avsessionService_);
670 AvSessionServiceGetAVQueueInfosTest(avsessionService_);
671 AvSessionServiceGetDescriptorsTest(avsessionService_);
672 AvSessionServiceAVPlaybackTest(avsessionService_);
673 CreateNewControllerForSessionTest(avsessionService_);
674 AvSessionServiceControllerTest(avsessionService_);
675 AvSessionServiceCastTest(avsessionService_);
676 AVSessionServiceSendSystemControlCommandTest(avsessionService_);
677 AvSessionServiceClientTest(avsessionService_);
678 AvSessionServiceHandleEventTest(avsessionService_);
679 ConvertKeyCodeToCommand001();
680 handleusereventTest(avsessionService_);
681
682 AvSessionServiceTest001();
683 }
684
OnRemoteRequest()685 int32_t AVSessionServiceStubFuzzer::OnRemoteRequest()
686 {
687 uint32_t code = GetData<uint32_t>();
688 code %= static_cast<uint32_t>(AvsessionSeviceInterfaceCode::SERVICE_CMD_MAX);
689
690 if (avsessionService_ == nullptr) {
691 SLOGI("check service null, try create");
692 avsessionService_ = new AVSessionService(AVSESSION_SERVICE_ID);
693 }
694 if (avsessionService_ == nullptr) {
695 SLOGE("service is null, return");
696 return AVSESSION_ERROR;
697 }
698 MessageParcel dataMessageParcel;
699 if (!dataMessageParcel.WriteInterfaceToken(avsessionService_->GetDescriptor())) {
700 return AVSESSION_ERROR;
701 }
702 dataMessageParcel.WriteBuffer(RAW_DATA, g_sizePos);
703 g_sizePos += sizeof(uint32_t);
704 dataMessageParcel.RewindRead(0);
705 MessageParcel reply;
706 MessageOption option;
707 int32_t ret = avsessionService_->OnRemoteRequest(code, dataMessageParcel, reply, option);
708 return ret;
709 }
710
AVSessionServiceStubRemoteRequestTest()711 void AVSessionServiceStubRemoteRequestTest()
712 {
713 auto serviceStub = std::make_unique<AVSessionServiceStubFuzzer>();
714 if (serviceStub == nullptr) {
715 return;
716 }
717 serviceStub->OnRemoteRequest();
718 if (avsessionService_ == nullptr) {
719 SLOGI("check service null, try create");
720 avsessionService_ = new AVSessionService(AVSESSION_SERVICE_ID);
721 }
722 if (avsessionService_ == nullptr) {
723 SLOGE("service is null, return");
724 return;
725 }
726 avsessionService_->Close();
727 avsessionService_ = nullptr;
728 }
729
730 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)731 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
732 {
733 if (size < MIN_SIZE_NUM) {
734 return 0;
735 }
736 /* Run your code on data */
737 FuzzTest(data, size);
738 return 0;
739 }
740 } // namespace AVSession
741 } // namespace OHOS
742