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 {
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->streamInfoSnapshot = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
67 cameraTest->DefaultInfosCapture(cameraTest->streamInfoSnapshot);
68 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
69 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
70 cameraTest->captureInfo->streamIds_ = {101};
71 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
72 cameraTest->captureInfo->enableShutterCallback_ = true;
73 bool isStreaming = true;
74 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->Capture(*rawData, *cameraTest->captureInfo, isStreaming);
75 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback =
76 new OHOS::Camera::CameraManager::TestStreamOperatorCallback();
77 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
78
79 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->ChangeToOfflineStream(
80 {cameraTest->streamInfoSnapshot->v1_0.streamId_}, streamOperatorCallback, offlineStreamOperator);
81 cameraTest->rc = (CamRetCode)offlineStreamOperator->CancelCapture(*rawData);
82 }
83
FuncReleaseStreams(const uint8_t * rawData)84 void FuncReleaseStreams(const uint8_t *rawData)
85 {
86 if (rawData == nullptr) {
87 CAMERA_LOGI("%{public}s rawData is null", __FUNCTION__);
88 return;
89 }
90 cameraTest->streamOperatorCallback = new OHOS::Camera::CameraManager::TestStreamOperatorCallback();
91 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
92 cameraTest->streamOperator);
93
94 int32_t data = static_cast<int32_t>(ConvertInt32(rawData));
95 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback =
96 new OHOS::Camera::CameraManager::TestStreamOperatorCallback();
97 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
98
99 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->ChangeToOfflineStream(
100 {data}, streamOperatorCallback, offlineStreamOperator);
101 cameraTest->rc = (CamRetCode)offlineStreamOperator->ReleaseStreams({data});
102 }
103
FuncRelease()104 void FuncRelease()
105 {
106 cameraTest->streamOperatorCallback = new OHOS::Camera::CameraManager::TestStreamOperatorCallback();
107 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
108 cameraTest->streamOperator);
109
110 cameraTest->streamInfoSnapshot = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
111 cameraTest->DefaultInfosCapture(cameraTest->streamInfoSnapshot);
112 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
113 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback =
114 new OHOS::Camera::CameraManager::TestStreamOperatorCallback();
115 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
116
117 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->ChangeToOfflineStream(
118 {cameraTest->streamInfoSnapshot->v1_0.streamId_}, streamOperatorCallback, offlineStreamOperator);
119 cameraTest->rc = (CamRetCode)offlineStreamOperator->Release();
120 }
121
HostFuncSwitch(uint32_t cmd,const uint8_t * rawData)122 static void HostFuncSwitch(uint32_t cmd, const uint8_t *rawData)
123 {
124 switch (cmd) {
125 case OFFLINE_STREAM_OPERATOR_CONCERCAPTURE: {
126 FuncCancelCapture(rawData);
127 break;
128 }
129 case OFFLINE_STREAM_OPERATOR_RELEASESTREAMS: {
130 FuncReleaseStreams(rawData);
131 break;
132 }
133 case OFFLINE_STREAM_OPERATOR_RELEASE:
134 FuncRelease();
135 break;
136 default:
137 return;
138 }
139 }
140
DoSomethingInterestingWithMyApi(const uint8_t * rawData,size_t size)141 bool DoSomethingInterestingWithMyApi(const uint8_t *rawData, size_t size)
142 {
143 (void)size;
144 if (rawData == nullptr) {
145 return false;
146 }
147
148 uint32_t cmd = ConvertUint32(rawData);
149 rawData += sizeof(cmd);
150
151 cameraTest = std::make_shared<OHOS::Camera::CameraManager>();
152 cameraTest->intents = {STILL_CAPTURE};
153 cameraTest->Init();
154 if (cameraTest->serviceV1_2 == nullptr) {
155 return false;
156 }
157 cameraTest->Open();
158 if (cameraTest->cameraDeviceV1_2 == nullptr) {
159 return false;
160 }
161 cameraTest->StartStream(cameraTest->intents);
162 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
163 for (cmd = 0; cmd < OFFLINE_STREAM_OPERATOR_END; cmd++) {
164 HostFuncSwitch(cmd, rawData);
165 }
166 cameraTest->Close();
167 return true;
168 }
169
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)170 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
171 {
172 if (size < OHOS::THRESHOLD) {
173 return 0;
174 }
175
176 OHOS::DoSomethingInterestingWithMyApi(data, size);
177 return 0;
178 }
179 } // namespace OHOS
180