1 /*
2 * Copyright (c) 2024-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 "distributedfwkservices_fuzzer.h"
17
18 #include <algorithm>
19 #include <chrono>
20 #include <cstddef>
21 #include <cstdint>
22 #include <string>
23 #include <unistd.h>
24
25 #include "distributed_hardware_errno.h"
26 #include "distributed_hardware_service.h"
27
28 namespace OHOS {
29 namespace DistributedHardware {
30 namespace {
31 const int32_t SAID = 4801;
32 const uint32_t QUERY_LOCAL_SYS_SIZE = 6;
33 const QueryLocalSysSpecType SPEC_TYPE[QUERY_LOCAL_SYS_SIZE] = {
34 QueryLocalSysSpecType::MIN, QueryLocalSysSpecType::HISTREAMER_AUDIO_ENCODER,
35 QueryLocalSysSpecType::HISTREAMER_AUDIO_DECODER, QueryLocalSysSpecType::HISTREAMER_VIDEO_ENCODER,
36 QueryLocalSysSpecType::HISTREAMER_VIDEO_DECODER, QueryLocalSysSpecType::MAX
37 };
38 }
39
40 class MyFwkServicesFuzzTest : public IRemoteStub<IPublisherListener> {
41 public:
AsObject()42 virtual sptr<IRemoteObject> AsObject() override
43 {
44 return nullptr;
45 }
OnMessage(const DHTopic topic,const std::string & message)46 void OnMessage(const DHTopic topic, const std::string& message) override
47 {
48 return;
49 }
50 };
51
FwkServicesQueryLocalSysSpecFuzzTest(const uint8_t * data,size_t size)52 void FwkServicesQueryLocalSysSpecFuzzTest(const uint8_t* data, size_t size)
53 {
54 if ((data == nullptr) || (size < sizeof(uint32_t))) {
55 return;
56 }
57 DistributedHardwareService service(SAID, true);
58 uint32_t sysSpec = *(reinterpret_cast<const uint32_t*>(data));
59 QueryLocalSysSpecType spec = SPEC_TYPE[sysSpec % QUERY_LOCAL_SYS_SIZE];
60
61 service.QueryLocalSysSpec(spec);
62 }
63
FwkServicesQueryDhSysSpecFuzzTest(const uint8_t * data,size_t size)64 void FwkServicesQueryDhSysSpecFuzzTest(const uint8_t* data, size_t size)
65 {
66 if ((data == nullptr) || (size == 0)) {
67 return;
68 }
69 DistributedHardwareService service(SAID, true);
70 std::string targetKey(reinterpret_cast<const char*>(data), size);
71 std::string attrs(reinterpret_cast<const char*>(data), size);
72
73 service.QueryDhSysSpec(targetKey, attrs);
74 }
75
FwkServicesNotifySourceRemoteSinkStartedFuzzTest(const uint8_t * data,size_t size)76 void FwkServicesNotifySourceRemoteSinkStartedFuzzTest(const uint8_t* data, size_t size)
77 {
78 if ((data == nullptr) || (size == 0)) {
79 return;
80 }
81 DistributedHardwareService service(SAID, true);
82 std::string deviceId(reinterpret_cast<const char*>(data), size);
83
84 service.NotifySourceRemoteSinkStarted(deviceId);
85 }
86
FwkServicesPauseDistributedHardwareFuzzTest(const uint8_t * data,size_t size)87 void FwkServicesPauseDistributedHardwareFuzzTest(const uint8_t* data, size_t size)
88 {
89 if ((data == nullptr) || (size == 0)) {
90 return;
91 }
92 DistributedHardwareService service(SAID, true);
93 DHType dhType = DHType::AUDIO;
94 std::string networkId(reinterpret_cast<const char*>(data), size);
95
96 service.PauseDistributedHardware(dhType, networkId);
97 }
98
FwkServicesResumeDistributedHardwareFuzzTest(const uint8_t * data,size_t size)99 void FwkServicesResumeDistributedHardwareFuzzTest(const uint8_t* data, size_t size)
100 {
101 if ((data == nullptr) || (size == 0)) {
102 return;
103 }
104 DistributedHardwareService service(SAID, true);
105 DHType dhType = DHType::AUDIO;
106 std::string networkId(reinterpret_cast<const char*>(data), size);
107
108 service.ResumeDistributedHardware(dhType, networkId);
109 }
110
FwkServicesStopDistributedHardwareFuzzTest(const uint8_t * data,size_t size)111 void FwkServicesStopDistributedHardwareFuzzTest(const uint8_t* data, size_t size)
112 {
113 if ((data == nullptr) || (size == 0)) {
114 return;
115 }
116 DistributedHardwareService service(SAID, true);
117 DHType dhType = DHType::AUDIO;
118 std::string networkId(reinterpret_cast<const char*>(data), size);
119
120 service.StopDistributedHardware(dhType, networkId);
121 }
122
FwkServicesGetDistributedHardwareFuzzTest(const uint8_t * data,size_t size)123 void FwkServicesGetDistributedHardwareFuzzTest(const uint8_t* data, size_t size)
124 {
125 if ((data == nullptr) || (size == 0)) {
126 return;
127 }
128 DistributedHardwareService service(SAID, true);
129 std::string networkId(reinterpret_cast<const char*>(data), size);
130 std::vector<DHDescriptor> descriptors;
131
132 service.GetDistributedHardware(networkId, descriptors);
133 }
134
FwkServicesRegisterDHStatusListenerFuzzTest(const uint8_t * data,size_t size)135 void FwkServicesRegisterDHStatusListenerFuzzTest(const uint8_t* data, size_t size)
136 {
137 if ((data == nullptr) || (size == 0)) {
138 return;
139 }
140 DistributedHardwareService service(SAID, true);
141 std::string networkId(reinterpret_cast<const char*>(data), size);
142 sptr<IHDSourceStatusListener> listener = nullptr;
143
144 service.RegisterDHStatusListener(networkId, listener);
145 }
146
FwkServicesUnregisterDHStatusListenerFuzzTest(const uint8_t * data,size_t size)147 void FwkServicesUnregisterDHStatusListenerFuzzTest(const uint8_t* data, size_t size)
148 {
149 if ((data == nullptr) || (size == 0)) {
150 return;
151 }
152 DistributedHardwareService service(SAID, true);
153 std::string networkId(reinterpret_cast<const char*>(data), size);
154 sptr<IHDSourceStatusListener> listener = nullptr;
155
156 service.UnregisterDHStatusListener(networkId, listener);
157 }
158
FwkServicesEnableSinkFuzzTest(const uint8_t * data,size_t size)159 void FwkServicesEnableSinkFuzzTest(const uint8_t* data, size_t size)
160 {
161 if ((data == nullptr) || (size == 0)) {
162 return;
163 }
164 DistributedHardwareService service(SAID, true);
165 std::vector<DHDescriptor> descriptors = {
166 { std::string(reinterpret_cast<const char*>(data), size), DHType::AUDIO }
167 };
168
169 service.EnableSink(descriptors);
170 }
171
FwkServicesDisableSinkFuzzTest(const uint8_t * data,size_t size)172 void FwkServicesDisableSinkFuzzTest(const uint8_t* data, size_t size)
173 {
174 if ((data == nullptr) || (size == 0)) {
175 return;
176 }
177 DistributedHardwareService service(SAID, true);
178 std::vector<DHDescriptor> descriptors = {
179 { std::string(reinterpret_cast<const char*>(data), size), DHType::AUDIO }
180 };
181
182 service.DisableSink(descriptors);
183 }
184
FwkServicesEnableSourceFuzzTest(const uint8_t * data,size_t size)185 void FwkServicesEnableSourceFuzzTest(const uint8_t* data, size_t size)
186 {
187 if ((data == nullptr) || (size == 0)) {
188 return;
189 }
190 DistributedHardwareService service(SAID, true);
191 std::string networkId(reinterpret_cast<const char*>(data), size);
192 std::vector<DHDescriptor> descriptors = {
193 { std::string(reinterpret_cast<const char*>(data), size), DHType::AUDIO }
194 };
195
196 service.EnableSource(networkId, descriptors);
197 }
198
FwkServicesDisableSourceFuzzTest(const uint8_t * data,size_t size)199 void FwkServicesDisableSourceFuzzTest(const uint8_t* data, size_t size)
200 {
201 if ((data == nullptr) || (size == 0)) {
202 return;
203 }
204 DistributedHardwareService service(SAID, true);
205 std::string networkId(reinterpret_cast<const char*>(data), size);
206 std::vector<DHDescriptor> descriptors = {
207 { std::string(reinterpret_cast<const char*>(data), size), DHType::AUDIO }
208 };
209
210 service.DisableSource(networkId, descriptors);
211 }
212 }
213 }
214
215 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)216 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
217 {
218 /* Run your code on data */
219 OHOS::DistributedHardware::FwkServicesQueryLocalSysSpecFuzzTest(data, size);
220 OHOS::DistributedHardware::FwkServicesQueryDhSysSpecFuzzTest(data, size);
221 OHOS::DistributedHardware::FwkServicesPauseDistributedHardwareFuzzTest(data, size);
222 OHOS::DistributedHardware::FwkServicesResumeDistributedHardwareFuzzTest(data, size);
223 OHOS::DistributedHardware::FwkServicesStopDistributedHardwareFuzzTest(data, size);
224 return 0;
225 }
226