1 /*
2 * Copyright (c) 2023-2025 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 <fuzzer/FuzzedDataProvider.h>
17
18 #include "dcameradeviceupdatesettings_fuzzer.h"
19
20 #include "dcamera_device.h"
21 #include "dcamera_host.h"
22 #include "v1_1/dcamera_types.h"
23
24 namespace OHOS {
25 namespace DistributedHardware {
DcameraDeviceUpdateSettingsFuzzTest(const uint8_t * data,size_t size)26 void DcameraDeviceUpdateSettingsFuzzTest(const uint8_t* data, size_t size)
27 {
28 if ((data == nullptr) || (size < sizeof(uint8_t))) {
29 return;
30 }
31 FuzzedDataProvider fdp(data, size);
32 std::string deviceId = fdp.ConsumeRandomLengthString(size);
33 std::string dhId = fdp.ConsumeRandomLengthString(size);
34
35 DHBase dhBase;
36 dhBase.deviceId_ = deviceId;
37 dhBase.dhId_ = dhId;
38
39 std::vector<uint8_t> results;
40 results.push_back(*(reinterpret_cast<const uint8_t*>(data)));
41
42 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
43 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
44
45 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
46 if (dcameraDevice == nullptr) {
47 return;
48 }
49 dcameraDevice->UpdateSettings(results);
50 }
51
DcameraDeviceGetStreamOperatorFuzzTest(const uint8_t * data,size_t size)52 void DcameraDeviceGetStreamOperatorFuzzTest(const uint8_t* data, size_t size)
53 {
54 if ((data == nullptr) || (size < sizeof(uint8_t))) {
55 return;
56 }
57
58 FuzzedDataProvider fdp(data, size);
59 std::string deviceId = fdp.ConsumeRandomLengthString(size);
60 std::string dhId = fdp.ConsumeRandomLengthString(size);
61
62 DHBase dhBase;
63 dhBase.deviceId_ = deviceId;
64 dhBase.dhId_ = dhId;
65
66 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
67 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
68
69 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
70 if (dcameraDevice == nullptr) {
71 return;
72 }
73 OHOS::sptr<HDI::Camera::V1_0::IStreamOperatorCallback> callbackObj = nullptr;
74 OHOS::sptr<HDI::Camera::V1_0::IStreamOperator> streamOperator = nullptr;
75
76 dcameraDevice->GetStreamOperator(callbackObj, streamOperator);
77 }
78
DcameraDeviceGetStreamOperatorV1_1FuzzTest(const uint8_t * data,size_t size)79 void DcameraDeviceGetStreamOperatorV1_1FuzzTest(const uint8_t* data, size_t size)
80 {
81 if ((data == nullptr) || (size < sizeof(uint8_t))) {
82 return;
83 }
84
85 FuzzedDataProvider fdp(data, size);
86 std::string deviceId = fdp.ConsumeRandomLengthString(size);
87 std::string dhId = fdp.ConsumeRandomLengthString(size);
88
89 DHBase dhBase;
90 dhBase.deviceId_ = deviceId;
91 dhBase.dhId_ = dhId;
92
93 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
94 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
95
96 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
97 if (dcameraDevice == nullptr) {
98 return;
99 }
100
101 OHOS::sptr<HDI::Camera::V1_0::IStreamOperatorCallback> callbackObj = nullptr;
102 OHOS::sptr<HDI::Camera::V1_1::IStreamOperator> streamOperator = nullptr;
103
104 dcameraDevice->GetStreamOperator_V1_1(callbackObj, streamOperator);
105 }
106
DcameraDeviceGetStreamOperatorV1_2FuzzTest(const uint8_t * data,size_t size)107 void DcameraDeviceGetStreamOperatorV1_2FuzzTest(const uint8_t* data, size_t size)
108 {
109 if ((data == nullptr) || (size < sizeof(uint8_t))) {
110 return;
111 }
112
113 FuzzedDataProvider fdp(data, size);
114 std::string deviceId = fdp.ConsumeRandomLengthString(size);
115 std::string dhId = fdp.ConsumeRandomLengthString(size);
116
117 DHBase dhBase;
118 dhBase.deviceId_ = deviceId;
119 dhBase.dhId_ = dhId;
120
121 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
122 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
123
124 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
125 if (dcameraDevice == nullptr) {
126 return;
127 }
128
129 OHOS::sptr<HDI::Camera::V1_2::IStreamOperatorCallback> callbackObj = nullptr;
130 OHOS::sptr<HDI::Camera::V1_2::IStreamOperator> streamOperator = nullptr;
131
132 dcameraDevice->GetStreamOperator_V1_2(callbackObj, streamOperator);
133 }
134
DcameraDeviceGetStreamOperatorV1_3FuzzTest(const uint8_t * data,size_t size)135 void DcameraDeviceGetStreamOperatorV1_3FuzzTest(const uint8_t* data, size_t size)
136 {
137 if ((data == nullptr) || (size < sizeof(uint8_t))) {
138 return;
139 }
140
141 FuzzedDataProvider fdp(data, size);
142 std::string deviceId = fdp.ConsumeRandomLengthString(size);
143 std::string dhId = fdp.ConsumeRandomLengthString(size);
144
145 DHBase dhBase;
146 dhBase.deviceId_ = deviceId;
147 dhBase.dhId_ = dhId;
148
149 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
150 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
151
152 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
153 if (dcameraDevice == nullptr) {
154 return;
155 }
156
157 OHOS::sptr<HDI::Camera::V1_3::IStreamOperatorCallback> callbackObj = nullptr;
158 OHOS::sptr<HDI::Camera::V1_3::IStreamOperator> streamOperator = nullptr;
159
160 dcameraDevice->GetStreamOperator_V1_3(callbackObj, streamOperator);
161 }
162
DCameraGetSecureCameraSeqFuzzTest(const uint8_t * data,size_t size)163 void DCameraGetSecureCameraSeqFuzzTest(const uint8_t* data, size_t size)
164 {
165 if ((data == nullptr) || (size < sizeof(uint64_t))) {
166 return;
167 }
168
169 FuzzedDataProvider fdp(data, size);
170 std::string deviceId = fdp.ConsumeRandomLengthString(size);
171 std::string dhId = fdp.ConsumeRandomLengthString(size);
172
173 DHBase dhBase;
174 dhBase.deviceId_ = deviceId;
175 dhBase.dhId_ = dhId;
176
177 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
178 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
179
180 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
181 if (dcameraDevice == nullptr) {
182 return;
183 }
184
185 uint64_t seqId = *(reinterpret_cast<const uint64_t*>(data));
186 dcameraDevice->GetSecureCameraSeq(seqId);
187 }
188
DCameraDeviceGetStatusFuzzTest(const uint8_t * data,size_t size)189 void DCameraDeviceGetStatusFuzzTest(const uint8_t* data, size_t size)
190 {
191 if ((data == nullptr) || (size == 0)) {
192 return;
193 }
194
195 FuzzedDataProvider fdp(data, size);
196 std::string deviceId = fdp.ConsumeRandomLengthString(size);
197 std::string dhId = fdp.ConsumeRandomLengthString(size);
198
199 DHBase dhBase;
200 dhBase.deviceId_ = deviceId;
201 dhBase.dhId_ = dhId;
202
203 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
204 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
205
206 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
207 if (dcameraDevice == nullptr) {
208 return;
209 }
210
211 std::vector<uint8_t> metaIn(data, data + size);
212 std::vector<uint8_t> metaOut;
213
214 dcameraDevice->GetStatus(metaIn, metaOut);
215 }
216
DCameraDeviceResetFuzzTest(const uint8_t * data,size_t size)217 void DCameraDeviceResetFuzzTest(const uint8_t* data, size_t size)
218 {
219 if ((data == nullptr) || (size == 0)) {
220 return;
221 }
222
223 FuzzedDataProvider fdp(data, size);
224 std::string deviceId = fdp.ConsumeRandomLengthString(size);
225 std::string dhId = fdp.ConsumeRandomLengthString(size);
226
227 DHBase dhBase;
228 dhBase.deviceId_ = deviceId;
229 dhBase.dhId_ = dhId;
230
231 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
232 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
233
234 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
235 if (dcameraDevice == nullptr) {
236 return;
237 }
238 dcameraDevice->Reset();
239 }
240
DCameraDeviceGetDefaultSettingsFuzzTest(const uint8_t * data,size_t size)241 void DCameraDeviceGetDefaultSettingsFuzzTest(const uint8_t* data, size_t size)
242 {
243 if ((data == nullptr) || (size == 0)) {
244 return;
245 }
246
247 FuzzedDataProvider fdp(data, size);
248 std::string deviceId = fdp.ConsumeRandomLengthString(size);
249 std::string dhId = fdp.ConsumeRandomLengthString(size);
250
251 DHBase dhBase;
252 dhBase.deviceId_ = deviceId;
253 dhBase.dhId_ = dhId;
254
255 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
256 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
257
258 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
259 if (dcameraDevice == nullptr) {
260 return;
261 }
262
263 std::vector<uint8_t> settings;
264 dcameraDevice->GetDefaultSettings(settings);
265 }
266
DCameraDeviceSetResultModeFuzzTest(const uint8_t * data,size_t size)267 void DCameraDeviceSetResultModeFuzzTest(const uint8_t* data, size_t size)
268 {
269 if ((data == nullptr) || (size < sizeof(ResultCallbackMode))) {
270 return;
271 }
272
273 FuzzedDataProvider fdp(data, size);
274 std::string deviceId = fdp.ConsumeRandomLengthString(size);
275 std::string dhId = fdp.ConsumeRandomLengthString(size);
276
277 DHBase dhBase;
278 dhBase.deviceId_ = deviceId;
279 dhBase.dhId_ = dhId;
280 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
281 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
282
283 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
284 if (dcameraDevice == nullptr) {
285 return;
286 }
287
288 ResultCallbackMode mode = *(reinterpret_cast<const ResultCallbackMode*>(data));
289 dcameraDevice->SetResultMode(mode);
290 }
291
DCameraDeviceGetEnabledResultsFuzzTest(const uint8_t * data,size_t size)292 void DCameraDeviceGetEnabledResultsFuzzTest(const uint8_t* data, size_t size)
293 {
294 if ((data == nullptr) || (size == 0)) {
295 return;
296 }
297 FuzzedDataProvider fdp(data, size);
298 std::string deviceId = fdp.ConsumeRandomLengthString(size);
299 std::string dhId = fdp.ConsumeRandomLengthString(size);
300
301 DHBase dhBase;
302 dhBase.deviceId_ = deviceId;
303 dhBase.dhId_ = dhId;
304 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
305 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
306
307 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
308 if (dcameraDevice == nullptr) {
309 return;
310 }
311
312 std::vector<int32_t> results;
313 dcameraDevice->GetEnabledResults(results);
314 }
315
DCameraEnableResultFuzzTest(const uint8_t * data,size_t size)316 void DCameraEnableResultFuzzTest(const uint8_t* data, size_t size)
317 {
318 if ((data == nullptr) || (size < sizeof(int32_t))) {
319 return;
320 }
321
322 FuzzedDataProvider fdp(data, size);
323 std::string deviceId = fdp.ConsumeRandomLengthString(size);
324 std::string dhId = fdp.ConsumeRandomLengthString(size);
325
326 DHBase dhBase;
327 dhBase.deviceId_ = deviceId;
328 dhBase.dhId_ = dhId;
329
330 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
331 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
332
333 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
334 if (dcameraDevice == nullptr) {
335 return;
336 }
337
338 std::vector<int32_t> results;
339 results.push_back(fdp.ConsumeIntegral<int32_t>());
340
341 dcameraDevice->EnableResult(results);
342 }
343
DCameraDisableResultFuzzTest(const uint8_t * data,size_t size)344 void DCameraDisableResultFuzzTest(const uint8_t* data, size_t size)
345 {
346 if ((data == nullptr) || (size < sizeof(int32_t))) {
347 return;
348 }
349
350 FuzzedDataProvider fdp(data, size);
351 std::string deviceId = fdp.ConsumeRandomLengthString(size);
352 std::string dhId = fdp.ConsumeRandomLengthString(size);
353
354 DHBase dhBase;
355 dhBase.deviceId_ = deviceId;
356 dhBase.dhId_ = dhId;
357
358 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
359 std::string srcAbilityInfo = fdp.ConsumeRandomLengthString(size);
360
361 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, srcAbilityInfo));
362 if (dcameraDevice == nullptr) {
363 return;
364 }
365
366 std::vector<int32_t> results;
367 results.push_back(fdp.ConsumeIntegral<int32_t>());
368
369 dcameraDevice->DisableResult(results);
370 }
371
DCameraAcquireBufferFuzzTest(const uint8_t * data,size_t size)372 void DCameraAcquireBufferFuzzTest(const uint8_t* data, size_t size)
373 {
374 if ((data == nullptr) || (size < sizeof(int32_t))) {
375 return;
376 }
377
378 std::string deviceId = "deviceId";
379 std::string dhId = "dhId";
380 DHBase dhBase;
381 dhBase.deviceId_ = deviceId;
382 dhBase.dhId_ = dhId;
383
384 FuzzedDataProvider fdp(data, size);
385 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
386 std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size);
387
388 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo));
389 if (dcameraDevice == nullptr) {
390 return;
391 }
392
393 int32_t streamId = fdp.ConsumeIntegral<int32_t>();
394 DCameraBuffer buffer;
395 buffer.index_ = fdp.ConsumeIntegral<int32_t>();
396 buffer.size_ = fdp.ConsumeIntegral<uint32_t>();
397
398 dcameraDevice->AcquireBuffer(streamId, buffer);
399 }
400
DCameraShutterBufferFuzzTest(const uint8_t * data,size_t size)401 void DCameraShutterBufferFuzzTest(const uint8_t* data, size_t size)
402 {
403 if ((data == nullptr) || (size < sizeof(int32_t))) {
404 return;
405 }
406
407 std::string deviceId = "deviceId";
408 std::string dhId = "dhId";
409 DHBase dhBase;
410 dhBase.deviceId_ = deviceId;
411 dhBase.dhId_ = dhId;
412
413 FuzzedDataProvider fdp(data, size);
414 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
415 std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size);
416
417 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo));
418 if (dcameraDevice == nullptr) {
419 return;
420 }
421
422 int32_t streamId = fdp.ConsumeIntegral<int32_t>();
423 DCameraBuffer buffer;
424 buffer.index_ = fdp.ConsumeIntegral<int32_t>();
425 buffer.size_ = fdp.ConsumeIntegral<uint32_t>();
426
427 dcameraDevice->ShutterBuffer(streamId, buffer);
428 }
429
DCameraOnSettingsResultFuzzTest(const uint8_t * data,size_t size)430 void DCameraOnSettingsResultFuzzTest(const uint8_t* data, size_t size)
431 {
432 if ((data == nullptr) || (size == 0)) {
433 return;
434 }
435
436 std::string deviceId = "deviceId";
437 std::string dhId = "dhId";
438 DHBase dhBase;
439 dhBase.deviceId_ = deviceId;
440 dhBase.dhId_ = dhId;
441
442 FuzzedDataProvider fdp(data, size);
443 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
444 std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size);
445
446 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo));
447 if (dcameraDevice == nullptr) {
448 return;
449 }
450
451 DCameraSettings result;
452 result.type_ = static_cast<DCSettingsType>(fdp.ConsumeIntegral<int32_t>());
453 result.value_ = fdp.ConsumeRemainingBytesAsString();
454
455 dcameraDevice->OnSettingsResult(std::make_shared<DCameraSettings>(result));
456 }
457
DCameraNotifyFuzzTest(const uint8_t * data,size_t size)458 void DCameraNotifyFuzzTest(const uint8_t* data, size_t size)
459 {
460 if ((data == nullptr) || (size == 0)) {
461 return;
462 }
463
464 std::string deviceId = "deviceId";
465 std::string dhId = "dhId";
466 DHBase dhBase;
467 dhBase.deviceId_ = deviceId;
468 dhBase.dhId_ = dhId;
469
470 FuzzedDataProvider fdp(data, size);
471 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
472 std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size);
473
474 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo));
475 if (dcameraDevice == nullptr) {
476 return;
477 }
478 const std::vector<DCameraEventResult> validEventResults = {
479 DCAMERA_EVENT_CHANNEL_DISCONNECTED, DCAMERA_EVENT_CHANNEL_CONNECTED,
480 DCAMERA_EVENT_CAMERA_SUCCESS, DCAMERA_EVENT_CAMERA_ERROR,
481 DCAMERA_EVENT_OPEN_CHANNEL_ERROR, DCAMERA_EVENT_CLOSE_CHANNEL_ERROR,
482 DCAMERA_EVENT_CONFIG_STREAMS_ERROR, DCAMERA_EVENT_RELEASE_STREAMS_ERROR,
483 DCAMERA_EVENT_START_CAPTURE_ERROR, DCAMERA_EVENT_STOP_CAPTURE_ERROR,
484 DCAMERA_EVENT_UPDATE_SETTINGS_ERROR, DCAMERA_EVENT_DEVICE_ERROR,
485 DCAMERA_EVENT_DEVICE_PREEMPT, DCAMERA_EVENT_DEVICE_IN_USE,
486 DCAMERA_EVENT_NO_PERMISSION
487 };
488
489 std::shared_ptr<DCameraHDFEvent> event = std::make_shared<DCameraHDFEvent>();
490 event->type_ = static_cast<DCameraEventType>(fdp.ConsumeIntegralInRange<int>(DCAMERA_MESSAGE, DCAMERE_GETFULLCAP));
491 size_t index = fdp.ConsumeIntegralInRange<size_t>(0, validEventResults.size() - 1);
492 event->result_ = validEventResults[index];
493 event->content_ = fdp.ConsumeRemainingBytesAsString();
494
495 dcameraDevice->Notify(event);
496 }
497
DCameraIsOpenSessFailedStateFuzzTest(const uint8_t * data,size_t size)498 void DCameraIsOpenSessFailedStateFuzzTest(const uint8_t* data, size_t size)
499 {
500 if ((data == nullptr) || (size == 0)) {
501 return;
502 }
503
504 std::string deviceId = "deviceId";
505 std::string dhId = "dhId";
506 DHBase dhBase;
507 dhBase.deviceId_ = deviceId;
508 dhBase.dhId_ = dhId;
509
510 FuzzedDataProvider fdp(data, size);
511 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
512 std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size);
513
514 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo));
515 if (dcameraDevice == nullptr) {
516 return;
517 }
518
519 bool state = fdp.ConsumeBool();
520 dcameraDevice->IsOpenSessFailedState(state);
521 }
522
DCameraNotifyStartCaptureErrorFuzzTest(const uint8_t * data,size_t size)523 void DCameraNotifyStartCaptureErrorFuzzTest(const uint8_t* data, size_t size)
524 {
525 if ((data == nullptr) || (size == 0)) {
526 return;
527 }
528
529 std::string deviceId = "deviceId";
530 std::string dhId = "dhId";
531 DHBase dhBase;
532 dhBase.deviceId_ = deviceId;
533 dhBase.dhId_ = dhId;
534
535 FuzzedDataProvider fdp(data, size);
536 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
537 std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size);
538
539 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo));
540 if (dcameraDevice == nullptr) {
541 return;
542 }
543
544 dcameraDevice->NotifyStartCaptureError();
545 }
546
DCameraNotifyCameraErrorFuzzTest(const uint8_t * data,size_t size)547 void DCameraNotifyCameraErrorFuzzTest(const uint8_t* data, size_t size)
548 {
549 if ((data == nullptr) || (size == 0)) {
550 return;
551 }
552
553 std::string deviceId = "deviceId";
554 std::string dhId = "dhId";
555 DHBase dhBase;
556 dhBase.deviceId_ = deviceId;
557 dhBase.dhId_ = dhId;
558
559 FuzzedDataProvider fdp(data, size);
560 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
561 std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size);
562
563 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo));
564 if (dcameraDevice == nullptr) {
565 return;
566 }
567
568 ErrorType errorType = static_cast<ErrorType>(fdp.ConsumeIntegral<int32_t>());
569
570 dcameraDevice->NotifyCameraError(errorType);
571 }
572
DCameraSetDcameraAbilityFuzzTest(const uint8_t * data,size_t size)573 void DCameraSetDcameraAbilityFuzzTest(const uint8_t* data, size_t size)
574 {
575 if ((data == nullptr) || (size == 0)) {
576 return;
577 }
578
579 std::string deviceId = "deviceId";
580 std::string dhId = "dhId";
581 DHBase dhBase;
582 dhBase.deviceId_ = deviceId;
583 dhBase.dhId_ = dhId;
584
585 FuzzedDataProvider fdp(data, size);
586 std::string sinkAbilityInfo = fdp.ConsumeRandomLengthString(size);
587 std::string sourceCodecInfo = fdp.ConsumeRandomLengthString(size);
588
589 OHOS::sptr<DCameraDevice> dcameraDevice(new (std::nothrow) DCameraDevice(dhBase, sinkAbilityInfo, sourceCodecInfo));
590 if (dcameraDevice == nullptr) {
591 return;
592 }
593
594 std::string randomSinkAbilityInfo = fdp.ConsumeRemainingBytesAsString();
595 dcameraDevice->SetDcameraAbility(randomSinkAbilityInfo);
596 }
597 }
598 }
599
600 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)601 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
602 {
603 /* Run your code on data */
604 OHOS::DistributedHardware::DcameraDeviceUpdateSettingsFuzzTest(data, size);
605 OHOS::DistributedHardware::DcameraDeviceGetStreamOperatorFuzzTest(data, size);
606 OHOS::DistributedHardware::DcameraDeviceGetStreamOperatorV1_1FuzzTest(data, size);
607 OHOS::DistributedHardware::DcameraDeviceGetStreamOperatorV1_2FuzzTest(data, size);
608 OHOS::DistributedHardware::DcameraDeviceGetStreamOperatorV1_3FuzzTest(data, size);
609 OHOS::DistributedHardware::DCameraGetSecureCameraSeqFuzzTest(data, size);
610 OHOS::DistributedHardware::DCameraDeviceGetStatusFuzzTest(data, size);
611 OHOS::DistributedHardware::DCameraDeviceResetFuzzTest(data, size);
612 OHOS::DistributedHardware::DCameraDeviceGetDefaultSettingsFuzzTest(data, size);
613 OHOS::DistributedHardware::DCameraDeviceSetResultModeFuzzTest(data, size);
614 OHOS::DistributedHardware::DCameraDeviceGetEnabledResultsFuzzTest(data, size);
615 OHOS::DistributedHardware::DCameraEnableResultFuzzTest(data, size);
616 OHOS::DistributedHardware::DCameraDisableResultFuzzTest(data, size);
617 OHOS::DistributedHardware::DCameraAcquireBufferFuzzTest(data, size);
618 OHOS::DistributedHardware::DCameraShutterBufferFuzzTest(data, size);
619 OHOS::DistributedHardware::DCameraOnSettingsResultFuzzTest(data, size);
620 OHOS::DistributedHardware::DCameraNotifyFuzzTest(data, size);
621 OHOS::DistributedHardware::DCameraIsOpenSessFailedStateFuzzTest(data, size);
622 OHOS::DistributedHardware::DCameraNotifyStartCaptureErrorFuzzTest(data, size);
623 OHOS::DistributedHardware::DCameraNotifyCameraErrorFuzzTest(data, size);
624 OHOS::DistributedHardware::DCameraSetDcameraAbilityFuzzTest(data, size);
625 return 0;
626 }
627
628