1 /*
2 * Copyright (c) 2021-2022 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 "offline_stream_operator_fuzzer.h"
17
18 using namespace OHOS::Camera;
19
20 namespace OHOS::Camera {
21 const size_t THRESHOLD = 10;
22
23 enum HostCmdId {
24 OFFLINE_STREAM_OPERATOR_CONCERCAPTURE,
25 OFFLINE_STREAM_OPERATOR_RELEASESTREAMS,
26 OFFLINE_STREAM_OPERATOR_RELEASE,
27 OFFLINE_STREAM_OPERATOR_END,
28 };
29
30 enum BitOperat {
31 INDEX_0 = 0,
32 INDEX_1,
33 INDEX_2,
34 INDEX_3,
35 MOVE_EIGHT_BITS = 8,
36 MOVE_SIXTEEN_BITS = 16,
37 MOVE_TWENTY_FOUR_BITS = 24,
38 };
39
ConvertUint32(const uint8_t * bitOperat)40 static uint32_t ConvertUint32(const uint8_t *bitOperat)
41 {
42 if (bitOperat == nullptr) {
43 return 0;
44 }
45
46 return (bitOperat[INDEX_0] << MOVE_TWENTY_FOUR_BITS) | (bitOperat[INDEX_1] << MOVE_SIXTEEN_BITS) |
47 (bitOperat[INDEX_2] << MOVE_EIGHT_BITS) | (bitOperat[INDEX_3]);
48 }
49
ConvertInt32(const uint8_t * bitOperat)50 static int32_t ConvertInt32(const uint8_t *bitOperat)
51 {
52 if (bitOperat == nullptr) {
53 return 0;
54 }
55
56 return ((int32_t)bitOperat[INDEX_0] << MOVE_TWENTY_FOUR_BITS) | ((int32_t)bitOperat[INDEX_1] << MOVE_SIXTEEN_BITS) |
57 ((int32_t)bitOperat[INDEX_2] << MOVE_EIGHT_BITS) | ((int32_t)bitOperat[INDEX_3]);
58 }
59
FuncCancelCapture(const uint8_t * rawData)60 void FuncCancelCapture(const uint8_t *rawData)
61 {
62 if (rawData == nullptr) {
63 CAMERA_LOGI("%{public}s rawData is null", __FUNCTION__);
64 return;
65 }
66 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
67 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
68 cameraTest->streamOperator);
69 cameraTest->streamInfoSnapshot = std::make_shared<OHOS::HDI::Camera::V1_0::StreamInfo>();
70 cameraTest->DefaultInfosCapture(cameraTest->streamInfoSnapshot);
71 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
72 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
73 cameraTest->captureInfo->streamIds_ = {101};
74 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
75 cameraTest->captureInfo->enableShutterCallback_ = true;
76 bool isStreaming = true;
77 cameraTest->rc = cameraTest->streamOperator->Capture(*rawData, *cameraTest->captureInfo, isStreaming);
78 OHOS::sptr<OHOS::HDI::Camera::V1_0::IStreamOperatorCallback> streamOperatorCallback =
79 new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
80 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
81
82 cameraTest->rc = cameraTest->streamOperator->ChangeToOfflineStream(
83 {cameraTest->streamInfoSnapshot->streamId_}, streamOperatorCallback, offlineStreamOperator);
84 cameraTest->rc = offlineStreamOperator->CancelCapture(*rawData);
85 }
86
FuncReleaseStreams(const uint8_t * rawData)87 void FuncReleaseStreams(const uint8_t *rawData)
88 {
89 if (rawData == nullptr) {
90 CAMERA_LOGI("%{public}s rawData is null", __FUNCTION__);
91 return;
92 }
93 cameraTest->streamOperatorCallback = new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
94 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
95 cameraTest->streamOperator);
96
97 int32_t data = static_cast<int32_t>(ConvertInt32(rawData));
98 OHOS::sptr<OHOS::HDI::Camera::V1_0::IStreamOperatorCallback> streamOperatorCallback =
99 new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
100 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
101
102 cameraTest->rc = cameraTest->streamOperator->ChangeToOfflineStream(
103 {data}, streamOperatorCallback, offlineStreamOperator);
104 cameraTest->rc = offlineStreamOperator->ReleaseStreams({data});
105 }
106
FuncRelease()107 void FuncRelease()
108 {
109 cameraTest->streamInfoSnapshot = std::make_shared<OHOS::HDI::Camera::V1_0::StreamInfo>();
110 cameraTest->DefaultInfosCapture(cameraTest->streamInfoSnapshot);
111 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
112 OHOS::sptr<OHOS::HDI::Camera::V1_0::IStreamOperatorCallback> streamOperatorCallback =
113 new OHOS::Camera::HdiCommon::TestStreamOperatorCallback();
114 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
115
116 cameraTest->rc = cameraTest->streamOperator->ChangeToOfflineStream(
117 {cameraTest->streamInfoSnapshot->streamId_}, streamOperatorCallback, offlineStreamOperator);
118 cameraTest->rc = offlineStreamOperator->Release();
119 }
120
HostFuncSwitch(uint32_t cmd,const uint8_t * rawData)121 static void HostFuncSwitch(uint32_t cmd, const uint8_t *rawData)
122 {
123 switch (cmd) {
124 case OFFLINE_STREAM_OPERATOR_CONCERCAPTURE: {
125 FuncCancelCapture(rawData);
126 break;
127 }
128 case OFFLINE_STREAM_OPERATOR_RELEASESTREAMS: {
129 FuncReleaseStreams(rawData);
130 break;
131 }
132 case OFFLINE_STREAM_OPERATOR_RELEASE:
133 FuncRelease();
134 break;
135 default:
136 return;
137 }
138 }
139
DoSomethingInterestingWithMyApi(const uint8_t * rawData,size_t size)140 bool DoSomethingInterestingWithMyApi(const uint8_t *rawData, size_t size)
141 {
142 (void)size;
143 if (rawData == nullptr) {
144 return false;
145 }
146
147 uint32_t cmd = ConvertUint32(rawData);
148 rawData += sizeof(cmd);
149
150 cameraTest = std::make_shared<OHOS::Camera::HdiCommon>();
151 cameraTest->Init();
152 if (cameraTest->service == nullptr) {
153 return false;
154 }
155 cameraTest->Open();
156 if (cameraTest->cameraDevice == nullptr) {
157 return false;
158 }
159 for (cmd = 0; cmd < OFFLINE_STREAM_OPERATOR_END; cmd++) {
160 HostFuncSwitch(cmd, rawData);
161 }
162 cameraTest->Close();
163 return true;
164 }
165
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)166 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
167 {
168 if (size < THRESHOLD) {
169 return 0;
170 }
171
172 DoSomethingInterestingWithMyApi(data, size);
173 return 0;
174 }
175 } // namespace OHOS
176