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