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 #define private public
17 #define protected public
18 #include "fuzzer/FuzzedDataProvider.h"
19 #include "scanserviceability_fuzzer.h"
20 #include "scan_service_ability.h"
21 #include "scan_callback_proxy.h"
22 #include "scan_service_ability_mock.h"
23 #include "scan_mdns_service.h"
24 #include "mdns_common.h"
25
26 namespace OHOS {
27 namespace Scan {
28 constexpr size_t FOO_MAX_LEN = 1024;
29 constexpr size_t U32_AT_SIZE = 4;
30 constexpr uint8_t MAX_STRING_LENGTH = 255;
31 constexpr int MAX_SET_NUMBER = 100;
32
TestOpenScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)33 void TestOpenScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
34 {
35 ScanServiceAbility::GetInstance()->InitScan();
36 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
37 ScanServiceAbility::GetInstance()->OpenScanner(scannerId);
38 }
39
TestCloseScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)40 void TestCloseScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
41 {
42 ScanServiceAbility::GetInstance()->InitScan();
43 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
44 ScanServiceAbility::GetInstance()->OpenScanner(scannerId);
45 ScanServiceAbility::GetInstance()->CloseScanner(scannerId);
46 }
47
TestGetScanOptionDesc(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)48 void TestGetScanOptionDesc(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
49 {
50 ScanServiceAbility::GetInstance()->InitScan();
51 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
52 int32_t optionIndex = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
53 ScanOptionDescriptor desc;
54 ScanServiceAbility::GetInstance()->GetScanOptionDesc(scannerId, optionIndex, desc);
55 }
56
TestStartScan(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)57 void TestStartScan(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
58 {
59 ScanServiceAbility::GetInstance()->InitScan();
60 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
61 bool batchMode = dataProvider->ConsumeBool();
62 ScanServiceAbility::GetInstance()->StartScan(scannerId, batchMode);
63 }
64
TestCancelScan(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)65 void TestCancelScan(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
66 {
67 ScanServiceAbility::GetInstance()->InitScan();
68 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
69 ScanServiceAbility::GetInstance()->CancelScan(scannerId);
70 }
71
TestOn(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)72 void TestOn(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
73 {
74 std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
75 std::string type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
76 sptr<IRemoteObject> impl;
77 ScanCallbackProxy scanCallbackProxy(impl);
78 sptr<IScanCallback> listener = iface_cast<IScanCallback>(impl);
79 ScanServiceAbility::registeredListeners_[type] = listener;
80 ScanServiceAbility::GetInstance()->On(taskId, type, listener);
81 ScanServiceAbility::registeredListeners_.clear();
82 }
83
TestOff(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)84 void TestOff(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
85 {
86 std::string taskId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
87 std::string type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
88 sptr<IRemoteObject> impl;
89 ScanCallbackProxy scanCallbackProxy(impl);
90 sptr<IScanCallback> listener = iface_cast<IScanCallback>(impl);
91 ScanServiceAbility::registeredListeners_[type] = listener;
92 ScanServiceAbility::GetInstance()->Off(taskId, type);
93 }
94
TestOnStartScan(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)95 void TestOnStartScan(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
96 {
97 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
98 bool batchMode = dataProvider->ConsumeBool();
99 auto scanSaPtr = ScanServiceAbility::GetInstance();
100 if (scanSaPtr == nullptr) {
101 return;
102 }
103 scanSaPtr->OnStartScan(scannerId, batchMode);
104 int32_t userId = scanSaPtr->GetCurrentUserId();
105 scanSaPtr->ObtainUserCacheDirectory(userId);
106 userId = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
107 scanSaPtr->ObtainUserCacheDirectory(userId);
108 constexpr int32_t DEFAULT_USERID = 100;
109 userId = DEFAULT_USERID;
110 scanSaPtr->ObtainUserCacheDirectory(userId);
111 }
112
TestSendDeviceInfo(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)113 void TestSendDeviceInfo(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
114 {
115 ScanDeviceInfo info;
116 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
117 ScanServiceAbility::GetInstance()->SendDeviceInfo(info, event);
118 }
119
TestSendDeviceInfoSync(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)120 void TestSendDeviceInfoSync(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
121 {
122 ScanDeviceInfoSync info;
123 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
124 ScanServiceAbility::GetInstance()->SendDeviceInfoSync(info, event);
125 }
126
TestDisConnectUsbScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)127 void TestDisConnectUsbScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
128 {
129 std::string serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
130 std::string newDeviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
131 ScanServiceAbility::GetInstance()->DisConnectUsbScanner(serialNumber, newDeviceId);
132 }
133
TestUpdateUsbScannerId(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)134 void TestUpdateUsbScannerId(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
135 {
136 std::string discoverMode = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
137 ScanDeviceInfoSync usbSyncInfo;
138 usbSyncInfo.discoverMode = discoverMode;
139 ScanServiceAbility::GetInstance()->UpdateScannerId(usbSyncInfo);
140 usbSyncInfo.discoverMode = "USB";
141 ScanServiceAbility::GetInstance()->UpdateScannerId(usbSyncInfo);
142 usbSyncInfo.discoverMode = "TCP";
143 ScanServiceAbility::GetInstance()->UpdateScannerId(usbSyncInfo);
144 }
145
TestSetScannerSerialNumber(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)146 void TestSetScannerSerialNumber(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
147 {
148 ScanDeviceInfo tcpInfo;
149 tcpInfo.deviceId = "pantum6500:tcp 192.168.223.1 9200-M6700DW";
150 std::string ip = "192.168.223.1";
151 ScanDeviceInfoTCP scanDeviceInfoTCP;
152 scanDeviceInfoTCP.deviceName = "Pantum 6666 54QWER";
153 ScanMdnsService::InsertIpToScannerInfo(ip, scanDeviceInfoTCP);
154 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(tcpInfo);
155
156 tcpInfo.deviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
157 ip = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
158 scanDeviceInfoTCP.deviceName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
159 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(tcpInfo);
160
161 ScanDeviceInfo usbInfo;
162 usbInfo.deviceId = "pantum6500:libusb:002:003";
163 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(usbInfo);
164
165 usbInfo.deviceId = "pantum6500:libusb:002:004";
166 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(usbInfo);
167 usbInfo.deviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
168 ScanServiceAbility::GetInstance()->SetScannerSerialNumber(usbInfo);
169 }
170
TestCheckPermission(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)171 void TestCheckPermission(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
172 {
173 std::string permissionName = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
174 ScanServiceAbility::GetInstance()->CheckPermission(permissionName);
175 }
176
TestGeneratePictureBatch(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)177 void TestGeneratePictureBatch(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
178 {
179 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
180 ScanServiceAbility::GetInstance()->GeneratePictureSingle(scannerId);
181 ScanServiceAbility::GetInstance()->GeneratePictureBatch(scannerId);
182 }
183
TestAddFoundScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)184 void TestAddFoundScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
185 {
186 ScanDeviceInfo info;
187 info.serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
188 ScanServiceAbility::GetInstance()->AddFoundScanner(info);
189 }
190
TestSendDeviceList(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)191 void TestSendDeviceList(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
192 {
193 ScanDeviceInfo infoItem;
194 std::vector<ScanDeviceInfo> info;
195 info.push_back(infoItem);
196 std::string event = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
197 ScanServiceAbility::GetInstance()->SendDeviceList(info, event);
198 }
199
TestAddScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)200 void TestAddScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
201 {
202 std::string serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
203 std::string discoverMode = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
204 ScanServiceAbility::GetInstance()->AddScanner(serialNumber, discoverMode);
205 }
206
TestGetAddedScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)207 void TestGetAddedScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
208 {
209 ScanDeviceInfo addedScanner;
210 std::string newDeviceId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
211 addedScanner.SetDeviceId(newDeviceId);
212 std::vector<ScanDeviceInfo> allAddedScanner;
213 allAddedScanner.push_back(addedScanner);
214 ScanServiceAbility::GetInstance()->GetAddedScanner(allAddedScanner);
215 }
216
TestNoParmFuncs(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)217 void TestNoParmFuncs(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
218 {
219 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
220 ScanServiceAbility::GetInstance()->InitScan();
221 ScanServiceAbility::GetInstance()->ServiceInit();
222 ScanServiceAbility::GetInstance()->InitServiceHandler();
223 ScanServiceAbility::GetInstance()->OnStart();
224 ScanServiceAbility::GetInstance()->OnStop();
225 ScanServiceAbility::GetInstance()->ManualStart();
226 ScanServiceAbility::GetInstance()->SaneGetScanner();
227 ScanServiceAbility::GetInstance()->GetScannerList();
228 ScanServiceAbility::GetInstance()->ExitScan();
229 }
230
TestNotPublicFunction(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)231 void TestNotPublicFunction(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
232 {
233 if (dataProvider == nullptr) {
234 return;
235 }
236 OHOS::Scan::TestNoParmFuncs(data, size, dataProvider);
237 OHOS::Scan::TestCheckPermission(data, size, dataProvider);
238 OHOS::Scan::TestGeneratePictureBatch(data, size, dataProvider);
239 OHOS::Scan::TestAddFoundScanner(data, size, dataProvider);
240 OHOS::Scan::TestSendDeviceList(data, size, dataProvider);
241 OHOS::Scan::TestAddScanner(data, size, dataProvider);
242 OHOS::Scan::TestGetAddedScanner(data, size, dataProvider);
243 }
244
TestCleanUpAfterScan(FuzzedDataProvider * dataProvider)245 void TestCleanUpAfterScan(FuzzedDataProvider* dataProvider)
246 {
247 if (dataProvider == nullptr) {
248 return;
249 }
250 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
251 ScanServiceAbility::GetInstance()->RestartScan(scannerId);
252 int32_t scanStatus = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
253 ScanServiceAbility::GetInstance()->CleanUpAfterScan(scanStatus);
254 }
255
TestActionSetAuto(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)256 void TestActionSetAuto(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
257 {
258 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
259 int32_t optionIndex = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
260 ScanServiceAbility::GetInstance()->ActionSetAuto(scannerId, optionIndex);
261 }
262
TestActionGetValue(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)263 void TestActionGetValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
264 {
265 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
266 int32_t optionIndex = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
267 ScanOptionValue scanOptionValue;
268 scanOptionValue.SetScanOptionValueType(ScanOptionValueType::SCAN_VALUE_BOOL);
269 int32_t valueSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
270 scanOptionValue.SetValueSize(valueSize);
271 scanOptionValue.SetBoolValue(true);
272 ScanServiceAbility::GetInstance()->ActionGetValue(scannerId, scanOptionValue, optionIndex);
273
274 ScanOptionValue scanOptionValue1;
275 scanOptionValue1.SetScanOptionValueType(ScanOptionValueType::SCAN_VALUE_NUM);
276 valueSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
277 scanOptionValue1.SetValueSize(valueSize);
278 int32_t numValue = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
279 scanOptionValue1.SetNumValue(numValue);
280 ScanServiceAbility::GetInstance()->ActionGetValue(scannerId, scanOptionValue1, optionIndex);
281
282 ScanOptionValue scanOptionValue2;
283 scanOptionValue2.SetScanOptionValueType(ScanOptionValueType::SCAN_VALUE_STR);
284 valueSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
285 scanOptionValue2.SetValueSize(valueSize);
286 std::string strValue = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
287 scanOptionValue2.SetStrValue(strValue);
288 ScanServiceAbility::GetInstance()->ActionGetValue(scannerId, scanOptionValue2, optionIndex);
289 }
290
TestActionSetValue(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)291 void TestActionSetValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
292 {
293 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
294 int32_t optionIndex = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
295 ScanOptionValue scanOptionValue;
296 ScanServiceAbility::GetInstance()->ActionSetValue(scannerId, scanOptionValue, optionIndex);
297 }
298
TestOpScanOptionValue(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)299 void TestOpScanOptionValue(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
300 {
301 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
302 int32_t optionIndex = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
303 ScanOptionValue scanOptionValue;
304 ScanServiceAbility::GetInstance()->OpScanOptionValue(scannerId, optionIndex,
305 ScanOptionOpType::SCAN_ACTION_GET_VALUE, scanOptionValue);
306 }
307
TestGetScanParameters(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)308 void TestGetScanParameters(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
309 {
310 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
311 ScanParameters scanParameters;
312 ScanServiceAbility::GetInstance()->GetScanParameters(scannerId, scanParameters);
313 }
314
TestGetScanProgress(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)315 void TestGetScanProgress(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
316 {
317 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
318 ScanProgress scanProg;
319 ScanServiceAbility::GetInstance()->GetScanProgress(scannerId, scanProg);
320 }
321
TestDeleteScanner(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)322 void TestDeleteScanner(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
323 {
324 std::string serialNumber = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
325 std::string discoverMode = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
326 ScanServiceAbility::GetInstance()->DeleteScanner(serialNumber, discoverMode);
327 }
328
TestStartScanTask(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)329 void TestStartScanTask(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
330 {
331 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
332 ScanServiceAbility::GetInstance()->StartScanTask(scannerId);
333 }
334
TestDoScanTask(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)335 void TestDoScanTask(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
336 {
337 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
338 ScanServiceAbility::GetInstance()->DoScanTask(scannerId);
339 }
340
TestSetScanProgr(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)341 void TestSetScanProgr(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
342 {
343 int64_t totalBytes = dataProvider->ConsumeIntegralInRange<int64_t>(0, MAX_SET_NUMBER);
344 int64_t hundredPercent = dataProvider->ConsumeIntegralInRange<int64_t>(0, MAX_SET_NUMBER);
345 int32_t curReadSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
346 ScanServiceAbility::GetInstance()->SetScanProgr(totalBytes, hundredPercent, curReadSize);
347 }
348
TestGetPicFrame(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)349 void TestGetPicFrame(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
350 {
351 std::string scannerId = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
352 int32_t scanStatus = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
353 ScanParameters scanParameters;
354 ScanServiceAbility::GetInstance()->GetPicFrame(scannerId, scanStatus, scanParameters);
355 }
356
TestWritePicData(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)357 void TestWritePicData(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
358 {
359 int32_t jpegrow = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
360 int32_t curReadSize = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
361 int32_t scanStatus = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
362 ScanParameters scanParameters;
363 ScanServiceAbility::GetInstance()->WritePicData(jpegrow, curReadSize, scanParameters, scanStatus);
364 }
365
TestMdnsDiscoveryHandleServiceFound(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)366 void TestMdnsDiscoveryHandleServiceFound(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
367 {
368 MDnsServiceInfo info;
369 info.name = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
370 info.type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
371 info.addr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
372 info.txtRecord = dataProvider->ConsumeBytes<uint8_t>(MAX_STRING_LENGTH);
373 int32_t retCode = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
374 ScanMDnsDiscoveryObserver observer(info);
375 observer.HandleServiceFound(info, retCode);
376 }
377
TestMdnsResolveHandleResolveResult(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)378 void TestMdnsResolveHandleResolveResult(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
379 {
380 MDnsServiceInfo info;
381 info.name = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
382 info.type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
383 info.addr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
384 info.txtRecord = dataProvider->ConsumeBytes<uint8_t>(MAX_STRING_LENGTH);
385 int32_t retCode = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
386 ScanMDnsResolveObserver observer(info);
387 observer.HandleResolveResult(info, retCode);
388 }
389
TestMdnsDiscoveryHandleServiceLost(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)390 void TestMdnsDiscoveryHandleServiceLost(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
391 {
392 MDnsServiceInfo info;
393 info.name = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
394 info.type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
395 info.addr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
396 info.txtRecord = dataProvider->ConsumeBytes<uint8_t>(MAX_STRING_LENGTH);
397 int32_t retCode = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
398 ScanMDnsDiscoveryObserver observer(info);
399 observer.HandleServiceLost(info, retCode);
400 }
401
TestMdnsLossResolveHandleResolveResult(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)402 void TestMdnsLossResolveHandleResolveResult(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
403 {
404 MDnsServiceInfo info;
405 info.name = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
406 info.type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
407 info.addr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
408 info.txtRecord = dataProvider->ConsumeBytes<uint8_t>(MAX_STRING_LENGTH);
409 int32_t retCode = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
410 ScanMDnsLossResolveObserver observer(info);
411 observer.HandleResolveResult(info, retCode);
412 }
413
TestHandDiscoveryleStopDiscover(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)414 void TestHandDiscoveryleStopDiscover(const uint8_t *data, size_t size, FuzzedDataProvider *dataProvider)
415 {
416 MDnsServiceInfo info;
417 info.name = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
418 info.type = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
419 info.addr = dataProvider->ConsumeRandomLengthString(MAX_STRING_LENGTH);
420 info.txtRecord = dataProvider->ConsumeBytes<uint8_t>(MAX_STRING_LENGTH);
421 int32_t retCode = dataProvider->ConsumeIntegralInRange<int32_t>(0, MAX_SET_NUMBER);
422 ScanMDnsDiscoveryObserver observer(info);
423 observer.HandleStopDiscover(info, retCode);
424 }
425
TestAllMdnsService(const uint8_t * data,size_t size,FuzzedDataProvider * dataProvider)426 void TestAllMdnsService(const uint8_t* data, size_t size, FuzzedDataProvider* dataProvider)
427 {
428 TestMdnsDiscoveryHandleServiceFound(data, size, dataProvider);
429 TestMdnsResolveHandleResolveResult(data, size, dataProvider);
430 TestMdnsDiscoveryHandleServiceLost(data, size, dataProvider);
431 TestMdnsLossResolveHandleResolveResult(data, size, dataProvider);
432 TestHandDiscoveryleStopDiscover(data, size, dataProvider);
433 }
434 }
435 }
436
437 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)438 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
439 {
440 if (data == nullptr) {
441 return 0;
442 }
443
444 if (size < OHOS::Scan::U32_AT_SIZE || size > OHOS::Scan::FOO_MAX_LEN) {
445 return 0;
446 }
447 FuzzedDataProvider dataProvider(data, size);
448 OHOS::Scan::ScanServiceAbilityMock::MockPermission();
449 OHOS::Scan::TestOpenScanner(data, size, &dataProvider);
450 OHOS::Scan::TestCloseScanner(data, size, &dataProvider);
451 OHOS::Scan::TestGetScanOptionDesc(data, size, &dataProvider);
452 OHOS::Scan::TestStartScan(data, size, &dataProvider);
453 OHOS::Scan::TestCancelScan(data, size, &dataProvider);
454 OHOS::Scan::TestOn(data, size, &dataProvider);
455 OHOS::Scan::TestOff(data, size, &dataProvider);
456 OHOS::Scan::TestOnStartScan(data, size, &dataProvider);
457 OHOS::Scan::TestSendDeviceInfo(data, size, &dataProvider);
458 OHOS::Scan::TestSendDeviceInfoSync(data, size, &dataProvider);
459 OHOS::Scan::TestDisConnectUsbScanner(data, size, &dataProvider);
460 OHOS::Scan::TestUpdateUsbScannerId(data, size, &dataProvider);
461 OHOS::Scan::TestSetScannerSerialNumber(data, size, &dataProvider);
462 OHOS::Scan::TestNotPublicFunction(data, size, &dataProvider);
463 OHOS::Scan::TestCleanUpAfterScan(&dataProvider);
464 OHOS::Scan::TestActionSetAuto(data, size, &dataProvider);
465 OHOS::Scan::TestActionGetValue(data, size, &dataProvider);
466 OHOS::Scan::TestOpScanOptionValue(data, size, &dataProvider);
467 OHOS::Scan::TestGetScanParameters(data, size, &dataProvider);
468 OHOS::Scan::TestGetScanProgress(data, size, &dataProvider);
469 OHOS::Scan::TestDeleteScanner(data, size, &dataProvider);
470 OHOS::Scan::TestStartScanTask(data, size, &dataProvider);
471 OHOS::Scan::TestDoScanTask(data, size, &dataProvider);
472 OHOS::Scan::TestSetScanProgr(data, size, &dataProvider);
473 OHOS::Scan::TestGetPicFrame(data, size, &dataProvider);
474 OHOS::Scan::TestWritePicData(data, size, &dataProvider);
475 OHOS::Scan::TestAllMdnsService(data, size, &dataProvider);
476 return 0;
477 }