1 /*
2  * Copyright (c) 2021-2023 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 "stream_operator_fuzzer.h"
17 
18 namespace OHOS::Camera {
19 const size_t THRESHOLD = 10;
20 
21 enum HostCmdId {
22     STREAM_OPERATOR_FUZZ_TEST,
23     STREAM_OPERATOR_ISSTREAMSUPPORTED_V1_1,
24     STREAM_OPERATOR_COMMITSTREAM_V1_1,
25     STREAM_OPERATOR_UPDATESTREAMS,
26     STREAM_OPERATOR_CONFIRMCAPTURE,
27     STREAM_OPERATOR_ENABLE_RESULT,
28     STREAM_OPERATOR_DISABLE_RESULT,
29     STREAM_OPERATOR_END,
30 };
31 
32 enum BitOperat {
33     INDEX_0 = 0,
34     INDEX_1,
35     INDEX_2,
36     INDEX_3,
37     MOVE_EIGHT_BITS = 8,
38     MOVE_SIXTEEN_BITS = 16,
39     MOVE_TWENTY_FOUR_BITS = 24,
40 };
41 
ConvertUint32(const uint8_t *bitOperat)42 static uint32_t ConvertUint32(const uint8_t *bitOperat)
43 {
44     if (bitOperat == nullptr) {
45         return 0;
46     }
47 
48     return (bitOperat[INDEX_0] << MOVE_TWENTY_FOUR_BITS) | (bitOperat[INDEX_1] << MOVE_SIXTEEN_BITS) |
49         (bitOperat[INDEX_2] << MOVE_EIGHT_BITS) | (bitOperat[INDEX_3]);
50 }
51 
IsStreamSupportedApi(const uint8_t *&rawData)52 void IsStreamSupportedApi(const uint8_t *&rawData)
53 {
54     std::vector<uint8_t> abilityVec = {};
55     uint8_t *data = const_cast<uint8_t *>(rawData);
56     abilityVec.push_back(*data);
57 
58     std::vector<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> streamInfosV1_1;
59     OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo;
60     extendedStreamInfo.type = OHOS::HDI::Camera::V1_1::EXTENDED_STREAM_INFO_QUICK_THUMBNAIL;
61     extendedStreamInfo.width = 0;
62     extendedStreamInfo.height = 0;
63     extendedStreamInfo.format = 0;
64     extendedStreamInfo.dataspace = 0;
65     std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> streamInfoCapture = nullptr;
66     streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
67     streamInfoCapture->v1_0 = {};
68     streamInfoCapture->extendedStreamInfos = {extendedStreamInfo};
69     streamInfosV1_1.push_back(*streamInfoCapture);
70     HDI::Camera::V1_0::StreamSupportType pType;
71 
72     cameraTest->streamOperator_V1_3->IsStreamsSupported_V1_1(
73         *reinterpret_cast<const HDI::Camera::V1_1::OperationMode_V1_1 *>(rawData), abilityVec,
74         streamInfosV1_1, pType);
75 }
76 
UpdateStreams(const uint8_t *rawData)77 void UpdateStreams(const uint8_t *rawData)
78 {
79     if (rawData == nullptr) {
80         return;
81     }
82     int *data = const_cast<int *>(reinterpret_cast<const int *>(rawData));
83     cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
84     cameraTest->streamInfoV1_1->v1_0.streamId_ = data[0];
85     cameraTest->streamInfoV1_1->v1_0.width_ = data[0];
86     cameraTest->streamInfoV1_1->v1_0.height_ = data[0];
87     cameraTest->streamInfoV1_1->v1_0.format_ = PIXEL_FMT_YCRCB_420_SP;
88     cameraTest->streamInfoV1_1->v1_0.tunneledMode_ = data[0];
89     cameraTest->streamInfoV1_1->v1_0.dataspace_ = OHOS_CAMERA_SRGB_FULL;
90     cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
91     cameraTest->rc = cameraTest->streamOperator_V1_3->UpdateStreams(cameraTest->streamInfosV1_1);
92 }
93 
funcConfirmCapture(const uint8_t *rawData)94 void funcConfirmCapture(const uint8_t *rawData)
95 {
96     cameraTest->streamOperator_V1_3->ConfirmCapture(*rawData);
97 }
98 
funcEnableResult(const uint8_t *rawData)99 void funcEnableResult(const uint8_t *rawData)
100 {
101     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
102         cameraTest->itemCapacity, cameraTest->dataCapacity);
103     std::vector<uint8_t> detectTypes;
104     uint8_t *data = const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(rawData));
105     detectTypes.push_back(data[0]);
106     uint8_t* typesToEnable = detectTypes.data();
107     meta->addEntry(OHOS_CONTROL_STATISTICS_DETECT_SETTING, typesToEnable, detectTypes.size());
108     std::vector<uint8_t> setting;
109     MetadataUtils::ConvertMetadataToVec(meta, setting);
110     cameraTest->streamOperator_V1_3->EnableResult(cameraTest->streamIdVideo, setting);
111 }
112 
funcDisableResult(const uint8_t *rawData)113 void funcDisableResult(const uint8_t *rawData)
114 {
115     std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(
116         cameraTest->itemCapacity, cameraTest->dataCapacity);
117     std::vector<uint8_t> detectTypes;
118     uint8_t *data = const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(rawData));
119     detectTypes.push_back(data[0]);
120     uint8_t* typesToEnable = detectTypes.data();
121     meta->addEntry(OHOS_CONTROL_STATISTICS_DETECT_SETTING, typesToEnable, detectTypes.size());
122     std::vector<uint8_t> setting;
123     MetadataUtils::ConvertMetadataToVec(meta, setting);
124     cameraTest->streamOperator_V1_3->DisableResult(cameraTest->streamIdVideo, setting);
125 }
126 
HostFuncSwitch(uint32_t cmd, const uint8_t *rawData)127 static void HostFuncSwitch(uint32_t cmd, const uint8_t *rawData)
128 {
129     switch (cmd) {
130         case STREAM_OPERATOR_ISSTREAMSUPPORTED_V1_1: {
131             IsStreamSupportedApi(rawData);
132             break;
133         }
134         case STREAM_OPERATOR_COMMITSTREAM_V1_1: {
135             std::vector<uint8_t> abilityVec = {};
136             uint8_t *data = const_cast<uint8_t *>(rawData);
137             abilityVec.push_back(*data);
138             cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
139                 *reinterpret_cast<const HDI::Camera::V1_1::OperationMode_V1_1 *>(rawData), abilityVec);
140             break;
141         }
142         case STREAM_OPERATOR_UPDATESTREAMS:
143             UpdateStreams(rawData);
144             break;
145         case STREAM_OPERATOR_CONFIRMCAPTURE:
146             funcConfirmCapture(rawData);
147             break;
148         case STREAM_OPERATOR_ENABLE_RESULT:
149             funcEnableResult(rawData);
150             break;
151         case STREAM_OPERATOR_DISABLE_RESULT:
152             funcDisableResult(rawData);
153             break;
154         default:
155             return;
156     }
157 }
158 
DoSomethingInterestingWithMyApi(const uint8_t *rawData, size_t size)159 bool DoSomethingInterestingWithMyApi(const uint8_t *rawData, size_t size)
160 {
161     (void)size;
162     if (rawData == nullptr) {
163         return false;
164     }
165 
166     uint32_t cmd = ConvertUint32(rawData);
167     rawData += sizeof(cmd);
168 
169     cameraTest = std::make_shared<OHOS::Camera::HdiCommonV1_3>();
170     cameraTest->Init();
171     if (cameraTest->serviceV1_3 == nullptr) {
172         return false;
173     }
174     cameraTest->Open(DEVICE_0);
175     if (cameraTest->cameraDeviceV1_3 == nullptr) {
176         return false;
177     }
178     cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::HdiCommonV1_3::TestStreamOperatorCallbackV1_3();
179     cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
180         cameraTest->streamOperator_V1_3);
181     for (cmd = 0; cmd < STREAM_OPERATOR_END; cmd++) {
182         HostFuncSwitch(cmd, rawData);
183     }
184     cameraTest->Close();
185     return true;
186 }
187 
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)188 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
189 {
190     if (size < THRESHOLD) {
191         return 0;
192     }
193 
194     DoSomethingInterestingWithMyApi(data, size);
195     return 0;
196 }
197 }
198