1 /*
2 * Copyright (c) 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 "getcellulardatastate_fuzzer.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #define private public
21 #include "adddatatoken_fuzzer.h"
22 #include "cellular_data_ipc_interface_code.h"
23 #include "cellular_data_service.h"
24 #include "cellular_data_service_stub.h"
25 #include "system_ability_definition.h"
26 #include <fuzzer/FuzzedDataProvider.h>
27
28 using namespace OHOS::Telephony;
29 namespace OHOS {
30 static bool g_isInited = false;
31 constexpr int32_t SLOT_NUM_MAX = 3;
32
IsServiceInited()33 bool IsServiceInited()
34 {
35 if (!g_isInited) {
36 DelayedSingleton<CellularDataService>::GetInstance()->OnStart();
37 if (DelayedSingleton<CellularDataService>::GetInstance()->GetServiceRunningState() ==
38 static_cast<int32_t>(ServiceRunningState::STATE_RUNNING)) {
39 g_isInited = true;
40 }
41 }
42 return g_isInited;
43 }
44
OnRemoteRequest(const uint8_t * data,size_t size)45 void OnRemoteRequest(const uint8_t *data, size_t size)
46 {
47 if (!IsServiceInited()) {
48 return;
49 }
50
51 MessageParcel dataMessageParcel;
52 if (!dataMessageParcel.WriteInterfaceToken(CellularDataServiceStub::GetDescriptor())) {
53 return;
54 }
55 dataMessageParcel.WriteBuffer(data, size);
56 dataMessageParcel.RewindRead(0);
57 FuzzedDataProvider fdp(data, size);
58 uint32_t code = fdp.ConsumeIntegralInRange<uint32_t>(0,
59 static_cast<uint32_t>(CellularDataInterfaceCode::GET_SUPPLIER_REGISTER_STATE) + 1);
60 MessageParcel reply;
61 MessageOption option;
62 DelayedSingleton<CellularDataService>::GetInstance()->OnRemoteRequest(code, dataMessageParcel, reply, option);
63 }
64
EnableCellularData(const uint8_t * data,size_t size)65 void EnableCellularData(const uint8_t *data, size_t size)
66 {
67 if (!IsServiceInited()) {
68 return;
69 }
70
71 MessageParcel dataMessageParcel;
72 dataMessageParcel.WriteBuffer(data, size);
73 dataMessageParcel.RewindRead(0);
74 MessageParcel reply;
75 DelayedSingleton<CellularDataService>::GetInstance()->OnEnableCellularData(dataMessageParcel, reply);
76 }
77
GetCellularDataState(const uint8_t * data,size_t size)78 void GetCellularDataState(const uint8_t *data, size_t size)
79 {
80 if (!IsServiceInited()) {
81 return;
82 }
83
84 MessageParcel dataMessageParcel;
85 dataMessageParcel.WriteBuffer(data, size);
86 dataMessageParcel.RewindRead(0);
87 MessageParcel reply;
88 DelayedSingleton<CellularDataService>::GetInstance()->OnGetCellularDataState(dataMessageParcel, reply);
89 }
90
IsCellularDataEnabled(const uint8_t * data,size_t size)91 void IsCellularDataEnabled(const uint8_t *data, size_t size)
92 {
93 if (!IsServiceInited()) {
94 return;
95 }
96
97 MessageParcel dataMessageParcel;
98 dataMessageParcel.WriteBuffer(data, size);
99 dataMessageParcel.RewindRead(0);
100 MessageParcel reply;
101 DelayedSingleton<CellularDataService>::GetInstance()->OnIsCellularDataEnabled(dataMessageParcel, reply);
102 }
103
IsCellularDataRoamingEnabled(const uint8_t * data,size_t size)104 void IsCellularDataRoamingEnabled(const uint8_t *data, size_t size)
105 {
106 if (!IsServiceInited()) {
107 return;
108 }
109 FuzzedDataProvider fdp(data, size);
110 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
111 MessageParcel dataMessageParcel;
112 dataMessageParcel.WriteInt32(slotId);
113 dataMessageParcel.WriteBuffer(data, size);
114 dataMessageParcel.RewindRead(0);
115 MessageParcel reply;
116 DelayedSingleton<CellularDataService>::GetInstance()->OnIsCellularDataRoamingEnabled(dataMessageParcel, reply);
117 }
118
GetDefaultCellularDataSlotId(const uint8_t * data,size_t size)119 void GetDefaultCellularDataSlotId(const uint8_t *data, size_t size)
120 {
121 if (!IsServiceInited()) {
122 return;
123 }
124
125 MessageParcel dataMessageParcel;
126 dataMessageParcel.WriteBuffer(data, size);
127 dataMessageParcel.RewindRead(0);
128 MessageParcel reply;
129 DelayedSingleton<CellularDataService>::GetInstance()->OnGetDefaultCellularDataSlotId(dataMessageParcel, reply);
130 }
131
EnableCellularDataRoaming(const uint8_t * data,size_t size)132 void EnableCellularDataRoaming(const uint8_t *data, size_t size)
133 {
134 if (!IsServiceInited()) {
135 return;
136 }
137
138 FuzzedDataProvider fdp(data, size);
139 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
140 MessageParcel dataMessageParcel;
141 dataMessageParcel.WriteInt32(slotId);
142 dataMessageParcel.WriteBuffer(data, size);
143 dataMessageParcel.RewindRead(0);
144 MessageParcel reply;
145 DelayedSingleton<CellularDataService>::GetInstance()->OnEnableCellularDataRoaming(dataMessageParcel, reply);
146 }
147
SetDefaultCellularDataSlotId(const uint8_t * data,size_t size)148 void SetDefaultCellularDataSlotId(const uint8_t *data, size_t size)
149 {
150 if (!IsServiceInited()) {
151 return;
152 }
153
154 FuzzedDataProvider fdp(data, size);
155 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
156 MessageParcel dataMessageParcel;
157 dataMessageParcel.WriteInt32(slotId);
158 dataMessageParcel.WriteBuffer(data, size);
159 dataMessageParcel.RewindRead(0);
160 MessageParcel reply;
161 DelayedSingleton<CellularDataService>::GetInstance()->OnSetDefaultCellularDataSlotId(dataMessageParcel, reply);
162 }
163
HasInternetCapability(const uint8_t * data,size_t size)164 void HasInternetCapability(const uint8_t *data, size_t size)
165 {
166 if (!IsServiceInited()) {
167 return;
168 }
169
170 FuzzedDataProvider fdp(data, size);
171 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
172 MessageParcel dataMessageParcel;
173 dataMessageParcel.WriteInt32(slotId);
174 dataMessageParcel.WriteBuffer(data, size);
175 dataMessageParcel.RewindRead(0);
176 MessageParcel reply;
177 DelayedSingleton<CellularDataService>::GetInstance()->OnHasInternetCapability(dataMessageParcel, reply);
178 }
179
ClearCellularDataConnections(const uint8_t * data,size_t size)180 void ClearCellularDataConnections(const uint8_t *data, size_t size)
181 {
182 if (!IsServiceInited()) {
183 return;
184 }
185
186 FuzzedDataProvider fdp(data, size);
187 int32_t slotId = fdp.ConsumeIntegralInRange<uint32_t>(0, SLOT_NUM_MAX);
188 MessageParcel dataMessageParcel;
189 dataMessageParcel.WriteInt32(slotId);
190 dataMessageParcel.WriteBuffer(data, size);
191 dataMessageParcel.RewindRead(0);
192 MessageParcel reply;
193 DelayedSingleton<CellularDataService>::GetInstance()->OnClearCellularDataConnections(dataMessageParcel, reply);
194 }
195
GetCellularDataFlowType(const uint8_t * data,size_t size)196 void GetCellularDataFlowType(const uint8_t *data, size_t size)
197 {
198 if (!IsServiceInited()) {
199 return;
200 }
201
202 MessageParcel dataMessageParcel;
203 dataMessageParcel.WriteBuffer(data, size);
204 dataMessageParcel.RewindRead(0);
205 MessageParcel reply;
206 DelayedSingleton<CellularDataService>::GetInstance()->OnGetCellularDataFlowType(dataMessageParcel, reply);
207 }
208
RegisterSimAccountCallback(const uint8_t * data,size_t size)209 void RegisterSimAccountCallback(const uint8_t *data, size_t size)
210 {
211 if (!IsServiceInited()) {
212 return;
213 }
214 MessageParcel dataMessageParcel;
215 dataMessageParcel.WriteBuffer(data, size);
216 dataMessageParcel.RewindRead(0);
217 MessageParcel reply;
218 DelayedSingleton<CellularDataService>::GetInstance()->OnRegisterSimAccountCallback(dataMessageParcel, reply);
219 }
220
UnregisterSimAccountCallback(const uint8_t * data,size_t size)221 void UnregisterSimAccountCallback(const uint8_t *data, size_t size)
222 {
223 if (!IsServiceInited()) {
224 return;
225 }
226 MessageParcel dataMessageParcel;
227 dataMessageParcel.WriteBuffer(data, size);
228 dataMessageParcel.RewindRead(0);
229 MessageParcel reply;
230 DelayedSingleton<CellularDataService>::GetInstance()->OnUnregisterSimAccountCallback(dataMessageParcel, reply);
231 }
232
GetDefaultActReportInfo(const uint8_t * data,size_t size)233 void GetDefaultActReportInfo(const uint8_t *data, size_t size)
234 {
235 if (!IsServiceInited()) {
236 return;
237 }
238 MessageParcel dataMessageParcel;
239 dataMessageParcel.WriteBuffer(data, size);
240 dataMessageParcel.RewindRead(0);
241 MessageParcel reply;
242 DelayedSingleton<CellularDataService>::GetInstance()->OnGetDefaultActReportInfo(dataMessageParcel, reply);
243 }
244
GetInternalActReportInfo(const uint8_t * data,size_t size)245 void GetInternalActReportInfo(const uint8_t *data, size_t size)
246 {
247 if (!IsServiceInited()) {
248 return;
249 }
250 MessageParcel dataMessageParcel;
251 dataMessageParcel.WriteBuffer(data, size);
252 dataMessageParcel.RewindRead(0);
253 MessageParcel reply;
254 DelayedSingleton<CellularDataService>::GetInstance()->OnGetInternalActReportInfo(dataMessageParcel, reply);
255 }
256
DoSomethingInterestingWithMyAPI(const uint8_t * data,size_t size)257 void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
258 {
259 if (data == nullptr || size == 0) {
260 return;
261 }
262
263 OnRemoteRequest(data, size);
264 EnableCellularData(data, size);
265 GetCellularDataState(data, size);
266 IsCellularDataEnabled(data, size);
267 IsCellularDataRoamingEnabled(data, size);
268 GetDefaultCellularDataSlotId(data, size);
269 GetCellularDataFlowType(data, size);
270 EnableCellularDataRoaming(data, size);
271 SetDefaultCellularDataSlotId(data, size);
272 HasInternetCapability(data, size);
273 ClearCellularDataConnections(data, size);
274 RegisterSimAccountCallback(data, size);
275 UnregisterSimAccountCallback(data, size);
276 GetDefaultActReportInfo(data, size);
277 GetInternalActReportInfo(data, size);
278 }
279 } // namespace OHOS
280
281 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)282 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
283 {
284 OHOS::AddDataTokenFuzzer token;
285 /* Run your code on data */
286 OHOS::DoSomethingInterestingWithMyAPI(data, size);
287 OHOS::DelayedSingleton<CellularDataService>::DestroyInstance();
288 return 0;
289 }
290