1 /*
2 * Copyright (c) 2021 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 "display_fuzzer.h"
17
18 #include <iostream>
19 #include <cstddef>
20 #include <cstdint>
21 #include <cstdlib>
22 #include <random>
23 #include <ctime>
24 #include "securec.h"
25 #include "display_power_mgr_client.h"
26
27 using namespace OHOS::DisplayPowerMgr;
28 using namespace std;
29
30 namespace {
31 auto& g_displayMgrClient = OHOS::DisplayPowerMgr::DisplayPowerMgrClient::GetInstance();
32 constexpr size_t DATANUM = 4;
33 constexpr int32_t SIZE = 1;
34 constexpr int32_t INDEX_0 = 0;
35 }
36
SetDisplayState(const uint8_t * data)37 static void SetDisplayState(const uint8_t* data)
38 {
39 int32_t type[1];
40 int32_t idSize = 4;
41 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
42 return;
43 }
44 g_displayMgrClient.SetDisplayState(static_cast<DisplayState>(type[0]));
45 }
46
GetDisplayState(const uint8_t * data)47 static void GetDisplayState(const uint8_t* data)
48 {
49 int32_t type[1];
50 int32_t idSize = 4;
51 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
52 return;
53 }
54
55 g_displayMgrClient.GetDisplayState();
56 }
57
GetDisplayIds(const uint8_t * data)58 static void GetDisplayIds(const uint8_t* data)
59 {
60 int32_t type[1];
61 int32_t idSize = 4;
62 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
63 return;
64 }
65
66 g_displayMgrClient.GetDisplayIds();
67 }
68
GetMainDisplayId(const uint8_t * data)69 static void GetMainDisplayId(const uint8_t* data)
70 {
71 int32_t type[1];
72 int32_t idSize = 4;
73 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
74 return;
75 }
76
77 g_displayMgrClient.GetMainDisplayId();
78 }
79
SetBrightness(const uint8_t * data)80 static void SetBrightness(const uint8_t* data)
81 {
82 int32_t type[1];
83 int32_t idSize = 4;
84 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
85 return;
86 }
87
88 g_displayMgrClient.SetBrightness(type[0]);
89 }
90
AdjustBrightness(const uint8_t * data,size_t size)91 static void AdjustBrightness(const uint8_t* data, size_t size)
92 {
93 int32_t type[1];
94 int32_t duration[1];
95 size_t idSize = 4;
96 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
97 return;
98 }
99 if (size <= (idSize + DATANUM) || (memcpy_s(duration, sizeof(duration), (data + DATANUM), idSize) != EOK)) {
100 duration[INDEX_0] = type[INDEX_0];
101 }
102
103 g_displayMgrClient.AdjustBrightness(type[0], duration[0]);
104 }
105
AutoAdjustBrightness(const uint8_t * data)106 static void AutoAdjustBrightness(const uint8_t* data)
107 {
108 int32_t type[1];
109 int32_t idSize = 4;
110 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
111 return;
112 }
113
114 g_displayMgrClient.AutoAdjustBrightness(type[0]);
115 }
116
RegisterCallback(const uint8_t * data)117 static void RegisterCallback(const uint8_t* data)
118 {
119 static OHOS::sptr<OHOS::DisplayPowerMgr::IDisplayPowerCallback> callback;
120 int32_t idSize = 4;
121 if ((memcpy_s(callback, sizeof(callback), data, idSize)) != EOK) {
122 return;
123 }
124
125 g_displayMgrClient.RegisterCallback(callback);
126 }
127
OverrideBrightness(const uint8_t * data)128 static void OverrideBrightness(const uint8_t* data)
129 {
130 uint32_t type[1];
131 int32_t idSize = 4;
132 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
133 return;
134 }
135 g_displayMgrClient.OverrideBrightness(type[0]);
136 }
137
RestoreBrightness(const uint8_t * data)138 static void RestoreBrightness(const uint8_t* data)
139 {
140 uint32_t type[1];
141 int32_t idSize = 4;
142 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
143 return;
144 }
145 g_displayMgrClient.RestoreBrightness(type[0]);
146 }
147
BoostBrightness(const uint8_t * data)148 static void BoostBrightness(const uint8_t* data)
149 {
150 uint32_t type[1];
151 int32_t idSize = 4;
152 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
153 return;
154 }
155 g_displayMgrClient.BoostBrightness(type[0]);
156 }
157
CancelBoostBrightness(const uint8_t * data)158 static void CancelBoostBrightness(const uint8_t* data)
159 {
160 uint32_t type[1];
161 int32_t idSize = 4;
162 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
163 return;
164 }
165 g_displayMgrClient.CancelBoostBrightness(type[0]);
166 }
167
DiscountBrightness(const uint8_t * data)168 static void DiscountBrightness(const uint8_t* data)
169 {
170 double type[1];
171 int32_t idSize = 4;
172 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
173 return;
174 }
175
176 g_displayMgrClient.DiscountBrightness(type[0]);
177 }
178
GetBrightness(const uint8_t * data)179 static void GetBrightness(const uint8_t* data)
180 {
181 uint32_t type[SIZE];
182 int32_t idSize = 4;
183 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
184 return;
185 }
186 g_displayMgrClient.GetBrightness(type[INDEX_0]);
187 }
188
GetDeviceBrightness(const uint8_t * data)189 static void GetDeviceBrightness(const uint8_t* data)
190 {
191 uint32_t type[SIZE];
192 int32_t idSize = 4;
193 if ((memcpy_s(type, sizeof(type), data, idSize)) != EOK) {
194 return;
195 }
196 g_displayMgrClient.GetDeviceBrightness(type[INDEX_0]);
197 }
198
199 namespace OHOS {
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)200 bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size)
201 {
202 int32_t idSize = 4;
203 int32_t cond[1];
204 if (static_cast<int32_t>(size) > idSize) {
205 if ((memcpy_s(cond, sizeof(cond), data, idSize)) != EOK) {
206 return false;
207 }
208 std::random_device rd;
209 std::default_random_engine engine(rd());
210 std::uniform_int_distribution<int32_t> randomNum(static_cast<int32_t>(ApiNumber::NUM_ZERO),
211 static_cast<int32_t>(ApiNumber::NUM_END) - 1);
212 int32_t number = randomNum(engine);
213
214 switch (static_cast<ApiNumber>(number)) {
215 case ApiNumber::NUM_ZERO:
216 SetDisplayState(data);
217 break;
218 case ApiNumber::NUM_ONE:
219 GetDisplayState(data);
220 break;
221 case ApiNumber::NUM_TWO:
222 GetDisplayIds(data);
223 break;
224 case ApiNumber::NUM_THREE:
225 GetMainDisplayId(data);
226 break;
227 case ApiNumber::NUM_FOUR:
228 SetBrightness(data);
229 break;
230 case ApiNumber::NUM_FIVE:
231 AdjustBrightness(data, size);
232 break;
233 case ApiNumber::NUM_SIX:
234 AutoAdjustBrightness(data);
235 break;
236 case ApiNumber::NUM_SEVEN:
237 RegisterCallback(data);
238 break;
239 case ApiNumber::NUM_EIGHT:
240 OverrideBrightness(data);
241 break;
242 case ApiNumber::NUM_NINE:
243 RestoreBrightness(data);
244 break;
245 case ApiNumber::NUM_TEN:
246 BoostBrightness(data);
247 break;
248 case ApiNumber::NUM_ELEVEN:
249 CancelBoostBrightness(data);
250 break;
251 case ApiNumber::NUM_TWELVE:
252 g_displayMgrClient.GetDefaultBrightness();
253 break;
254 case ApiNumber::NUM_THIRTEEN:
255 g_displayMgrClient.GetMaxBrightness();
256 break;
257 case ApiNumber::NUM_FOURTEEN:
258 g_displayMgrClient.GetMinBrightness();
259 break;
260 case ApiNumber::NUM_FIFTEEN:
261 DiscountBrightness(data);
262 break;
263 case ApiNumber::NUM_SIXTEEN:
264 GetBrightness(data);
265 break;
266 case ApiNumber::NUM_SEVENTEEN:
267 GetDeviceBrightness(data);
268 break;
269 case ApiNumber::NUM_EIGHTEEN:
270 g_displayMgrClient.IsAutoAdjustBrightness();
271 break;
272 case ApiNumber::NUM_NINETEEN:
273 g_displayMgrClient.GetError();
274 break;
275 default:
276 break;
277 }
278 }
279 return true;
280 }
281 }
282
283 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)284 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
285 {
286 /* Run your code on data */
287 OHOS::DoSomethingInterestingWithMyAPI(data, size);
288 return 0;
289 }
290