1 /*
2  * Copyright (c) 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 "sinkstubdaudiosinkstub_fuzzer.h"
17 
18 #include <cstddef>
19 #include <cstdint>
20 #include <random>
21 
22 #include "daudio_sink_stub.h"
23 #include "daudio_sink_service.h"
24 
25 #include "daudio_ipc_interface_code.h"
26 #include "if_system_ability_manager.h"
27 #include "iservice_registry.h"
28 
29 namespace OHOS {
30 namespace DistributedHardware {
31 const uint32_t RANGE = 8;
SinkStubDaudioSinkStubFuzzTest(const uint8_t * data,size_t size)32 void SinkStubDaudioSinkStubFuzzTest(const uint8_t* data, size_t size)
33 {
34     if ((data == nullptr) || (size < (sizeof(int32_t)))) {
35         return;
36     }
37     int32_t saId = *(reinterpret_cast<const int32_t*>(data));
38     bool runOnCreate = *(reinterpret_cast<const bool*>(data));
39     auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
40     std::random_device rd;
41     MessageParcel pdata;
42     MessageParcel reply;
43     MessageOption option;
44     std::string devId = "1";
45     std::string dhId = "2";
46     std::string reqId = "3";
47     int32_t status = *(reinterpret_cast<const int32_t*>(data));
48     std::string resultData(reinterpret_cast<const char*>(data), size);
49     pdata.WriteString(devId);
50     pdata.WriteString(dhId);
51     pdata.WriteString(reqId);
52     pdata.WriteInt32(status);
53     pdata.WriteString(resultData);
54     dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::INIT_SINK)] =
55         &DAudioSinkStub::InitSinkInner;
56     dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::RELEASE_SINK)] =
57         &DAudioSinkStub::ReleaseSinkInner;
58     dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::SUBSCRIBE_LOCAL_HARDWARE)] =
59         &DAudioSinkStub::SubscribeLocalHardwareInner;
60     dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::UNSUBSCRIBE_LOCAL_HARDWARE)] =
61         &DAudioSinkStub::UnsubscribeLocalHardwareInner;
62     dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::DAUDIO_NOTIFY)] =
63         &DAudioSinkStub::DAudioNotifyInner;
64     dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE)] =
65         &DAudioSinkStub::PauseDistributedHardwareInner;
66     dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE)] =
67         &DAudioSinkStub::ResumeDistributedHardwareInner;
68     dAudioSinkService->memberFuncMap_[static_cast<uint32_t>(IDAudioSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE)] =
69         &DAudioSinkStub::StopDistributedHardwareInner;
70     const uint32_t code = rd() % RANGE;
71     dAudioSinkService->OnRemoteRequest(code, pdata, reply, option);
72 }
73 
SinkStubSubscribeLocalHardwareInnerFuzzTest(const uint8_t * data,size_t size)74 void SinkStubSubscribeLocalHardwareInnerFuzzTest(const uint8_t* data, size_t size)
75 {
76     if ((data == nullptr) || (size < (sizeof(int32_t)))) {
77         return;
78     }
79     int32_t saId = *(reinterpret_cast<const int32_t*>(data));
80     bool runOnCreate = *(reinterpret_cast<const bool*>(data));
81     auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
82     std::random_device rd;
83     MessageParcel pdata;
84     MessageParcel reply;
85     MessageOption option;
86     std::string devId = "1";
87     std::string dhId = "2";
88     std::string reqId = "3";
89     int32_t status = *(reinterpret_cast<const int32_t*>(data));
90     std::string resultData(reinterpret_cast<const char*>(data), size);
91     pdata.WriteString(devId);
92     pdata.WriteString(dhId);
93     pdata.WriteString(reqId);
94     pdata.WriteInt32(status);
95     pdata.WriteString(resultData);
96     dAudioSinkService->SubscribeLocalHardwareInner(pdata, reply, option);
97 }
98 
SinkStubUnsubscribeLocalHardwareInnerFuzzTest(const uint8_t * data,size_t size)99 void SinkStubUnsubscribeLocalHardwareInnerFuzzTest(const uint8_t* data, size_t size)
100 {
101     if ((data == nullptr) || (size < (sizeof(int32_t)))) {
102         return;
103     }
104     int32_t saId = *(reinterpret_cast<const int32_t*>(data));
105     bool runOnCreate = *(reinterpret_cast<const bool*>(data));
106     auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
107     std::random_device rd;
108     MessageParcel pdata;
109     MessageParcel reply;
110     MessageOption option;
111     std::string devId = "1";
112     std::string dhId = "2";
113     std::string reqId = "3";
114     int32_t status = *(reinterpret_cast<const int32_t*>(data));
115     std::string resultData(reinterpret_cast<const char*>(data), size);
116     pdata.WriteString(devId);
117     pdata.WriteString(dhId);
118     pdata.WriteString(reqId);
119     pdata.WriteInt32(status);
120     pdata.WriteString(resultData);
121     dAudioSinkService->UnsubscribeLocalHardwareInner(pdata, reply, option);
122 }
123 
SinkStubDAudioNotifyInnerFuzzTest(const uint8_t * data,size_t size)124 void SinkStubDAudioNotifyInnerFuzzTest(const uint8_t* data, size_t size)
125 {
126     if ((data == nullptr) || (size < (sizeof(int32_t)))) {
127         return;
128     }
129     int32_t saId = *(reinterpret_cast<const int32_t*>(data));
130     bool runOnCreate = *(reinterpret_cast<const bool*>(data));
131     auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
132     std::random_device rd;
133     MessageParcel pdata;
134     MessageParcel reply;
135     MessageOption option;
136     std::string devId = "1";
137     std::string dhId = "2";
138     std::string reqId = "3";
139     int32_t status = *(reinterpret_cast<const int32_t*>(data));
140     std::string resultData(reinterpret_cast<const char*>(data), size);
141     pdata.WriteString(devId);
142     pdata.WriteString(dhId);
143     pdata.WriteString(reqId);
144     pdata.WriteInt32(status);
145     pdata.WriteString(resultData);
146     dAudioSinkService->DAudioNotifyInner(pdata, reply, option);
147 }
148 
SinkStubPauseDistributedHardwareInnerFuzzTest(const uint8_t * data,size_t size)149 void SinkStubPauseDistributedHardwareInnerFuzzTest(const uint8_t* data, size_t size)
150 {
151     if ((data == nullptr) || (size < (sizeof(int32_t)))) {
152         return;
153     }
154     int32_t saId = *(reinterpret_cast<const int32_t*>(data));
155     bool runOnCreate = *(reinterpret_cast<const bool*>(data));
156     auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
157     std::random_device rd;
158     MessageParcel pdata;
159     MessageParcel reply;
160     MessageOption option;
161     std::string devId = "1";
162     std::string dhId = "2";
163     std::string reqId = "3";
164     int32_t status = *(reinterpret_cast<const int32_t*>(data));
165     std::string resultData(reinterpret_cast<const char*>(data), size);
166     pdata.WriteString(devId);
167     pdata.WriteString(dhId);
168     pdata.WriteString(reqId);
169     pdata.WriteInt32(status);
170     pdata.WriteString(resultData);
171     dAudioSinkService->PauseDistributedHardwareInner(pdata, reply, option);
172 }
173 
SinkStubResumeDistributedHardwareInnerFuzzTest(const uint8_t * data,size_t size)174 void SinkStubResumeDistributedHardwareInnerFuzzTest(const uint8_t* data, size_t size)
175 {
176     if ((data == nullptr) || (size < (sizeof(int32_t)))) {
177         return;
178     }
179     int32_t saId = *(reinterpret_cast<const int32_t*>(data));
180     bool runOnCreate = *(reinterpret_cast<const bool*>(data));
181     auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
182     std::random_device rd;
183     MessageParcel pdata;
184     MessageParcel reply;
185     MessageOption option;
186     std::string devId = "1";
187     std::string dhId = "2";
188     std::string reqId = "3";
189     int32_t status = *(reinterpret_cast<const int32_t*>(data));
190     std::string resultData(reinterpret_cast<const char*>(data), size);
191     pdata.WriteString(devId);
192     pdata.WriteString(dhId);
193     pdata.WriteString(reqId);
194     pdata.WriteInt32(status);
195     pdata.WriteString(resultData);
196     dAudioSinkService->ResumeDistributedHardwareInner(pdata, reply, option);
197 }
198 
SinkStubStopDistributedHardwareInnerFuzzTest(const uint8_t * data,size_t size)199 void SinkStubStopDistributedHardwareInnerFuzzTest(const uint8_t* data, size_t size)
200 {
201     if ((data == nullptr) || (size < (sizeof(int32_t)))) {
202         return;
203     }
204     int32_t saId = *(reinterpret_cast<const int32_t*>(data));
205     bool runOnCreate = *(reinterpret_cast<const bool*>(data));
206     auto dAudioSinkService = std::make_shared<DAudioSinkService>(saId, runOnCreate);
207     std::random_device rd;
208     MessageParcel pdata;
209     MessageParcel reply;
210     MessageOption option;
211     std::string devId = "1";
212     std::string dhId = "2";
213     std::string reqId = "3";
214     int32_t status = *(reinterpret_cast<const int32_t*>(data));
215     std::string resultData(reinterpret_cast<const char*>(data), size);
216     pdata.WriteString(devId);
217     pdata.WriteString(dhId);
218     pdata.WriteString(reqId);
219     pdata.WriteInt32(status);
220     pdata.WriteString(resultData);
221     dAudioSinkService->StopDistributedHardwareInner(pdata, reply, option);
222 }
223 }
224 }
225 
226 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)227 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
228 {
229     /* Run your code on data */
230     OHOS::DistributedHardware::SinkStubDaudioSinkStubFuzzTest(data, size);
231     OHOS::DistributedHardware::SinkStubSubscribeLocalHardwareInnerFuzzTest(data, size);
232     OHOS::DistributedHardware::SinkStubUnsubscribeLocalHardwareInnerFuzzTest(data, size);
233     OHOS::DistributedHardware::SinkStubDAudioNotifyInnerFuzzTest(data, size);
234     OHOS::DistributedHardware::SinkStubPauseDistributedHardwareInnerFuzzTest(data, size);
235     OHOS::DistributedHardware::SinkStubResumeDistributedHardwareInnerFuzzTest(data, size);
236     OHOS::DistributedHardware::SinkStubStopDistributedHardwareInnerFuzzTest(data, size);
237     return 0;
238 }
239