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 "workschedulerstartwork_fuzzer.h"
17
18 #include "iwork_sched_service.h"
19 #include "work_scheduler_service.h"
20 #include "work_sched_common.h"
21 #include "work_condition.h"
22 #include "work_sched_errors.h"
23 #include "scheduler_bg_task_subscriber.h"
24 #include "work_bundle_group_change_callback.h"
25 #include "work_conn_manager.h"
26 #include "conditions/battery_status_listener.h"
27 #include "conditions/charger_listener.h"
28 #include "conditions/battery_level_listener.h"
29 #include "common_event_manager.h"
30 #include "common_event_support.h"
31 #include "battery_info.h"
32 #include "conditions/screen_listener.h"
33 #include "work_queue_manager.h"
34 #include "conditions/network_listener.h"
35 #include "conditions/storage_listener.h"
36 #include "net_supplier_info.h"
37 #include "work_standby_state_change_callback.h"
38
DecStrongRef(void const * obj)39 void OHOS::RefBase::DecStrongRef(void const* obj) {}
40
41 namespace OHOS {
42 namespace WorkScheduler {
43 const std::u16string WORK_SCHEDULER_STUB_TOKEN = u"ohos.workscheduler.iworkschedservice";
44 static std::shared_ptr<WorkSchedulerService> workSchedulerService_;
45 const uint32_t allowType = 8;
46 const int32_t DEFAULT_VALUE = -1;
47 const int32_t BEARER_CELLULAR = 0;
48 const int32_t BEARER_WIFI = 1;
49 const int32_t BEARER_BLUETOOTH = 2;
50 const int32_t BEARER_ETHERNET = 3;
51 const int32_t BEARER_WIFI_AWARE = 5;
52
GetUidByBundleName(const std::string & bundleName,int32_t & uid)53 bool WorkSchedulerService::GetUidByBundleName(const std::string &bundleName, int32_t &uid)
54 {
55 return true;
56 }
57
CreateWorkInfo()58 WorkInfo CreateWorkInfo()
59 {
60 int32_t uid = 20008;
61 int32_t workId = 10000;
62 uint32_t timeInterval = 20 * 60 * 1000;
63 int32_t battery = 20;
64 WorkInfo workInfo = WorkInfo();
65 workInfo.SetWorkId(workId);
66 workInfo.SetElement("bundleName", "MainWorkSchedulerAbility");
67 workInfo.RequestPersisted(true);
68 workInfo.RequestRepeatCycle(timeInterval);
69 workInfo.RefreshUid(uid);
70 workInfo.RequestDeepIdle(true);
71 workInfo.RequestBatteryStatus(WorkCondition::BatteryStatus::BATTERY_STATUS_LOW);
72 workInfo.RequestBatteryLevel(battery);
73 workInfo.RequestChargerType(true, WorkCondition::Charger::CHARGING_PLUGGED_AC);
74 workInfo.RequestStorageLevel(WorkCondition::Storage::STORAGE_LEVEL_LOW);
75 workInfo.RequestNetworkType(WorkCondition::Network::NETWORK_TYPE_WIFI);
76 return workInfo;
77 }
78
OnStorageChange()79 void OnStorageChange()
80 {
81 std::vector<std::string> argsInStr;
82 std::string result;
83
84 argsInStr.clear();
85 result.clear();
86 argsInStr.push_back("-d");
87 argsInStr.push_back("storage");
88 argsInStr.push_back("invalid");
89 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
90
91 argsInStr.clear();
92 result.clear();
93 argsInStr.push_back("-d");
94 argsInStr.push_back("storage");
95 argsInStr.push_back("ok");
96 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
97
98 argsInStr.clear();
99 result.clear();
100 argsInStr.push_back("-d");
101 argsInStr.push_back("storage");
102 argsInStr.push_back("low");
103 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
104 }
105
OnNetworkChange()106 void OnNetworkChange()
107 {
108 std::vector<std::string> argsInStr;
109 std::string result;
110
111 argsInStr.clear();
112 result.clear();
113 argsInStr.push_back("-d");
114 argsInStr.push_back("network");
115 argsInStr.push_back("invalid");
116 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
117
118 argsInStr.clear();
119 result.clear();
120 argsInStr.push_back("-d");
121 argsInStr.push_back("network");
122 argsInStr.push_back("disconnect");
123 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
124
125 argsInStr.clear();
126 result.clear();
127 argsInStr.push_back("-d");
128 argsInStr.push_back("network");
129 argsInStr.push_back("wifi");
130 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
131 }
132
OnChargingChange()133 void OnChargingChange()
134 {
135 std::vector<std::string> argsInStr;
136 std::string result;
137
138 argsInStr.clear();
139 result.clear();
140 argsInStr.push_back("-d");
141 argsInStr.push_back("charging");
142 argsInStr.push_back("none");
143 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
144
145 argsInStr.clear();
146 result.clear();
147 argsInStr.push_back("-d");
148 argsInStr.push_back("charging");
149 argsInStr.push_back("usb");
150 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
151
152 argsInStr.clear();
153 result.clear();
154 argsInStr.push_back("-d");
155 argsInStr.push_back("charging");
156 argsInStr.push_back("wireless");
157 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
158
159 argsInStr.clear();
160 result.clear();
161 argsInStr.push_back("-d");
162 argsInStr.push_back("charging");
163 argsInStr.push_back("ac");
164 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
165 }
166
OnBatteryStatusChange()167 void OnBatteryStatusChange()
168 {
169 std::vector<std::string> argsInStr;
170 std::string result;
171
172 argsInStr.clear();
173 result.clear();
174 argsInStr.push_back("-d");
175 argsInStr.push_back("batteryStatus");
176 argsInStr.push_back("ok");
177 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
178
179 argsInStr.clear();
180 result.clear();
181 argsInStr.push_back("-d");
182 argsInStr.push_back("batteryStatus");
183 argsInStr.push_back("low");
184 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
185 }
186
OnTimerChange()187 void OnTimerChange()
188 {
189 std::vector<std::string> argsInStr;
190 std::string result;
191
192 argsInStr.clear();
193 result.clear();
194 argsInStr.push_back("-repeat_time_min");
195 argsInStr.push_back("10000");
196 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
197
198 argsInStr.clear();
199 result.clear();
200 argsInStr.push_back("-watchdog_time");
201 argsInStr.push_back("5000");
202 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
203
204 argsInStr.clear();
205 result.clear();
206 argsInStr.push_back("-min_interval");
207 argsInStr.push_back("20000");
208 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
209 }
210
OnBatteryLevelListener()211 void OnBatteryLevelListener()
212 {
213 int32_t capacity = 20;
214 BatteryLevelListener batteryLevelListener(workSchedulerService_->workQueueManager_, workSchedulerService_);
215 batteryLevelListener.Start();
216
217 EventFwk::CommonEventData data;
218 batteryLevelListener.commonEventSubscriber->OnReceiveEvent(data);
219
220 EventFwk::Want want;
221 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
222 data.SetWant(want);
223 batteryLevelListener.commonEventSubscriber->OnReceiveEvent(data);
224
225 want.SetParam(PowerMgr::BatteryInfo::COMMON_EVENT_KEY_CAPACITY, capacity);
226 data.SetWant(want);
227 batteryLevelListener.commonEventSubscriber->OnReceiveEvent(data);
228 batteryLevelListener.Stop();
229 }
230
OnBatteryStatusListener()231 void OnBatteryStatusListener()
232 {
233 BatteryStatusListener batteryStatusListener(workSchedulerService_->workQueueManager_);
234
235 batteryStatusListener.Start();
236
237 EventFwk::CommonEventData data;
238 batteryStatusListener.commonEventSubscriber->OnReceiveEvent(data);
239
240 EventFwk::Want want;
241
242 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_OKAY);
243 data.SetWant(want);
244 batteryStatusListener.commonEventSubscriber->OnReceiveEvent(data);
245
246 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_LOW);
247 data.SetWant(want);
248 batteryStatusListener.commonEventSubscriber->OnReceiveEvent(data);
249 batteryStatusListener.Stop();
250 }
251
OnChargerListener()252 void OnChargerListener()
253 {
254 ChargerListener chargerListener(workSchedulerService_->workQueueManager_);
255
256 chargerListener.Start();
257
258 EventFwk::CommonEventData data;
259 chargerListener.commonEventSubscriber->OnReceiveEvent(data);
260
261 EventFwk::Want want;
262 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
263 data.SetWant(want);
264 data.SetCode(static_cast<uint32_t>(PowerMgr::BatteryPluggedType::PLUGGED_TYPE_NONE));
265 chargerListener.commonEventSubscriber->OnReceiveEvent(data);
266
267 data.SetCode(static_cast<uint32_t>(PowerMgr::BatteryPluggedType::PLUGGED_TYPE_USB));
268 chargerListener.commonEventSubscriber->OnReceiveEvent(data);
269
270 data.SetCode(static_cast<uint32_t>(PowerMgr::BatteryPluggedType::PLUGGED_TYPE_WIRELESS));
271 chargerListener.commonEventSubscriber->OnReceiveEvent(data);
272
273 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED);
274 data.SetWant(want);
275 data.SetCode(static_cast<uint32_t>(PowerMgr::BatteryPluggedType::PLUGGED_TYPE_AC));
276 chargerListener.commonEventSubscriber->OnReceiveEvent(data);
277 chargerListener.Stop();
278 }
279
OnScreenListener()280 void OnScreenListener()
281 {
282 ScreenListener screenListener(workSchedulerService_->workQueueManager_, workSchedulerService_);
283
284 screenListener.Start();
285 EventFwk::CommonEventData data;
286 screenListener.commonEventSubscriber->OnReceiveEvent(data);
287
288 EventFwk::Want want;
289 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF);
290 data.SetWant(want);
291 screenListener.commonEventSubscriber->OnReceiveEvent(data);
292
293 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_BATTERY_CHANGED);
294 data.SetWant(want);
295 screenListener.commonEventSubscriber->OnReceiveEvent(data);
296 screenListener.Stop();
297 }
298
OnStorageListener()299 void OnStorageListener()
300 {
301 StorageListener storageListener(workSchedulerService_->workQueueManager_);
302 storageListener.Start();
303
304 EventFwk::CommonEventData data;
305 EventFwk::Want want;
306 storageListener.commonEventSubscriber->OnReceiveEvent(data);
307
308 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DEVICE_STORAGE_LOW);
309 data.SetWant(want);
310 storageListener.commonEventSubscriber->OnReceiveEvent(data);
311
312 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_DEVICE_STORAGE_OK);
313 data.SetWant(want);
314 storageListener.commonEventSubscriber->OnReceiveEvent(data);
315 storageListener.Stop();
316 }
317
OnNetworkListener()318 void OnNetworkListener()
319 {
320 NetworkListener networkListener(workSchedulerService_->workQueueManager_);
321 networkListener.Start();
322 EventFwk::CommonEventData data;
323 EventFwk::Want want;
324 data.SetCode(NetManagerStandard::NetConnState::NET_CONN_STATE_CONNECTED);
325 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE);
326 data.SetWant(want);
327 EventFwk::CommonEventManager::PublishCommonEvent(data);
328 networkListener.commonEventSubscriber->OnReceiveEvent(data);
329
330 want.SetParam("NetType", BEARER_CELLULAR);
331 data.SetWant(want);
332 EventFwk::CommonEventManager::PublishCommonEvent(data);
333 networkListener.commonEventSubscriber->OnReceiveEvent(data);
334
335 want.SetParam("NetType", BEARER_WIFI);
336 data.SetWant(want);
337 EventFwk::CommonEventManager::PublishCommonEvent(data);
338 networkListener.commonEventSubscriber->OnReceiveEvent(data);
339
340 want.SetParam("NetType", BEARER_BLUETOOTH);
341 data.SetWant(want);
342 EventFwk::CommonEventManager::PublishCommonEvent(data);
343 networkListener.commonEventSubscriber->OnReceiveEvent(data);
344
345 want.SetParam("NetType", BEARER_ETHERNET);
346 data.SetWant(want);
347 EventFwk::CommonEventManager::PublishCommonEvent(data);
348 networkListener.commonEventSubscriber->OnReceiveEvent(data);
349
350 want.SetParam("NetType", BEARER_WIFI_AWARE);
351 data.SetWant(want);
352 EventFwk::CommonEventManager::PublishCommonEvent(data);
353 networkListener.commonEventSubscriber->OnReceiveEvent(data);
354
355 want.SetParam("NetType", DEFAULT_VALUE);
356 data.SetWant(want);
357 EventFwk::CommonEventManager::PublishCommonEvent(data);
358 networkListener.commonEventSubscriber->OnReceiveEvent(data);
359 networkListener.Stop();
360 }
361
OnReceiveEvent()362 void OnReceiveEvent()
363 {
364 OnBatteryLevelListener();
365 OnBatteryStatusListener();
366 OnChargerListener();
367 OnScreenListener();
368 OnStorageListener();
369 OnNetworkListener();
370 }
371
TriggerWork(WorkInfo & workInfo)372 void TriggerWork(WorkInfo &workInfo)
373 {
374 OnStorageChange();
375 OnNetworkChange();
376 OnChargingChange();
377 OnBatteryStatusChange();
378 OnTimerChange();
379
380 OnReceiveEvent();
381
382 std::vector<std::string> argsInStr;
383 std::string result;
384 argsInStr.clear();
385 result.clear();
386 argsInStr.push_back("-k");
387 argsInStr.push_back("settings.power.suspend_sources");
388 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
389
390 argsInStr.clear();
391 result.clear();
392 argsInStr.push_back("-t");
393 argsInStr.push_back(workInfo.GetBundleName());
394 argsInStr.push_back(workInfo.GetAbilityName());
395 workSchedulerService_->DumpProcessForEngMode(argsInStr, result);
396
397 workSchedulerService_->PauseRunningWorks(workInfo.GetUid());
398 workSchedulerService_->ResumePausedWorks(workInfo.GetUid());
399
400 std::shared_ptr<WorkConnManager> workConnManager = std::make_shared<WorkConnManager>();
401 std::shared_ptr<WorkStatus> workStatus = std::make_shared<WorkStatus>(workInfo, workInfo.GetUid());
402 workConnManager->WriteStartWorkEvent(workStatus);
403 }
404
OnProcEfficiencyResourcesChange()405 void OnProcEfficiencyResourcesChange()
406 {
407 SchedulerBgTaskSubscriber subscriber;
408 subscriber.OnProcEfficiencyResourcesApply(nullptr);
409 subscriber.OnProcEfficiencyResourcesReset(nullptr);
410 subscriber.OnAppEfficiencyResourcesApply(nullptr);
411 subscriber.OnAppEfficiencyResourcesReset(nullptr);
412
413 auto resourceInfo = std::make_shared<BackgroundTaskMgr::ResourceCallbackInfo>(0, 0, 0xFFFF, "name");
414 subscriber.OnProcEfficiencyResourcesApply(resourceInfo);
415 subscriber.OnProcEfficiencyResourcesReset(resourceInfo);
416 subscriber.OnAppEfficiencyResourcesApply(resourceInfo);
417 subscriber.OnAppEfficiencyResourcesReset(resourceInfo);
418 }
419
OnWorkStandbyStateChange()420 void OnWorkStandbyStateChange()
421 {
422 workSchedulerService_->standbyStateObserver_->OnDeviceIdleMode(true, false);
423 workSchedulerService_->standbyStateObserver_->OnDeviceIdleMode(true, true);
424 workSchedulerService_->standbyStateObserver_->OnDeviceIdleMode(false, true);
425 workSchedulerService_->standbyStateObserver_->OnAllowListChanged(0, "bundlename", allowType, true);
426 }
427
OnWorkBundleGroupChange()428 void OnWorkBundleGroupChange()
429 {
430 int32_t value = 2;
431 OHOS::DeviceUsageStats::AppGroupCallbackInfo appGroupCallbackInfo1(0, 1, value, 0, "bundlename");
432 workSchedulerService_->groupObserver_->OnAppGroupChanged(appGroupCallbackInfo1);
433 OHOS::DeviceUsageStats::AppGroupCallbackInfo appGroupCallbackInfo2(0, value, 1, 0, "bundlename");
434 workSchedulerService_->groupObserver_->OnAppGroupChanged(appGroupCallbackInfo2);
435 }
436
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)437 bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
438 {
439 MessageParcel dataMessageParcel;
440 dataMessageParcel.WriteInterfaceToken(WORK_SCHEDULER_STUB_TOKEN);
441 dataMessageParcel.WriteBuffer(data, size);
442 dataMessageParcel.RewindRead(0);
443 MessageParcel reply;
444 MessageOption option;
445 workSchedulerService_ = DelayedSingleton<WorkSchedulerService>::GetInstance();
446 uint32_t code = static_cast<int32_t>(IWorkSchedServiceIpcCode::COMMAND_START_WORK);
447
448 workSchedulerService_->OnStart();
449 workSchedulerService_->InitBgTaskSubscriber();
450 if (!workSchedulerService_->ready_) {
451 workSchedulerService_->ready_ = true;
452 }
453 if (workSchedulerService_->workQueueManager_ == nullptr) {
454 workSchedulerService_->workQueueManager_ = std::make_shared<WorkQueueManager>(workSchedulerService_);
455 }
456 if (workSchedulerService_->standbyStateObserver_ == nullptr) {
457 workSchedulerService_->standbyStateObserver_ =
458 new (std::nothrow) WorkStandbyStateChangeCallback(workSchedulerService_->workQueueManager_);
459 }
460 if (workSchedulerService_->groupObserver_ == nullptr) {
461 workSchedulerService_->groupObserver_ =
462 new (std::nothrow) WorkBundleGroupChangeCallback(workSchedulerService_->workQueueManager_);
463 }
464 OnProcEfficiencyResourcesChange();
465 OnWorkStandbyStateChange();
466 OnWorkBundleGroupChange();
467 if (workSchedulerService_->checkBundle_) {
468 workSchedulerService_->checkBundle_ = false;
469 }
470
471 WorkInfo workInfo = CreateWorkInfo();
472 if (!dataMessageParcel.WriteParcelable(&workInfo)) {
473 return false;
474 }
475 workSchedulerService_->OnRemoteRequest(code, dataMessageParcel, reply, option);
476 workSchedulerService_->TriggerWorkIfConditionReady();
477 TriggerWork(workInfo);
478 workSchedulerService_->StopAndClearWorks();
479 workSchedulerService_->OnStop();
480 return true;
481 }
482 } // WorkScheduler
483 } // OHOS
484
485 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)486 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
487 {
488 /* Run your code on data */
489 OHOS::WorkScheduler::DoSomethingInterestingWithMyAPI(data, size);
490 return 0;
491 }