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 #include "statemanageradapter_fuzzer.h"
16 #include "securec.h"
17 #include "state_manager_adapter.h"
18 #include "common_event_support.h"
19 #include "standby_service_impl.h"
20 #include "working_state.h"
21 
22 
23 namespace OHOS {
24 namespace DevStandbyMgr {
25     constexpr size_t U32_AT_SIZE = 4;
26     const std::string DUMP_D = "-D";
27     const std::string DUMP_E = "-E";
28     const std::string DUMP_S = "-S";
29     const std::string DUMP_HALF_HOUR = "--halfhour";
30     const std::string DUMP_MOTION = "--motion";
31     const std::string DUMP_BLOCKED = "--blocked";
32     const std::string DUMP_WORK = "working";
33     const std::string ARGS_TEST_MODEM = "-M";
34     const std::string LID_OPEN = "LID_OPEN";
35     const std::string LID_CLOSE = "LID_CLOSE";
36     const std::string STR_TEST = "test";
37     const std::string TEST_TRUE = "true";
38     const std::string TEST_FALSE = "false";
39     const std::string TEST_BLANK = "";
40     bool g_initFlag = false;
41     const uint8_t *g_baseFuzzData = nullptr;
42     size_t g_baseFuzzSize = 0;
43     size_t g_baseFuzzPos;
44 
GetData()45     template <class T> T GetData()
46     {
47         T object{};
48         size_t objectSize = sizeof(object);
49         if (g_baseFuzzData == nullptr || objectSize > g_baseFuzzSize - g_baseFuzzPos) {
50             return object;
51         }
52         errno_t ret = memcpy_s(&object, objectSize, g_baseFuzzData + g_baseFuzzPos, objectSize);
53         if (ret != EOK) {
54             return {};
55         }
56         g_baseFuzzPos += objectSize;
57         return object;
58     }
59 
PreciseCoverageHandleEvent()60     void PreciseCoverageHandleEvent()
61     {
62         std::shared_ptr<IStateManagerAdapter> stateManager =
63             StandbyServiceImpl::GetInstance()->GetStateManager();
64         StandbyMessage standbyMessageCase1{StandbyMessageType::COMMON_EVENT,
65             EventFwk::CommonEventSupport::COMMON_EVENT_USB_DEVICE_ATTACHED};
66         StandbyMessage standbyMessageCase2{StandbyMessageType::RES_CTRL_CONDITION_CHANGED,
67             EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON};
68         StandbyMessage standbyMessageCase3{StandbyMessageType::RES_CTRL_CONDITION_CHANGED,
69             EventFwk::CommonEventSupport::COMMON_EVENT_CHARGING};
70         StandbyMessage standbyMessageCase4{StandbyMessageType::RES_CTRL_CONDITION_CHANGED,
71             EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF};
72         StandbyMessage standbyMessageCase5{StandbyMessageType::RES_CTRL_CONDITION_CHANGED,
73             EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING};
74         StandbyMessage standbyMessageCase6{StandbyMessageType::RES_CTRL_CONDITION_CHANGED,
75             EventFwk::CommonEventSupport::COMMON_EVENT_USB_DEVICE_DETACHED};
76         StandbyMessage standbyMessageCase7{StandbyMessageType::RES_CTRL_CONDITION_CHANGED, LID_OPEN};
77         StandbyMessage standbyMessageCase8{StandbyMessageType::RES_CTRL_CONDITION_CHANGED, LID_CLOSE};
78         StandbyMessage standbyMessageCase9{StandbyMessageType::COMMON_EVENT,
79             EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF};
80         StandbyMessage standbyMessageCase10{StandbyMessageType::COMMON_EVENT,
81             EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON};
82         StandbyMessage standbyMessageCase11{StandbyMessageType::COMMON_EVENT,
83             EventFwk::CommonEventSupport::COMMON_EVENT_DISCHARGING};
84         StandbyMessage standbyMessageCase12{StandbyMessageType::COMMON_EVENT,
85             EventFwk::CommonEventSupport::COMMON_EVENT_USB_DEVICE_DETACHED};
86         StandbyMessage standbyMessageCase13{StandbyMessageType::COMMON_EVENT, STR_TEST};
87         StandbyMessage standbyMessageCase14{StandbyMessageType::COMMON_EVENT, LID_OPEN};
88         StandbyMessage standbyMessageCase15{StandbyMessageType::COMMON_EVENT, LID_CLOSE};
89         stateManager->HandleEvent(standbyMessageCase1);
90         stateManager->HandleEvent(standbyMessageCase2);
91         stateManager->HandleEvent(standbyMessageCase3);
92         stateManager->HandleEvent(standbyMessageCase4);
93         stateManager->HandleEvent(standbyMessageCase5);
94         stateManager->HandleEvent(standbyMessageCase6);
95         stateManager->HandleEvent(standbyMessageCase7);
96         stateManager->HandleEvent(standbyMessageCase8);
97         stateManager->HandleEvent(standbyMessageCase9);
98         stateManager->HandleEvent(standbyMessageCase10);
99         stateManager->HandleEvent(standbyMessageCase11);
100         stateManager->HandleEvent(standbyMessageCase12);
101         stateManager->HandleEvent(standbyMessageCase13);
102         stateManager->HandleEvent(standbyMessageCase14);
103         stateManager->HandleEvent(standbyMessageCase15);
104     }
105 
PreciseCoverage()106     void PreciseCoverage()
107     {
108         if (g_initFlag) {
109             return;
110         }
111         g_initFlag = true;
112         StandbyServiceImpl::GetInstance()->Init();
113         std::shared_ptr<IStateManagerAdapter> stateManager =
114             StandbyServiceImpl::GetInstance()->GetStateManager();
115         stateManager->isEvalution_ = false;
116         stateManager->StopEvalution();
117         stateManager->Init();
118         PreciseCoverageHandleEvent();
119         const std::vector<std::string> argsInStr01 = {DUMP_D, DUMP_RESET_STATE};
120         const std::vector<std::string> argsInStr02 = {DUMP_E};
121         const std::vector<std::string> argsInStr03 = {DUMP_E, TEST_BLANK, TEST_FALSE};
122         const std::vector<std::string> argsInStr04 = {DUMP_E, DUMP_WORK, TEST_TRUE};
123         const std::vector<std::string> argsInStr05 = {DUMP_S, DUMP_MOTION};
124         const std::vector<std::string> argsInStr06 = {DUMP_S, DUMP_BLOCKED};
125         const std::vector<std::string> argsInStr07 = {DUMP_S, DUMP_HALF_HOUR};
126         std::string result = "";
127         stateManager->ShellDump(argsInStr01, result);
128         stateManager->ShellDump(argsInStr02, result);
129         stateManager->ShellDump(argsInStr03, result);
130         stateManager->ShellDump(argsInStr04, result);
131         stateManager->ShellDump(argsInStr05, result);
132         stateManager->ShellDump(argsInStr06, result);
133         stateManager->ShellDump(argsInStr07, result);
134         stateManager->GetCurState();
135         stateManager->GetPreState();
136         std::shared_ptr<BaseState> workingStatePrt_ = std::make_shared<WorkingState>(StandbyState::WORKING, 0,
137             StandbyServiceImpl::GetInstance()->GetStateManager(), StandbyServiceImpl::GetInstance()->GetHandler());
138         workingStatePrt_->CheckTransitionValid(StandbyState::MAINTENANCE);
139         workingStatePrt_->EndEvalCurrentState(true);
140         workingStatePrt_->EndEvalCurrentState(false);
141         stateManager->OnScreenOffHalfHour(false, true);
142         stateManager->isEvalution_ = true;
143         stateManager->EndEvalCurrentState(false);
144         stateManager->isEvalution_ = false;
145         stateManager->EndEvalCurrentState(true);
146         stateManager->UnInit();
147         stateManager->Init();
148     }
149 
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)150     bool DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
151     {
152         g_baseFuzzData = data;
153         g_baseFuzzSize = size;
154         g_baseFuzzPos = 0;
155         uint32_t  uintParam = GetData<uint32_t>();
156         std::string strParam((const char *) g_baseFuzzData + g_baseFuzzPos, g_baseFuzzSize - g_baseFuzzPos);
157         StandbyMessage standbyMessage{uintParam, strParam};
158         PreciseCoverage();
159         StandbyServiceImpl::GetInstance()->GetStateManager()->HandleEvent(standbyMessage);
160         return true;
161     }
162 } // namespace DevStandbyMgr
163 } // namespace OHOS
164 
165 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)166 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
167 {
168     /* Run your code on data */
169     if (data == nullptr) {
170         return 0;
171     }
172 
173     if (size < OHOS::DevStandbyMgr::U32_AT_SIZE) {
174         return 0;
175     }
176     OHOS::DevStandbyMgr::DoSomethingInterestingWithMyAPI(data, size);
177     return 0;
178 }
179