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