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 "camera_host_fuzzer.h"
17#include "camera.h"
18
19namespace OHOS::Camera {
20const size_t THRESHOLD = 10;
21
22enum HostCmdId {
23    CAMERA_HOST_PRELAUNCH,
24    CAMERA_HOST_GET_CAMERA_ABILITY,
25    CAMERA_HOST_OPEN_CAMERA,
26    CAMERA_HOST_OPEN_CAMERA_V1_1,
27    CAMERA_HOST_SET_FLASH_LIGHTS,
28    CAMERA_HOST_SET_FLASH_LIGHTS_V1_2,
29    CAMERA_HOST_NOTIFY_DEVICE_STATE_CHANGE_INFO,
30    CAMERA_HOST_PRE_CAMERA_SWITCH,
31    CAMERA_HOST_PRELAUNCH_WITH_OPMODE,
32    CAMERA_HOST_OPEN_SECURECAMERA,
33    CAMERA_HOST_END, // Enumerated statistical value. The new enumerated value is added before
34};
35
36void FuncPrelaunch(const uint8_t *rawData, size_t size)
37{
38    if (size < sizeof(struct HDI::Camera::V1_1::PrelaunchConfig)) {
39        return;
40    }
41    cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
42    cameraTest->prelaunchConfig->cameraId = const_cast<char*>(reinterpret_cast<const char*>(rawData));
43    cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
44    cameraTest->prelaunchConfig->setting.push_back(*rawData);
45    cameraTest->serviceV1_3->Prelaunch(*cameraTest->prelaunchConfig);
46}
47
48void FuncGetCameraAbility(const uint8_t *rawData, size_t size)
49{
50    cameraTest->serviceV1_3->GetCameraAbility(const_cast<char*>(reinterpret_cast<const char*>(rawData)),
51        cameraTest->abilityVec);
52}
53
54void FuncOpenCamera(const uint8_t *rawData, size_t size)
55{
56    sptr<HDI::Camera::V1_0::ICameraDevice> g_CameraDevice = nullptr;
57    const sptr<HDI::Camera::V1_0::ICameraDeviceCallback> callback =
58        new HdiCommon::DemoCameraDeviceCallback();
59    cameraTest->serviceV1_3->OpenCamera(
60        const_cast<char*>(reinterpret_cast<const char*>(rawData)), callback, g_CameraDevice);
61}
62
63void FuncOpenCamera_V1_1(const uint8_t *rawData, size_t size)
64{
65    sptr<HDI::Camera::V1_1::ICameraDevice> g_CameraDevice = nullptr;
66    const sptr<HDI::Camera::V1_0::ICameraDeviceCallback> callback =
67        new HdiCommon::DemoCameraDeviceCallback();
68    cameraTest->serviceV1_3->OpenCamera_V1_1(
69        const_cast<char*>(reinterpret_cast<const char*>(rawData)), callback, g_CameraDevice);
70}
71
72void FuncSetFlashlight(const uint8_t *rawData, size_t size)
73{
74    cameraTest->serviceV1_3->SetFlashlight(
75        const_cast<char*>(reinterpret_cast<const char*>(rawData)), true);
76}
77
78void FuncSetFlashlightV1_2(const uint8_t *rawData, size_t size)
79{
80    uint8_t *data = const_cast<uint8_t *>(rawData);
81    cameraTest->serviceV1_3->SetFlashlight_V1_2(*(reinterpret_cast<float *>(data)));
82}
83
84void FuncNotifyDeviceStateChangeInfo(const uint8_t *rawData, size_t size)
85{
86    int *data = const_cast<int *>(reinterpret_cast<const int *>(rawData));
87    cameraTest->serviceV1_3->NotifyDeviceStateChangeInfo(data[0], data[1]);
88}
89
90void FuncPreCameraSwitch(const uint8_t *rawData, size_t size)
91{
92    std::string cameraId = reinterpret_cast<const char*>(rawData);
93    cameraTest->serviceV1_3->PreCameraSwitch(cameraId);
94}
95
96void FuncPrelaunchWithOpMode(const uint8_t *rawData, size_t size)
97{
98    cameraTest->prelaunchConfig = std::make_shared<OHOS::HDI::Camera::V1_1::PrelaunchConfig>();
99    std::string cameraId = reinterpret_cast<const char*>(rawData);
100    cameraTest->prelaunchConfig->cameraId = cameraId;
101    cameraTest->prelaunchConfig->streamInfos_V1_1 = {};
102    cameraTest->prelaunchConfig->setting.push_back(*rawData);
103
104    int *data = const_cast<int *>(reinterpret_cast<const int *>(rawData));
105
106    cameraTest->serviceV1_3->PrelaunchWithOpMode(*cameraTest->prelaunchConfig, data[0]);
107}
108
109void FuncOpenSecureCamera(const uint8_t *rawData, size_t size)
110{
111    sptr<HDI::Camera::V1_3::ICameraDevice> g_CameraDevice = nullptr;
112    const sptr<HDI::Camera::V1_0::ICameraDeviceCallback> callback =
113        new HdiCommon::DemoCameraDeviceCallback();
114    cameraTest->serviceV1_3->OpenSecureCamera(
115        const_cast<char*>(reinterpret_cast<const char*>(rawData)), callback, g_CameraDevice);
116}
117
118static void HostFuncSwitch(uint32_t cmd, const uint8_t *rawData, size_t size)
119{
120    switch (cmd) {
121        case CAMERA_HOST_PRELAUNCH: {
122            FuncPrelaunch(rawData, size);
123            break;
124        }
125        case CAMERA_HOST_GET_CAMERA_ABILITY: {
126            FuncGetCameraAbility(rawData, size);
127            break;
128        }
129        case CAMERA_HOST_OPEN_CAMERA: {
130            FuncOpenCamera(rawData, size);
131            break;
132        }
133        case CAMERA_HOST_OPEN_CAMERA_V1_1: {
134            FuncOpenCamera_V1_1(rawData, size);
135            break;
136        }
137        case CAMERA_HOST_SET_FLASH_LIGHTS: {
138            FuncSetFlashlight(rawData, size);
139            break;
140        }
141        case CAMERA_HOST_SET_FLASH_LIGHTS_V1_2: {
142            FuncSetFlashlightV1_2(rawData, size);
143            break;
144        }
145        case CAMERA_HOST_NOTIFY_DEVICE_STATE_CHANGE_INFO: {
146            FuncNotifyDeviceStateChangeInfo(rawData, size);
147            break;
148        }
149        case CAMERA_HOST_PRE_CAMERA_SWITCH: {
150            FuncPreCameraSwitch(rawData, size);
151            break;
152        }
153        case CAMERA_HOST_PRELAUNCH_WITH_OPMODE: {
154            FuncPrelaunchWithOpMode(rawData, size);
155            break;
156        }
157        case CAMERA_HOST_OPEN_SECURECAMERA: {
158            FuncOpenSecureCamera(rawData, size);
159            break;
160        }
161        default:
162            return;
163    }
164}
165
166bool DoSomethingInterestingWithMyApi(const uint8_t *rawData, size_t size)
167{
168    if (rawData == nullptr) {
169        return false;
170    }
171
172    uint32_t cmd = 0;
173    rawData += sizeof(cmd);
174
175    cameraTest = std::make_shared<OHOS::Camera::HdiCommonV1_3>();
176    cameraTest->Init();
177    if (cameraTest->serviceV1_3 == nullptr) {
178        return false;
179    }
180    cameraTest->Open(DEVICE_0);
181    if (cameraTest->cameraDeviceV1_3 == nullptr) {
182        return false;
183    }
184
185    for (cmd = 0; cmd < CAMERA_HOST_END; cmd++) {
186        HostFuncSwitch(cmd, rawData, size);
187    }
188    cameraTest->Close();
189    return true;
190}
191
192extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
193{
194    if (size < THRESHOLD) {
195        return 0;
196    }
197
198    DoSomethingInterestingWithMyApi(data, size);
199    return 0;
200}
201} // namespace OHOS
202