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 "avsession_item.h"
20 #include "ipc_skeleton.h"
21 #include "avcontroller_callback_proxy.h"
22 #include "avsession_controller_stub.h"
23 #include "avsession_errors.h"
24 #include "system_ability_definition.h"
25 #include "audio_info.h"
26
27 #define private public
28 #define protected public
29 #include "avsession_service.h"
30 #undef protected
31 #undef private
32
33 #include "avsessionservice_fuzzer.h"
34 #include "client_death_proxy.h"
35 #include "client_death_stub.h"
36 #include "audio_info.h"
37
38 using namespace std;
39 using namespace OHOS::AudioStandard;
40 namespace OHOS {
41 namespace AVSession {
42
43
44 static constexpr int32_t MAX_CODE_LEN = 512;
45 static constexpr int32_t MIN_SIZE_NUM = 4;
46 static constexpr int32_t CAST_ENGINE_SA_ID = 65546;
47 static char g_testSessionTag[] = "test";
48 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
49 static char g_testAnotherAbilityName[] = "testAnother.ability";
50 static sptr<AVSessionService> avsessionService_;
51
52 class FuzzTestISessionListener : public ISessionListener {
53 public:
OnSessionCreate(const AVSessionDescriptor & descriptor)54 void OnSessionCreate(const AVSessionDescriptor& descriptor) override
55 {
56 };
57
OnSessionRelease(const AVSessionDescriptor & descriptor)58 void OnSessionRelease(const AVSessionDescriptor& descriptor) override
59 {
60 };
61
OnTopSessionChange(const AVSessionDescriptor & descriptor)62 void OnTopSessionChange(const AVSessionDescriptor& descriptor) override
63 {
64 };
65
OnAudioSessionChecked(const int32_t uid)66 void OnAudioSessionChecked(const int32_t uid) override
67 {
68 };
69
OnDeviceAvailable(const OutputDeviceInfo & castOutputDeviceInfo)70 void OnDeviceAvailable(const OutputDeviceInfo& castOutputDeviceInfo) override
71 {
72 };
73
OnDeviceLogEvent(const DeviceLogEventCode eventId,const int64_t param)74 void OnDeviceLogEvent(const DeviceLogEventCode eventId, const int64_t param) override
75 {
76 };
77
OnDeviceOffline(const std::string & deviceId)78 void OnDeviceOffline(const std::string& deviceId) override
79 {
80 };
81
AsObject()82 sptr<IRemoteObject> AsObject() override
83 {
84 return nullptr;
85 };
86 };
87
88 template<typename T>
89 class ResourceAutoDestroy {
90 public:
ResourceAutoDestroy(T ptr)91 explicit ResourceAutoDestroy(T ptr) : ptr_(ptr)
92 {
93 }
94
~ResourceAutoDestroy()95 ~ResourceAutoDestroy()
96 {
97 if (ptr_) {
98 ptr_->Destroy();
99 }
100 }
101
102 private:
103 T ptr_;
104 };
105
AvSessionServiceExternalCallTest(const uint8_t * data,size_t size)106 void AvSessionServiceExternalCallTest(const uint8_t* data, size_t size)
107 {
108 if (avsessionService_ == nullptr) {
109 SLOGI("check service null, try create");
110 avsessionService_ = new AVSessionService(AVSESSION_SERVICE_ID);
111 }
112 if (avsessionService_ == nullptr) {
113 SLOGE("service is null, return");
114 return;
115 }
116
117 avsessionService_->OnDump();
118 avsessionService_->OnStart();
119 avsessionService_->OnStop();
120 }
121
AvSessionServiceCloseTest(const uint8_t * data,size_t size)122 void AvSessionServiceCloseTest(const uint8_t* data, size_t size)
123 {
124 if (avsessionService_ == nullptr) {
125 SLOGI("check service null, try create");
126 avsessionService_ = new AVSessionService(AVSESSION_SERVICE_ID);
127 }
128 if (avsessionService_ == nullptr) {
129 SLOGE("service is null, return");
130 return;
131 }
132 avsessionService_->Close();
133 avsessionService_ = nullptr;
134 }
135
AvSessionServiceSystemAbilityTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)136 void AvSessionServiceSystemAbilityTest(const uint8_t* data, size_t size,
137 sptr<AVSessionService> service)
138 {
139 static std::vector<int32_t> systemAbilityIdSet {
140 SAMGR_DUMP_SAID,
141 MULTIMODAL_INPUT_SERVICE_ID,
142 AUDIO_POLICY_SERVICE_ID,
143 APP_MGR_SERVICE_ID,
144 DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID,
145 BUNDLE_MGR_SERVICE_SYS_ABILITY_ID,
146 CAST_ENGINE_SA_ID,
147 MEMORY_MANAGER_SA_ID,
148 };
149
150 int32_t randomNumber = *(reinterpret_cast<const int32_t *>(data));
151 int32_t systemAbilityId = systemAbilityIdSet[randomNumber % systemAbilityIdSet.size()];
152 std::string deviceId(reinterpret_cast<const char *>(data), size);
153 service->OnAddSystemAbility(systemAbilityId, deviceId);
154 service->OnRemoveSystemAbility(systemAbilityId, deviceId);
155 }
156
AvSessionServiceGetAVQueueInfosTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)157 void AvSessionServiceGetAVQueueInfosTest(const uint8_t* data, size_t size,
158 sptr<AVSessionService> service)
159 {
160 int32_t maxSize = *(reinterpret_cast<const int32_t *>(data));
161 int32_t maxAppSize = *(reinterpret_cast<const int32_t *>(data));
162 std::vector<AVQueueInfo> avQueueInfos;
163 service->GetHistoricalAVQueueInfos(maxSize, maxAppSize, avQueueInfos);
164 }
165
AvSessionServiceGetDescriptorsTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)166 void AvSessionServiceGetDescriptorsTest(const uint8_t* data, size_t size,
167 sptr<AVSessionService> service)
168 {
169 std::string systemAbilityId(reinterpret_cast<const char *>(data), size);
170 std::vector<AVSessionDescriptor> descriptors;
171 AVSessionDescriptor descriptor;
172 int32_t maxSize = *(reinterpret_cast<const int32_t *>(data));
173
174 service->GetAllSessionDescriptors(descriptors);
175 service->GetSessionDescriptorsBySessionId(systemAbilityId, descriptor);
176 service->GetHistoricalSessionDescriptors(maxSize, descriptors);
177 }
178
AvSessionServiceAVPlaybackTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)179 void AvSessionServiceAVPlaybackTest(const uint8_t* data, size_t size,
180 sptr<AVSessionService> service)
181 {
182 std::string bundleName(reinterpret_cast<const char *>(data), size);
183 std::string assetId(reinterpret_cast<const char *>(data), size);
184
185 service->StartAVPlayback(bundleName, assetId);
186 }
187
AvSessionServiceControllerTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)188 void AvSessionServiceControllerTest(const uint8_t* data, size_t size,
189 sptr<AVSessionService> service)
190 {
191 std::string tag(reinterpret_cast<const char*>(data), size);
192 int32_t type = *reinterpret_cast<const int32_t*>(data);
193 std::string bundleName(reinterpret_cast<const char*>(data), size);
194 std::string abilityName(reinterpret_cast<const char*>(data), size);
195 AppExecFwk::ElementName elementName;
196 elementName.SetBundleName(bundleName);
197 elementName.SetAbilityName(abilityName);
198 sptr<IRemoteObject> avSessionItemObj = service->CreateSessionInner(tag, type % MIN_SIZE_NUM, elementName);
199 sptr<AVSessionItem> avSessionItem = (sptr<AVSessionItem>&)avSessionItemObj;
200 if (!avSessionItem) {
201 return;
202 }
203 ResourceAutoDestroy<sptr<AVSessionItem>> avSessionItemRelease(avSessionItem);
204 service->AddAvQueueInfoToFile(*avSessionItem);
205 sptr<IRemoteObject> avControllerItemObj;
206 std::string sessionId(reinterpret_cast<const char*>(data), size);
207 uint32_t ret = service->CreateControllerInner(avSessionItem->GetSessionId(), avControllerItemObj);
208 if (ret != AVSESSION_SUCCESS) {
209 return;
210 }
211 sptr<AVControllerItem> avControllerItem = (sptr<AVControllerItem>&)avControllerItemObj;
212 if (!avControllerItem) {
213 return;
214 }
215 ResourceAutoDestroy<sptr<AVControllerItem>> avControllerItemRelease(avControllerItem);
216 service->HandleControllerRelease(*avControllerItem);
217 service->HandleSessionRelease(avSessionItem->GetSessionId());
218
219 SessionToken token;
220 token.sessionId = avSessionItem->GetSessionId();
221 token.pid = *(reinterpret_cast<const int32_t *>(data));
222 token.uid = *(reinterpret_cast<const int32_t *>(data));
223 int32_t uid = *(reinterpret_cast<const int32_t *>(data));
224
225 std::vector<AudioStandard::AudioDeviceDescriptor> audioDeviceDescriptors;
226 AudioStandard::AudioDeviceDescriptor descriptor;
227 descriptor.deviceType_ = OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
228 audioDeviceDescriptors.push_back(descriptor);
229 service->CastAudio(token, audioDeviceDescriptors);
230 service->CastAudioForAll(audioDeviceDescriptors);
231 service->NotifyAudioSessionCheckTrigger(uid);
232
233 service->CreateControllerInner("default", avControllerItemObj);
234 }
235
AVSessionServiceSendSystemControlCommandTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)236 void AVSessionServiceSendSystemControlCommandTest(const uint8_t* data, size_t size,
237 sptr<AVSessionService> service)
238 {
239 AVControlCommand command;
240 command.SetCommand(*reinterpret_cast<const int32_t*>(data));
241 service->SendSystemControlCommand(command);
242 sptr<FuzzTestISessionListener> listener = new FuzzTestISessionListener();
243 if (!listener) {
244 return;
245 }
246 service->RegisterSessionListener(listener);
247 service->RegisterSessionListenerForAllUsers(listener);
248 }
249
AvSessionServiceClientTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)250 void AvSessionServiceClientTest(const uint8_t* data, size_t size,
251 sptr<AVSessionService> service)
252 {
253 int32_t pid = *reinterpret_cast<const int32_t*>(data);
254 service->OnClientDied(pid);
255
256 sptr<ClientDeathStub> clientDeath = new ClientDeathStub();
257 service->RegisterClientDeathObserver(clientDeath);
258 }
259
AvSessionServiceHandleEventTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)260 void AvSessionServiceHandleEventTest(const uint8_t* data, size_t size,
261 sptr<AVSessionService> service)
262 {
263 std::string sessionId(reinterpret_cast<const char*>(data), size);
264 service->HandleSessionRelease(sessionId);
265 service->HandleCallStartEvent();
266
267 int32_t fd = *reinterpret_cast<const int32_t*>(data);
268 string strArg(reinterpret_cast<const char*>(data), size);
269 std::u16string u16strArg(strArg.begin(), strArg.end());
270 std::vector<std::u16string> args;
271 args.emplace_back(u16strArg);
272 service->Dump(fd, args);
273 }
274
AvSessionServiceSuperLauncherTest(const uint8_t * data,size_t size,sptr<AVSessionService> service)275 void AvSessionServiceSuperLauncherTest(const uint8_t* data, size_t size,
276 sptr<AVSessionService> service)
277 {
278 vector<string> states {
279 "UNKNOWN",
280 "IDLE",
281 "CONNECTING",
282 };
283 vector<string> serviceNames {
284 "Unknown",
285 "SuperLauncher",
286 "HuaweiCast",
287 };
288 int32_t randomNumber = *(reinterpret_cast<const int32_t *>(data));
289 std::string serviceName = serviceNames[randomNumber % serviceNames.size()];
290 std::string state = states[randomNumber % states.size()];
291 std::string deviceId(reinterpret_cast<const char*>(data), size);
292 std::string extraInfo(reinterpret_cast<const char*>(data), size);
293 service->SuperLauncher(deviceId, serviceName, extraInfo, state);
294 }
295
NotifyDeviceAvailable001(const uint8_t * data,size_t size)296 void NotifyDeviceAvailable001(const uint8_t* data, size_t size)
297 {
298 SLOGI("NotifyDeviceAvailable001 begin!");
299 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
300 SLOGI("NotifyDeviceAvailable001 in!");
301 OutputDeviceInfo outputDeviceInfo;
302 OHOS::AVSession::DeviceInfo deviceInfo;
303 deviceInfo.castCategory_ = 1;
304 deviceInfo.deviceId_ = "deviceId";
305 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
306 avsessionService_->NotifyDeviceAvailable(outputDeviceInfo);
307 #endif
308 SLOGI("NotifyDeviceAvailable001 end!");
309 }
310
NotifyMirrorToStreamCast001(const uint8_t * data,size_t size)311 void NotifyMirrorToStreamCast001(const uint8_t* data, size_t size)
312 {
313 SLOGI("NotifyMirrorToStreamCast001 begin!");
314 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
315 SLOGI("NotifyMirrorToStreamCast001 in!");
316 avsessionService_->NotifyMirrorToStreamCast();
317 #endif
318 SLOGI("NotifyMirrorToStreamCast001 end!");
319 }
320
NotifyMirrorToStreamCast002(const uint8_t * data,size_t size)321 void NotifyMirrorToStreamCast002(const uint8_t* data, size_t size)
322 {
323 SLOGI("NotifyMirrorToStreamCast002 begin!");
324 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
325 SLOGI("NotifyMirrorToStreamCast002 in!");
326 OHOS::AppExecFwk::ElementName elementName;
327 elementName.SetBundleName(g_testAnotherBundleName);
328 elementName.SetAbilityName(g_testAnotherAbilityName);
329 OHOS::sptr<AVSessionItem> avsessionHere_ =
330 avsessionService_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
331 avsessionService_->UpdateTopSession(avsessionHere_);
332 avsessionService_->NotifyMirrorToStreamCast();
333 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
334 #endif
335 SLOGI("NotifyMirrorToStreamCast002 end!");
336 }
337
NotifyMirrorToStreamCast003(const uint8_t * data,size_t size)338 void NotifyMirrorToStreamCast003(const uint8_t* data, size_t size)
339 {
340 SLOGI("NotifyMirrorToStreamCast003 begin!");
341 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
342 SLOGI("NotifyMirrorToStreamCast002 in!");
343 OHOS::AppExecFwk::ElementName elementName;
344 elementName.SetBundleName(g_testAnotherBundleName);
345 elementName.SetAbilityName(g_testAnotherAbilityName);
346 OHOS::sptr<AVSessionItem> avsessionHere_ =
347 avsessionService_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
348 avsessionService_->UpdateTopSession(avsessionHere_);
349 avsessionService_->NotifyMirrorToStreamCast();
350 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
351 #endif
352 SLOGI("NotifyMirrorToStreamCast003 end!");
353 }
354
RefreshFocusSessionSort001(const uint8_t * data,size_t size)355 void RefreshFocusSessionSort001(const uint8_t* data, size_t size)
356 {
357 SLOGI("RefreshFocusSessionSort001 begin!");
358 OHOS::AppExecFwk::ElementName elementName;
359 elementName.SetBundleName(g_testAnotherBundleName);
360 elementName.SetAbilityName(g_testAnotherAbilityName);
361 OHOS::sptr<AVSessionItem> avsessionHere_ =
362 avsessionService_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
363 avsessionService_->RefreshFocusSessionSort(avsessionHere_);
364 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
365 SLOGI("RefreshFocusSessionSort001 end!");
366 }
367
SelectSessionByUid001(const uint8_t * data,size_t size)368 void SelectSessionByUid001(const uint8_t* data, size_t size)
369 {
370 SLOGI("SelectSessionByUid001 begin!");
371 OHOS::AppExecFwk::ElementName elementName;
372 elementName.SetBundleName(g_testAnotherBundleName);
373 elementName.SetAbilityName(g_testAnotherAbilityName);
374 OHOS::sptr<AVSessionItem> avsessionHere_ =
375 avsessionService_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
376 AudioRendererChangeInfo info = {};
377 info.clientUID = 0;
378 avsessionService_->SelectSessionByUid(info);
379 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
380 SLOGI("SelectSessionByUid001 end!");
381 }
382
SelectSessionByUid002(const uint8_t * data,size_t size)383 void SelectSessionByUid002(const uint8_t* data, size_t size)
384 {
385 SLOGI("SelectSessionByUid002 begin!");
386 OHOS::AppExecFwk::ElementName elementName;
387 elementName.SetBundleName(g_testAnotherBundleName);
388 elementName.SetAbilityName(g_testAnotherAbilityName);
389 OHOS::sptr<AVSessionItem> avsessionHere_ =
390 avsessionService_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
391 AudioRendererChangeInfo info = {};
392 info.clientUID = avsessionHere_->GetUid();
393 avsessionService_->SelectSessionByUid(info);
394 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
395 SLOGI("SelectSessionByUid002 end!");
396 }
397
InitBMS001(const uint8_t * data,size_t size)398 void InitBMS001(const uint8_t* data, size_t size)
399 {
400 SLOGI("InitBMS001 begin!");
401 avsessionService_->InitBMS();
402 SLOGI("InitBMS001 end!");
403 }
404
ReleaseCastSession001(const uint8_t * data,size_t size)405 void ReleaseCastSession001(const uint8_t* data, size_t size)
406 {
407 SLOGI("ReleaseCastSession001 begin!");
408 OHOS::AppExecFwk::ElementName elementName;
409 elementName.SetBundleName(g_testAnotherBundleName);
410 elementName.SetAbilityName(g_testAnotherAbilityName);
411 OHOS::sptr<AVSessionItem> avsessionHere_ =
412 avsessionService_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
413 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
414 SLOGI("ReleaseCastSession001 in!");
415 avsessionService_->ReleaseCastSession();
416 #endif
417 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
418 SLOGI("ReleaseCastSession001 end!");
419 }
420
CreateSessionByCast001(const uint8_t * data,size_t size)421 void CreateSessionByCast001(const uint8_t* data, size_t size)
422 {
423 SLOGI("CreateSessionByCast001 begin!");
424 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
425 SLOGI("CreateSessionByCast001 in!");
426 avsessionService_->CreateSessionByCast(0);
427 avsessionService_->ClearSessionForClientDiedNoLock(getpid());
428 #endif
429 SLOGI("CreateSessionByCast001 end!");
430 }
431
MirrorToStreamCast001(const uint8_t * data,size_t size)432 void MirrorToStreamCast001(const uint8_t* data, size_t size)
433 {
434 SLOGI("MirrorToStreamCast001 begin!");
435 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
436 SLOGI("MirrorToStreamCast001 in!");
437 OHOS::AppExecFwk::ElementName elementName;
438 elementName.SetBundleName(g_testAnotherBundleName);
439 elementName.SetAbilityName(g_testAnotherAbilityName);
440 OHOS::sptr<AVSessionItem> avsessionHere_ =
441 avsessionService_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
442 avsessionService_->is2in1_ = true;
443 avsessionService_->MirrorToStreamCast(avsessionHere_);
444 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
445 #endif
446 SLOGI("MirrorToStreamCast001 end!");
447 }
448
MirrorToStreamCast002(const uint8_t * data,size_t size)449 void MirrorToStreamCast002(const uint8_t* data, size_t size)
450 {
451 SLOGI("MirrorToStreamCast002 begin!");
452 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
453 SLOGI("MirrorToStreamCast002 in!");
454 OHOS::AppExecFwk::ElementName elementName;
455 elementName.SetBundleName(g_testAnotherBundleName);
456 elementName.SetAbilityName(g_testAnotherAbilityName);
457 OHOS::sptr<AVSessionItem> avsessionHere_ =
458 avsessionService_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
459 avsessionService_->is2in1_ = false;
460 avsessionService_->MirrorToStreamCast(avsessionHere_);
461 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
462 #endif
463 SLOGI("MirrorToStreamCast002 end!");
464 }
465
MirrorToStreamCast003(const uint8_t * data,size_t size)466 void MirrorToStreamCast003(const uint8_t* data, size_t size)
467 {
468 SLOGI("MirrorToStreamCast003 begin!");
469 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
470 SLOGI("MirrorToStreamCast003 in!");
471 OHOS::AppExecFwk::ElementName elementName;
472 elementName.SetBundleName(g_testAnotherBundleName);
473 elementName.SetAbilityName(g_testAnotherAbilityName);
474 OHOS::sptr<AVSessionItem> avsessionHere_ =
475 avsessionService_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
476 avsessionService_->is2in1_ = true;
477 avsessionService_->MirrorToStreamCast(avsessionHere_);
478 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
479 #endif
480 SLOGI("MirrorToStreamCast003 end!");
481 }
482
RefreshSortFileOnCreateSession001(const uint8_t * data,size_t size)483 void RefreshSortFileOnCreateSession001(const uint8_t* data, size_t size)
484 {
485 SLOGI("RefreshSortFileOnCreateSession001 begin!");
486 OHOS::AppExecFwk::ElementName elementName;
487 elementName.SetBundleName(g_testAnotherBundleName);
488 elementName.SetAbilityName(g_testAnotherAbilityName);
489 OHOS::sptr<AVSessionItem> avsessionHere_ =
490 avsessionService_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
491 avsessionService_->refreshSortFileOnCreateSession(avsessionHere_->GetSessionId(),
492 "audio", elementName);
493 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
494 SLOGI("RefreshSortFileOnCreateSession001 end!");
495 }
496
GetHistoricalAVQueueInfos001(const uint8_t * data,size_t size)497 void GetHistoricalAVQueueInfos001(const uint8_t* data, size_t size)
498 {
499 SLOGI("GetHistoricalAVQueueInfos001 begin!");
500 std::vector<AVQueueInfo> avQueueInfos_;
501 avsessionService_->GetHistoricalAVQueueInfos(0, 0, avQueueInfos_);
502 SLOGI("GetHistoricalAVQueueInfos001 end!");
503 }
504
SaveAvQueueInfo001(const uint8_t * data,size_t size)505 void SaveAvQueueInfo001(const uint8_t* data, size_t size)
506 {
507 SLOGI("SaveAvQueueInfo001 begin!");
508 OHOS::AppExecFwk::ElementName elementName;
509 elementName.SetBundleName(g_testAnotherBundleName);
510 elementName.SetAbilityName(g_testAnotherAbilityName);
511 OHOS::sptr<AVSessionItem> avsessionHere_ =
512 avsessionService_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
513 AVMetaData meta = avsessionHere_->GetMetaData();
514 std::string oldContent;
515 if (!avsessionService_->LoadStringFromFileEx(avsessionService_->GetAVQueueDir(), oldContent)) {
516 SLOGE("SaveAvQueueInfo001 read avqueueinfo fail, Return!");
517 return;
518 }
519 avsessionService_->SaveAvQueueInfo(oldContent, g_testAnotherBundleName, meta,
520 avsessionService_->GetUsersManager().GetCurrentUserId());
521 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
522 SLOGI("SaveAvQueueInfo001 end!");
523 }
524
AddAvQueueInfoToFile001(const uint8_t * data,size_t size)525 void AddAvQueueInfoToFile001(const uint8_t* data, size_t size)
526 {
527 SLOGI("AddAvQueueInfoToFile001 begin!");
528 OHOS::AppExecFwk::ElementName elementName;
529 elementName.SetBundleName(g_testAnotherBundleName);
530 elementName.SetAbilityName(g_testAnotherAbilityName);
531 OHOS::sptr<AVSessionItem> avsessionHere_ =
532 avsessionService_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
533 avsessionService_->AddAvQueueInfoToFile(*avsessionHere_);
534 avsessionService_->HandleSessionRelease(avsessionHere_->GetSessionId());
535 SLOGI("AddAvQueueInfoToFile001 end!");
536 }
537
StartAVPlayback001(const uint8_t * data,size_t size)538 void StartAVPlayback001(const uint8_t* data, size_t size)
539 {
540 SLOGI("StartAVPlayback001 begin!");
541 avsessionService_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME");
542 SLOGI("StartAVPlayback001 end!");
543 }
544
GetSubNode001(const uint8_t * data,size_t size)545 void GetSubNode001(const uint8_t* data, size_t size)
546 {
547 SLOGI("GetSubNode001 begin!");
548 nlohmann::json value;
549 value["bundleName"] = g_testAnotherBundleName;
550 avsessionService_->GetSubNode(value, "FAKE_NAME");
551 SLOGI("GetSubNode001 end!");
552 }
553
DeleteHistoricalRecord001(const uint8_t * data,size_t size)554 void DeleteHistoricalRecord001(const uint8_t* data, size_t size)
555 {
556 SLOGI("DeleteHistoricalRecord001 begin!");
557 avsessionService_->DeleteHistoricalRecord(g_testAnotherBundleName);
558 SLOGI("DeleteHistoricalRecord001 end!");
559 }
560
Dump001(const uint8_t * data,size_t size)561 void Dump001(const uint8_t* data, size_t size)
562 {
563 SLOGI("Dump001 begin!");
564 std::vector<std::u16string> argsList;
565 avsessionService_->Dump(1, argsList);
566 SLOGI("Dump001 end!");
567 }
568
ProcessCastAudioCommand001(const uint8_t * data,size_t size)569 void ProcessCastAudioCommand001(const uint8_t* data, size_t size)
570 {
571 SLOGI("ProcessCastAudioCommand001 begin!");
572 std::string sourceSessionInfo = "SOURCE";
573 std::string sinkSessionInfo = " SINK";
574 avsessionService_->ProcessCastAudioCommand(
575 OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CAST_AUDIO,
576 sourceSessionInfo, sinkSessionInfo);
577 SLOGI("ProcessCastAudioCommand001 end!");
578 }
579
ProcessCastAudioCommand002(const uint8_t * data,size_t size)580 void ProcessCastAudioCommand002(const uint8_t* data, size_t size)
581 {
582 SLOGI("ProcessCastAudioCommand002 begin!");
583 std::string sourceSessionInfo = "SOURCE";
584 std::string sinkSessionInfo = " SINK";
585 avsessionService_->ProcessCastAudioCommand(
586 OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CANCEL_CAST_AUDIO,
587 sourceSessionInfo, sinkSessionInfo);
588 SLOGI("ProcessCastAudioCommand002 end!");
589 }
590
HandleDeviceChange001(const uint8_t * data,size_t size)591 void HandleDeviceChange001(const uint8_t* data, size_t size)
592 {
593 SLOGI("HandleDeviceChange001 begin!");
594 DeviceChangeAction deviceChange;
595 deviceChange.type = static_cast<DeviceChangeType>(0);
596 deviceChange.flag = static_cast<DeviceFlag>(0);
597 avsessionService_->HandleDeviceChange(deviceChange);
598 SLOGI("HandleDeviceChange001 end!");
599 }
600
HandleDeviceChange002(const uint8_t * data,size_t size)601 void HandleDeviceChange002(const uint8_t* data, size_t size)
602 {
603 SLOGI("HandleDeviceChange002 begin!");
604 DeviceChangeAction deviceChange;
605 std::vector<OHOS::sptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
606 OHOS::sptr<AudioDeviceDescriptor> descriptor = new(std::nothrow) AudioDeviceDescriptor();
607 descriptor->deviceType_ = OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
608 deviceChange.type = static_cast<DeviceChangeType>(0);
609 deviceChange.flag = static_cast<DeviceFlag>(0);
610
611 audioDeviceDescriptors.push_back(descriptor);
612 deviceChange.deviceDescriptors = audioDeviceDescriptors;
613 avsessionService_->HandleDeviceChange(deviceChange);
614 SLOGI("HandleDeviceChange002 end!");
615 }
616
AvSessionServiceTest(const uint8_t * data,size_t size)617 void AvSessionServiceTest(const uint8_t* data, size_t size)
618 {
619 if ((data == nullptr) || (size > MAX_CODE_LEN) || (size < MIN_SIZE_NUM)) {
620 return;
621 }
622 if (avsessionService_ == nullptr) {
623 SLOGI("check service null, try create");
624 avsessionService_ = new AVSessionService(AVSESSION_SERVICE_ID);
625 }
626 if (avsessionService_ == nullptr) {
627 SLOGE("service is null, return");
628 return;
629 }
630 AvSessionServiceSystemAbilityTest(data, size, avsessionService_);
631 AvSessionServiceGetAVQueueInfosTest(data, size, avsessionService_);
632 AvSessionServiceGetDescriptorsTest(data, size, avsessionService_);
633 AvSessionServiceAVPlaybackTest(data, size, avsessionService_);
634 AvSessionServiceControllerTest(data, size, avsessionService_);
635 AVSessionServiceSendSystemControlCommandTest(data, size, avsessionService_);
636 AvSessionServiceClientTest(data, size, avsessionService_);
637 AvSessionServiceHandleEventTest(data, size, avsessionService_);
638 AvSessionServiceSuperLauncherTest(data, size, avsessionService_);
639 NotifyDeviceAvailable001(data, size);
640 NotifyMirrorToStreamCast001(data, size);
641 NotifyMirrorToStreamCast002(data, size);
642 NotifyMirrorToStreamCast003(data, size);
643 RefreshFocusSessionSort001(data, size);
644 SelectSessionByUid001(data, size);
645 SelectSessionByUid002(data, size);
646 InitBMS001(data, size);
647 ReleaseCastSession001(data, size);
648 CreateSessionByCast001(data, size);
649 MirrorToStreamCast001(data, size);
650 MirrorToStreamCast002(data, size);
651 MirrorToStreamCast003(data, size);
652 RefreshSortFileOnCreateSession001(data, size);
653 GetHistoricalAVQueueInfos001(data, size);
654 SaveAvQueueInfo001(data, size);
655 AddAvQueueInfoToFile001(data, size);
656 StartAVPlayback001(data, size);
657 GetSubNode001(data, size);
658 DeleteHistoricalRecord001(data, size);
659 Dump001(data, size);
660 ProcessCastAudioCommand001(data, size);
661 ProcessCastAudioCommand002(data, size);
662 HandleDeviceChange001(data, size);
663 HandleDeviceChange002(data, size);
664 }
665
OnRemoteRequestForSessionStub(const uint8_t * data,size_t size)666 int32_t AVSessionServiceStubFuzzer::OnRemoteRequestForSessionStub(const uint8_t* data, size_t size)
667 {
668 if ((data == nullptr) || (size > MAX_CODE_LEN) || (size < MIN_SIZE_NUM)) {
669 return AVSESSION_ERROR;
670 }
671 uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
672 code %= static_cast<uint32_t>(IAVSession::SESSION_CMD_MAX);
673
674 size -= sizeof(uint32_t);
675 std::string sessionId(reinterpret_cast<const char*>(data), size);
676 std::string tag(reinterpret_cast<const char*>(data), size);
677 int32_t type = *reinterpret_cast<const int32_t*>(data);
678 std::string bundleName(reinterpret_cast<const char*>(data), size);
679 std::string abilityName(reinterpret_cast<const char*>(data), size);
680 bool isThirdPartyApp = *(reinterpret_cast<const int32_t *>(data));
681 AVSessionDescriptor descriptor;
682 AppExecFwk::ElementName elementName;
683 elementName.SetBundleName(bundleName);
684 elementName.SetAbilityName(abilityName);
685 descriptor.sessionId_ = sessionId;
686 descriptor.sessionTag_ = tag;
687 descriptor.sessionType_ = type;
688 descriptor.elementName_ = elementName;
689 descriptor.isThirdPartyApp_ = isThirdPartyApp;
690 sptr<AVSessionItem> avSessionItem = new(std::nothrow) AVSessionItem(descriptor);
691 if (!avSessionItem) {
692 SLOGI("testAVSession item is null");
693 return AVSESSION_ERROR;
694 }
695 sptr<IRemoteObject> remoteObject = nullptr;
696 std::shared_ptr<AVSessionProxyTestOnServiceFuzzer> avSessionProxy =
697 std::make_shared<AVSessionProxyTestOnServiceFuzzer>(remoteObject);
698 MessageParcel dataMessageParcelForSession;
699 if (!dataMessageParcelForSession.WriteInterfaceToken(avSessionProxy->GetDescriptor())) {
700 SLOGE("testAVSession item write interface token error");
701 return AVSESSION_ERROR;
702 }
703 dataMessageParcelForSession.WriteBuffer(data + sizeof(uint32_t), size);
704 dataMessageParcelForSession.RewindRead(0);
705 MessageParcel replyForSession;
706 MessageOption optionForSession;
707 int ret = avSessionItem->OnRemoteRequest(code, dataMessageParcelForSession,
708 replyForSession, optionForSession);
709 return ret;
710 }
711
OnRemoteRequest(const uint8_t * data,size_t size)712 int32_t AVSessionServiceStubFuzzer::OnRemoteRequest(const uint8_t* data, size_t size)
713 {
714 if ((data == nullptr) || (size > MAX_CODE_LEN) || (size < MIN_SIZE_NUM)) {
715 return AVSESSION_ERROR;
716 }
717 uint32_t code = *(reinterpret_cast<const uint32_t*>(data));
718 code %= static_cast<uint32_t>(AvsessionSeviceInterfaceCode::SERVICE_CMD_MAX);
719
720 size -= sizeof(uint32_t);
721 if (avsessionService_ == nullptr) {
722 SLOGI("check service null, try create");
723 avsessionService_ = new AVSessionService(AVSESSION_SERVICE_ID);
724 }
725 if (avsessionService_ == nullptr) {
726 SLOGE("service is null, return");
727 return AVSESSION_ERROR;
728 }
729 MessageParcel dataMessageParcel;
730 if (!dataMessageParcel.WriteInterfaceToken(avsessionService_->GetDescriptor())) {
731 return AVSESSION_ERROR;
732 }
733 dataMessageParcel.WriteBuffer(data + sizeof(uint32_t), size);
734 dataMessageParcel.RewindRead(0);
735 MessageParcel reply;
736 MessageOption option;
737 int32_t ret = avsessionService_->OnRemoteRequest(code, dataMessageParcel, reply, option);
738 return ret;
739 }
740
AvSessionServiceStubRemoteRequestTest(const uint8_t * data,size_t size)741 int32_t AvSessionServiceStubRemoteRequestTest(const uint8_t* data, size_t size)
742 {
743 auto serviceStub = std::make_unique<AVSessionServiceStubFuzzer>();
744 if (serviceStub == nullptr) {
745 return 0;
746 }
747 serviceStub->OnRemoteRequest(data, size);
748 serviceStub->OnRemoteRequestForSessionStub(data, size);
749 return 0;
750 }
751
752 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)753 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
754 {
755 /* Run your code on data */
756 AvSessionServiceCloseTest(data, size);
757 AvSessionServiceExternalCallTest(data, size);
758 AvSessionServiceTest(data, size);
759 AvSessionServiceStubRemoteRequestTest(data, size);
760 return 0;
761 }
762 } // namespace AVSession
763 } // namespace OHOS
764