1 /*
2 * Copyright (c) 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 "allconnectmanager_fuzzer.h"
17
18 #include <fuzzer/FuzzedDataProvider.h>
19
20 #include "distributed_camera_allconnect_manager.h"
21
22 constexpr size_t maxStringLength = 64;
23 namespace OHOS {
24 namespace DistributedHardware {
DCameraAllConnectManagerInitFuzzTest(const uint8_t * data,size_t size)25 void DCameraAllConnectManagerInitFuzzTest(const uint8_t* data, size_t size)
26 {
27 if (data == nullptr || size == 0) {
28 return;
29 }
30
31 FuzzedDataProvider fuzzedData(data, size);
32 #ifdef __LP64__
33 constexpr const char *tmpAllConnectSoPath = "/system/lib64/";
34 #else
35 constexpr const char *tmpAllConnectSoPath = "/system/lib/";
36 #endif
37 std::string randomPath = fuzzedData.ConsumeRandomLengthString(PATH_MAX);
38 std::string allConnectSoPath = tmpAllConnectSoPath;
39 allConnectSoPath = randomPath;
40
41 DCameraAllConnectManager::GetInstance().InitDCameraAllConnectManager();
42 }
43
DCameraAllConnectManagerUnInitFuzzTest(const uint8_t * data,size_t size)44 void DCameraAllConnectManagerUnInitFuzzTest(const uint8_t* data, size_t size)
45 {
46 if (data == nullptr || size == 0) {
47 return;
48 }
49
50 FuzzedDataProvider fuzzedData(data, size);
51 void* randomDllHandle = reinterpret_cast<void*>(fuzzedData.ConsumeIntegral<uintptr_t>());
52 const_cast<void*&>(DCameraAllConnectManager::GetInstance().dllHandle_) = randomDllHandle;
53
54 DCameraAllConnectManager::GetInstance().UnInitDCameraAllConnectManager();
55 }
56
DCameraAllConnectManagerIsInitedFuzzTest(const uint8_t * data,size_t size)57 void DCameraAllConnectManagerIsInitedFuzzTest(const uint8_t* data, size_t size)
58 {
59 if (data == nullptr || size == 0) {
60 return;
61 }
62
63 FuzzedDataProvider fuzzedData(data, size);
64 bool randomInitState = fuzzedData.ConsumeBool();
65 const_cast<bool&>(DCameraAllConnectManager::GetInstance().bInited_) = randomInitState;
66
67 DCameraAllConnectManager::GetInstance().IsInited();
68 }
69
DCameraAllConnectManagerPublishServiceStateFuzzTest(const uint8_t * data,size_t size)70 void DCameraAllConnectManagerPublishServiceStateFuzzTest(const uint8_t* data, size_t size)
71 {
72 if (data == nullptr || size == 0) {
73 return;
74 }
75
76 FuzzedDataProvider fuzzedData(data, size);
77 std::string peerNetworkId = fuzzedData.ConsumeRandomLengthString(maxStringLength);
78 std::string dhId = fuzzedData.ConsumeRandomLengthString(maxStringLength);
79 DCameraCollaborationBussinessStatus state = static_cast<DCameraCollaborationBussinessStatus>(
80 fuzzedData.ConsumeIntegralInRange<int32_t>(SCM_IDLE, SCM_CONNECTED));
81
82 DCameraAllConnectManager::GetInstance().PublishServiceState(peerNetworkId, dhId, state);
83 }
84
DCameraAllConnectManagerApplyAdvancedResourceFuzzTest(const uint8_t * data,size_t size)85 void DCameraAllConnectManagerApplyAdvancedResourceFuzzTest(const uint8_t* data, size_t size)
86 {
87 if (data == nullptr || size == 0) {
88 return;
89 }
90
91 FuzzedDataProvider fuzzedData(data, size);
92 std::string peerNetworkId = fuzzedData.ConsumeRandomLengthString(maxStringLength);
93 DCameraCollaborationResourceRequestInfoSets resourceRequest;
94 resourceRequest.remoteHardwareListSize = fuzzedData.ConsumeIntegral<uint32_t>();
95 resourceRequest.localHardwareListSize = fuzzedData.ConsumeIntegral<uint32_t>();
96 resourceRequest.communicationRequest = nullptr;
97
98 DCameraAllConnectManager::GetInstance().ApplyAdvancedResource(peerNetworkId, &resourceRequest);
99 }
100
DCameraAllConnectManagerGetAllConnectSoLoadFuzzTest(const uint8_t * data,size_t size)101 void DCameraAllConnectManagerGetAllConnectSoLoadFuzzTest(const uint8_t* data, size_t size)
102 {
103 if (data == nullptr || size == 0) {
104 return;
105 }
106
107 FuzzedDataProvider fuzzedData(data, size);
108 #ifdef __LP64__
109 constexpr const char *tmpAllConnectSoPath = "/system/lib64/";
110 #else
111 constexpr const char *tmpAllConnectSoPath = "/system/lib/";
112 #endif
113 std::string randomPath = fuzzedData.ConsumeRandomLengthString(PATH_MAX + 10);
114 std::string allConnectSoPath = tmpAllConnectSoPath;
115 allConnectSoPath = randomPath;
116
117 DCameraAllConnectManager::GetInstance().GetAllConnectSoLoad();
118 }
119
DCameraAllConnectManagerRegisterLifecycleCallbackFuzzTest(const uint8_t * data,size_t size)120 void DCameraAllConnectManagerRegisterLifecycleCallbackFuzzTest(const uint8_t* data, size_t size)
121 {
122 if (data == nullptr || size == 0) {
123 return;
124 }
125
126 FuzzedDataProvider fuzzedData(data, size);
127 std::string serviceName = fuzzedData.ConsumeRandomLengthString(maxStringLength);
128 const_cast<std::string&>(DCameraAllConnectManager::SERVICE_NAME) = serviceName;
129
130 DCameraAllConnectManager::GetInstance().RegisterLifecycleCallback();
131 }
132
DCameraAllConnectManagerUnRegisterLifecycleCallbackFuzzTest(const uint8_t * data,size_t size)133 void DCameraAllConnectManagerUnRegisterLifecycleCallbackFuzzTest(const uint8_t* data, size_t size)
134 {
135 if (data == nullptr || size == 0) {
136 return;
137 }
138
139 FuzzedDataProvider fuzzedData(data, size);
140 std::string serviceName = fuzzedData.ConsumeRandomLengthString(maxStringLength);
141 const_cast<std::string&>(DCameraAllConnectManager::SERVICE_NAME) = serviceName;
142
143 DCameraAllConnectManager::GetInstance().UnRegisterLifecycleCallback();
144 }
145
DCameraAllConnectManagerOnStopFuzzTest(const uint8_t * data,size_t size)146 void DCameraAllConnectManagerOnStopFuzzTest(const uint8_t* data, size_t size)
147 {
148 if (data == nullptr || size == 0) {
149 return;
150 }
151
152 FuzzedDataProvider fuzzedData(data, size);
153 std::string peerNetworkId = fuzzedData.ConsumeRandomLengthString(maxStringLength);
154
155 DCameraAllConnectManager::GetInstance().OnStop(peerNetworkId.c_str());
156 }
157
DCameraAllConnectManagerRemoveSinkNetworkIdFuzzTest(const uint8_t * data,size_t size)158 void DCameraAllConnectManagerRemoveSinkNetworkIdFuzzTest(const uint8_t* data, size_t size)
159 {
160 if (data == nullptr || size == 0) {
161 return;
162 }
163
164 FuzzedDataProvider fuzzedData(data, size);
165 int32_t sessionId = fuzzedData.ConsumeIntegral<int32_t>();
166
167 DCameraAllConnectManager::GetInstance().RemoveSinkNetworkId(sessionId);
168 }
169
DCameraAllConnectManagerRemoveSourceNetworkIdFuzzTest(const uint8_t * data,size_t size)170 void DCameraAllConnectManagerRemoveSourceNetworkIdFuzzTest(const uint8_t* data, size_t size)
171 {
172 if (data == nullptr || size == 0) {
173 return;
174 }
175
176 FuzzedDataProvider fuzzedData(data, size);
177 int32_t sessionId = fuzzedData.ConsumeIntegral<int32_t>();
178 DCameraAllConnectManager::GetInstance().RemoveSourceNetworkId(sessionId);
179 }
180
DCameraAllConnectManagerSetSourceNetworkIdFuzzTest(const uint8_t * data,size_t size)181 void DCameraAllConnectManagerSetSourceNetworkIdFuzzTest(const uint8_t* data, size_t size)
182 {
183 if (data == nullptr || size == 0) {
184 return;
185 }
186
187 FuzzedDataProvider fuzzedData(data, size);
188 std::string networkId = fuzzedData.ConsumeRandomLengthString(maxStringLength);
189 int32_t socket = fuzzedData.ConsumeIntegral<int32_t>();
190
191 DCameraAllConnectManager::GetInstance().SetSourceNetworkId(networkId, socket);
192 }
193
DCameraAllConnectManagerSetSinkNetWorkIdFuzzTest(const uint8_t * data,size_t size)194 void DCameraAllConnectManagerSetSinkNetWorkIdFuzzTest(const uint8_t* data, size_t size)
195 {
196 if (data == nullptr || size == 0) {
197 return;
198 }
199
200 FuzzedDataProvider fuzzedData(data, size);
201 std::string networkId = fuzzedData.ConsumeRandomLengthString(maxStringLength);
202 int32_t socket = fuzzedData.ConsumeIntegral<int32_t>();
203
204 DCameraAllConnectManager::GetInstance().SetSinkNetWorkId(networkId, socket);
205 }
206
DCameraAllConnectManagerGetSinkDevIdBySocketFuzzTest(const uint8_t * data,size_t size)207 void DCameraAllConnectManagerGetSinkDevIdBySocketFuzzTest(const uint8_t* data, size_t size)
208 {
209 if (data == nullptr || size == 0) {
210 return;
211 }
212
213 FuzzedDataProvider fuzzedData(data, size);
214 int32_t socket = fuzzedData.ConsumeIntegral<int32_t>();
215
216 DCameraAllConnectManager::GetInstance().GetSinkDevIdBySocket(socket);
217 }
218
DCameraAllConnectManagerGetSinkSocketByNetWorkIdFuzzTest(const uint8_t * data,size_t size)219 void DCameraAllConnectManagerGetSinkSocketByNetWorkIdFuzzTest(const uint8_t* data, size_t size)
220 {
221 if (data == nullptr || size == 0) {
222 return;
223 }
224
225 FuzzedDataProvider fuzzedData(data, size);
226 std::string networkId = fuzzedData.ConsumeRandomLengthString(maxStringLength);
227
228 DCameraAllConnectManager::GetInstance().GetSinkSocketByNetWorkId(networkId);
229 }
230
DCameraAllConnectManagerGetSourceSocketByNetworkIdFuzzTest(const uint8_t * data,size_t size)231 void DCameraAllConnectManagerGetSourceSocketByNetworkIdFuzzTest(const uint8_t* data, size_t size)
232 {
233 if (data == nullptr || size == 0) {
234 return;
235 }
236
237 FuzzedDataProvider fuzzedData(data, size);
238 std::string networkId = fuzzedData.ConsumeRandomLengthString(maxStringLength);
239
240 DCameraAllConnectManager::GetInstance().GetSourceSocketByNetworkId(networkId);
241 }
242 }
243 }
244
245 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)246 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
247 {
248 /* Run your code on data */
249 OHOS::DistributedHardware::DCameraAllConnectManagerInitFuzzTest(data, size);
250 OHOS::DistributedHardware::DCameraAllConnectManagerUnInitFuzzTest(data, size);
251 OHOS::DistributedHardware::DCameraAllConnectManagerIsInitedFuzzTest(data, size);
252 OHOS::DistributedHardware::DCameraAllConnectManagerPublishServiceStateFuzzTest(data, size);
253 OHOS::DistributedHardware::DCameraAllConnectManagerApplyAdvancedResourceFuzzTest(data, size);
254 OHOS::DistributedHardware::DCameraAllConnectManagerGetAllConnectSoLoadFuzzTest(data, size);
255 OHOS::DistributedHardware::DCameraAllConnectManagerRegisterLifecycleCallbackFuzzTest(data, size);
256 OHOS::DistributedHardware::DCameraAllConnectManagerUnRegisterLifecycleCallbackFuzzTest(data, size);
257 OHOS::DistributedHardware::DCameraAllConnectManagerOnStopFuzzTest(data, size);
258 OHOS::DistributedHardware::DCameraAllConnectManagerRemoveSinkNetworkIdFuzzTest(data, size);
259 OHOS::DistributedHardware::DCameraAllConnectManagerRemoveSourceNetworkIdFuzzTest(data, size);
260 OHOS::DistributedHardware::DCameraAllConnectManagerSetSourceNetworkIdFuzzTest(data, size);
261 OHOS::DistributedHardware::DCameraAllConnectManagerSetSinkNetWorkIdFuzzTest(data, size);
262 OHOS::DistributedHardware::DCameraAllConnectManagerGetSinkDevIdBySocketFuzzTest(data, size);
263 OHOS::DistributedHardware::DCameraAllConnectManagerGetSinkSocketByNetWorkIdFuzzTest(data, size);
264 OHOS::DistributedHardware::DCameraAllConnectManagerGetSourceSocketByNetworkIdFuzzTest(data, size);
265 return 0;
266 }